message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x — the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 ≤ n ≤ 105, 1 ≤ x ≤ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 ≤ ai ≤ 109, ax ≠ 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
# from sys import stdin
# input = stdin.readline
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,6)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
n,x=L()
A=L()
x-=1
if 0 in A[:x]:
cnt=0
while A[x]!=0:
cnt+=1
A[x]-=1
x-=1
A[x]=cnt
elif 0 in A[x+1:]:
cnt=0
for i in range(x+1):
A[i]-=1
cnt+=1
for i in range(n-1,-1,-1):
if A[i]==0:
A[i]+=cnt
break
A[i]-=1
cnt+=1
else:
m=min(A)
idx=-1
for i in range(x,-1,-1):
if A[i]==m:
idx=i
break
if idx==-1:
for i in range(x+1,n):
if A[i]==m:
idx=i
break
cnt=0
print(idx,m)
for i in range(n):
# print(A)
A[i]-=m
cnt+=m
if (idx<=x and idx<=i<=x) or (idx>x and not (x<i<=idx)):
A[i]-=1
# print(A)
cnt+=1
# print(cnt)
A[idx]+=cnt
print(*A)
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
``` | instruction | 0 | 18,844 | 8 | 37,688 |
No | output | 1 | 18,844 | 8 | 37,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x — the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 ≤ n ≤ 105, 1 ≤ x ≤ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 ≤ ai ≤ 109, ax ≠ 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
n,x = map(int, input().split())
a = list(map(int, input().split()))
s = sum(a)
idx = a.index(min(a))
x = x-1
if x>idx:
for i in range(idx):
a[i]-=a[idx]
for i in range(idx+1, n):
a[i]-=(a[idx]+1)
elif x<idx:
for i in range(idx):
a[i]-=(a[idx]+1)
for i in range(idx+1,n):
a[i]-=(a[idx]+1)
elif x==idx:
for i in range(idx):
a[i]-=a[idx]
for i in range(idx+1,n):
a[i]-=a[idx]
s1 = sum(a)-a[idx]
a[idx] = s-s1
print(*a)
``` | instruction | 0 | 18,845 | 8 | 37,690 |
No | output | 1 | 18,845 | 8 | 37,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x — the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 ≤ n ≤ 105, 1 ≤ x ≤ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 ≤ ai ≤ 109, ax ≠ 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
n,x = map(int,input().split())
a = list(map(int,input().split()))
m = min(a)
st = a.index(m)
c = m+1
ct = 0
for i in range(n):
a[st] -= c
ct += c
if(st == x-1): c -= 1
st = (st+1)%n
a[st] = ct-1
print(*a)
``` | instruction | 0 | 18,846 | 8 | 37,692 |
No | output | 1 | 18,846 | 8 | 37,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Vasya had n boxes with balls in the room. The boxes stood in a row and were numbered with numbers from 1 to n from left to right.
Once Vasya chose one of the boxes, let's assume that its number is i, took all balls out from it (it is guaranteed that this box originally had at least one ball), and began putting balls (one at a time) to the boxes with numbers i + 1, i + 2, i + 3 and so on. If Vasya puts a ball into the box number n, then the next ball goes to box 1, the next one goes to box 2 and so on. He did it until he had no balls left in his hands. It is possible that Vasya puts multiple balls to the same box, and it is also possible that one or more balls will go to the box number i. If i = n, Vasya puts the first ball into the box number 1, then the next ball goes to box 2 and so on.
For example, let's suppose that initially Vasya had four boxes, and the first box had 3 balls, the second one had 2, the third one had 5 and the fourth one had 4 balls. Then, if i = 3, then Vasya will take all five balls out of the third box and put them in the boxes with numbers: 4, 1, 2, 3, 4. After all Vasya's actions the balls will lie in the boxes as follows: in the first box there are 4 balls, 3 in the second one, 1 in the third one and 6 in the fourth one.
At this point Vasya has completely forgotten the original arrangement of the balls in the boxes, but he knows how they are arranged now, and the number x — the number of the box, where he put the last of the taken out balls.
He asks you to help to find the initial arrangement of the balls in the boxes.
Input
The first line of the input contains two integers n and x (2 ≤ n ≤ 105, 1 ≤ x ≤ n), that represent the number of the boxes and the index of the box that got the last ball from Vasya, correspondingly. The second line contains n space-separated integers a1, a2, ..., an, where integer ai (0 ≤ ai ≤ 109, ax ≠ 0) represents the number of balls in the box with index i after Vasya completes all the actions.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print n integers, where the i-th one represents the number of balls in the box number i before Vasya starts acting. Separate the numbers in the output by spaces. If there are multiple correct solutions, you are allowed to print any of them.
Examples
Input
4 4
4 3 1 6
Output
3 2 5 4
Input
5 2
3 2 0 2 7
Output
2 1 4 1 6
Input
3 3
2 3 1
Output
1 2 3
Submitted Solution:
```
# arr = list(map(int,input().split()))
# for i in range(1,len(arr)):
# k=arr[i]
# j=i-1
# while j>=0 and arr[j]>k:
# arr[j+1]=arr[j]
# j=j-1
# arr[j+1]=k
# print(arr)
# l=list(map(int,input().split()))
# for i in range(len(l)):
# mid_idx=i
# for j in range(i+1,len(l)):
# if l[mid_idx]>l[j]:
# mid_idx=j
# l[i],l[mid_idx]=l[mid_idx],l[i]
# print(l)
# def merge(l,p,r):
# if p<r:
# q=(p+(r-1))//2
# merge(l,p,q)
# merge(l,q+1,r)
# l=list(map(int,input().split()))
# merge(l,0,len(l)-1)
# for i in range(len(l)):
# print(l[i]
n,k=map(int,input().split())
l=list(map(int,input().split()))
a=l.index(min(l))
m=l[a]+1
c=0
for i in range(n):
l[a]-=m
c+=m
if a==k-1:
m-=1
a=(a+1)%n
m+=1
l[a]=c-1
print(*l)
``` | instruction | 0 | 18,847 | 8 | 37,694 |
No | output | 1 | 18,847 | 8 | 37,695 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,405 | 8 | 38,810 |
"Correct Solution:
```
F = [[[0] * 10 for i in range(3)] for i in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().split())
F[b-1][f-1][r-1] += v
for x in range(0, 4):
for y in range(0, 3):
for z in range(0, 10):
print(" {0}".format(F[x][y][z]), end = '')
print()
if x != 3:
print("#" * 20)
``` | output | 1 | 19,405 | 8 | 38,811 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,406 | 8 | 38,812 |
"Correct Solution:
```
n = int(input())
cnt = [[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]
for _ in range(n):
b, f, r, v = map(int, input().split())
cnt[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
print(' '+' '.join(map(str, cnt[i][j])))
if i != 3:
print('#'*20)
``` | output | 1 | 19,406 | 8 | 38,813 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,407 | 8 | 38,814 |
"Correct Solution:
```
l=[[[0 for i in range(10)] for i in range(3)] for i in range(4)]
n=int(input())
for i in range(n):
a,b,c,d=list(map(int,input().split()))
l[a-1][b-1][c-1]+=d
for i in l[:-1]:
for j in i:
print(" "+" ".join(list(map(str,j))))
print("####################")
for j in l[-1]:
print(" "+" ".join(list(map(str,j))))
``` | output | 1 | 19,407 | 8 | 38,815 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,408 | 8 | 38,816 |
"Correct Solution:
```
rooms = [[[0] * 10 for b in range(3)] for a in range(4)]
n = int(input())
for _ in range(n):
b, f, r, v = map(int, input().split())
rooms[b - 1][f - 1][r - 1] += v
for i in range(4):
for j in range(3):
print(' ' + ' '.join(map(str, rooms[i][j])))
if i < 3:
print('#' * 20)
``` | output | 1 | 19,408 | 8 | 38,817 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,409 | 8 | 38,818 |
"Correct Solution:
```
R=range
I=input
p=print
l=[[[0 for i in R(10)]for j in R(3)]for s in R(4)]
for i in R(int(I())):b,f,r,v=map(int,I().split());l[b-1][f-1][r-1]+=v
for i in R(4):
for k in l[i]:p("",*k)
if i!=3:p("#"*20)
``` | output | 1 | 19,409 | 8 | 38,819 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,410 | 8 | 38,820 |
"Correct Solution:
```
houses = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().split())
houses[b - 1][f - 1][r - 1] += v
for b in range(4):
for f in houses[b]:
print("", *f)
if b != 3:
print("#" * 20)
``` | output | 1 | 19,410 | 8 | 38,821 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,411 | 8 | 38,822 |
"Correct Solution:
```
R=range
l=[[[0 for i in R(10)]for j in R(3)]for s in R(4)]
n=int(input())
for a in range(n):
b,f,r,v=map(int,input().split())
l[b-1][f-1][r-1]+=v
for b in range(4):
for k in l[b]:
print('',*k)
if b<3:
print('#'*20)
``` | output | 1 | 19,411 | 8 | 38,823 |
Provide a correct Python 3 solution for this coding contest problem.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 | instruction | 0 | 19,412 | 8 | 38,824 |
"Correct Solution:
```
a=[[[0 for i in range(10)] for j in range(3)] for k in range(4)]
n=int(input())
for i in range(n):
b,f,r,v=[int(j) for j in input().split()]
a[b-1][f-1][r-1] += v
for i, b in enumerate(a):
for f in b:
for r in f:
print(" {}".format(r),end="")
print()
if i< 3:
print("#"*20)
``` | output | 1 | 19,412 | 8 | 38,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
num = [[[0 for i in range(10)] for i in range(3)] for i in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().split())
num[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(" " + " ".join(map(str, num[b][f])))
if b < 3:
print("#"*20)
``` | instruction | 0 | 19,413 | 8 | 38,826 |
Yes | output | 1 | 19,413 | 8 | 38,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
n=int(input())
a=[[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]
for _ in range(n):
b,f,r,v=map(int,input().split())
a[b-1][f-1][r-1]+=v
for c in range(4):
for d in range(3):print('',*a[c][d])
if c != 3:print('#' *20)
``` | instruction | 0 | 19,414 | 8 | 38,828 |
Yes | output | 1 | 19,414 | 8 | 38,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
tbl = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
n = int(input())
for i in range(n):
b,f,r,v =map(int,input().split())
tbl[b-1][f-1][r-1]+=v
for k in range(4):
for j in range(3):
for i in range(10):
print(f' {tbl[k][j][i]}',end="")
print()
if k<3:
print("#"*20)
``` | instruction | 0 | 19,415 | 8 | 38,830 |
Yes | output | 1 | 19,415 | 8 | 38,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
building = [[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]
n = int(input())
for _ in range(n):
b, f, r, v = map(int, input().split())
building[b-1][f-1][r-1] += v
for i in range(4):
for j in range(3):
print(' ' + ' '.join(map(str, building[i][j])))
if i != 3:
print('#' * 20)
``` | instruction | 0 | 19,416 | 8 | 38,832 |
Yes | output | 1 | 19,416 | 8 | 38,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
N = int(input())
n = [input().split() for _ in range(N)]
all_info = [[["0" for _ in range(10)] for _ in range(3)] for _ in range(4)]
def change_room(info):
info = [int(i) for i in info]
info_dic = {"all_info": all_info,
"buil": info[0]-1,
"loc" : info[1]-1,
"room": info[2]-1,
"num" : str(info[3])}
exec("all_info[buil][loc][room] = num", info_dic)
for i in n:
change_room(i)
for i in all_info:
for j in i:
print(" ".join(j))
print("#"*20)
``` | instruction | 0 | 19,417 | 8 | 38,834 |
No | output | 1 | 19,417 | 8 | 38,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
house = {1:[[0 for i in range(10)] for j in range(3)], 2:[[0 for i in range(10)] for j in range(3)],
3:[[0 for i in range(10)] for j in range(3)], 4:[[0 for i in range(10)] for j in range(3)]}
n = int(input())
for i in range(n):
building, floor, room, people_numbers = [int(j) for j in input().split()]
house[building][floor - 1][room - 1] = people_numbers
partition = "#"*20
for i in range(4):
for j in range(3):
tmp_list = [str(tmp) for tmp in house[i + 1][j]]
print(" {}".format(" ".join(tmp_list)))
if j == 2 and i != 3: print(partition)
``` | instruction | 0 | 19,418 | 8 | 38,836 |
No | output | 1 | 19,418 | 8 | 38,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
N = int(input())
buildings = [[[0]*10]*3]*4
for i in range(N):
b, f, r, num = map(int, input().split())
buildings[b-1][f-1][r-1] += num
for i in range(4):
for j in range(3):
for k in range(10):
print(" {0}".format(buildings[k][j][i]), end="")
print()
if i!=3:
print("####################")
``` | instruction | 0 | 19,419 | 8 | 38,838 |
No | output | 1 | 19,419 | 8 | 38,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You manage 4 buildings, each of which has 3 floors, each of which consists of 10 rooms. Write a program which reads a sequence of tenant/leaver notices, and reports the number of tenants for each room.
For each notice, you are given four integers b, f, r and v which represent that v persons entered to room r of fth floor at building b. If v is negative, it means that −v persons left.
Assume that initially no person lives in the building.
Constraints
* No incorrect building, floor and room numbers are given.
* 0 ≤ the number of tenants during the management ≤ 9
Input
In the first line, the number of notices n is given. In the following n lines, a set of four integers b, f, r and v which represents ith notice is given in a line.
Output
For each building, print the information of 1st, 2nd and 3rd floor in this order. For each floor information, print the number of tenants of 1st, 2nd, .. and 10th room in this order. Print a single space character before the number of tenants. Print "####################" (20 '#') between buildings.
Example
Input
3
1 1 3 8
3 2 2 7
4 3 8 1
Output
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
####################
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
Submitted Solution:
```
residents = [[[0] * 11 for i in range(4)] for j in range(5)]
N = int(input())
for _i in range(N):
b, f, r, v = map(int, input().split())
residents[b][f][r] += v
for i in range(1, 5):
for j in range(1, 4):
print(' '.join(map(str, residents[i][j][1:])))
if not i == 4:
print(''.join(['#'] * 20))
``` | instruction | 0 | 19,420 | 8 | 38,840 |
No | output | 1 | 19,420 | 8 | 38,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,609 | 8 | 39,218 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
class UnionFind(object):
__slots__ = ['nodes']
def __init__(self, n: int):
self.nodes = [-1] * n
def find(self, x: int) -> int:
if self.nodes[x] < 0:
return x
else:
self.nodes[x] = self.find(self.nodes[x])
return self.nodes[x]
def unite(self, x: int, y: int) -> bool:
root_x, root_y, nodes = self.find(x), self.find(y), self.nodes
if root_x != root_y:
if nodes[root_x] > nodes[root_y]:
root_x, root_y = root_y, root_x
nodes[root_x] += nodes[root_y]
nodes[root_y] = root_x
return root_x != root_y
def size(self, x: int) -> int:
return -self.nodes[self.find(x)]
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
real = list(range(m + 1))
indexes = [[] for _ in range(m + 1)]
uf = UnionFind(m + 1)
difficulty = 0
for i, x in enumerate(a):
indexes[x].append(i)
if i > 0 and a[i - 1] != a[i]:
difficulty += 1
ans = [difficulty] + [0] * (m - 1)
for qi, (u, v) in enumerate((map(int, input().split()) for _ in range(m - 1)), start=1):
x, y = uf.find(u), uf.find(v)
if uf.size(x) > uf.size(y):
x, y = y, x
real_x, real_y = real[x], real[y]
for i in indexes[real_x]:
if i > 0 and a[i - 1] == real_y:
difficulty -= 1
if i < n - 1 and a[i + 1] == real_y:
difficulty -= 1
for i in indexes[real_x]:
a[i] = real_y
indexes[real_y] += indexes[real_x]
indexes[real_x].clear()
uf.unite(x, y)
real[uf.find(x)] = real_y
ans[qi] = difficulty
sys.stdout.buffer.write('\n'.join(map(str, ans)).encode('utf-8'))
if __name__ == '__main__':
main()
``` | output | 1 | 19,609 | 8 | 39,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,610 | 8 | 39,220 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
M1 = lambda s: int(s)-1
N, M = map(int, input().split())
e = [-1] * N
def find(x):
if e[x] < 0: return x
e[x] = find(e[x])
return e[x]
def join(a, b):
a, b = find(a), find(b)
if a == b: return
if e[a] > e[b]: a, b = b, a
e[a] += e[b]
e[b] = a
T = [[] for _ in range(M)]
diff = N-1
for i, v in enumerate(map(M1, input().split())):
if T[v]:
join(T[v][0], i)
if T[v][-1] + 1 == i: diff -= 1
T[v].append(i)
ans = [str(diff)]
for _ in range(M-1):
i, j = map(M1, input().split())
a, b = T[i], T[j]
if len(a) < len(b):
a, b = b, a
ra = find(a[0])
for v in b:
if v > 0 and find(v-1) == ra: diff -= 1
if v < N-1 and find(v+1) == ra: diff -= 1
ans.append(str(diff))
join(ra, v)
a.extend(b)
T[i] = T[j] = a
print('\n'.join(ans))
``` | output | 1 | 19,610 | 8 | 39,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,611 | 8 | 39,222 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class LCA:
# 頂点は0～n-1
# costは問題によって違うのでそのたび修正(__dfsとcost)
def __init__(self, to, root=0):
self.memo = {}
self.to = to
self.n = len(to)
self.parents = [-1] * (self.n + 1)
self.depth = [0] * self.n
# self.costtor = [-1] * self.n
self.__dfs(root)
self.max_level = max(self.depth).bit_length()
self.ancestor = [self.parents] + [[-1] * (self.n + 1) for _ in range(self.max_level)]
row0 = self.ancestor[0]
for lv in range(self.max_level):
row1 = self.ancestor[lv + 1]
for u in range(self.n):
row1[u] = row0[row0[u]]
row0 = row1
def __dfs(self, root):
# self.costtor[root]=mint(1)
stack = [root]
while stack:
u = stack.pop()
pu = self.parents[u]
du = self.depth[u]
# cost=self.costtor[u]
for v in self.to[u]:
if v == pu: continue
self.parents[v] = u
self.depth[v] = du + 1
# self.costtor[v]=cost*c
stack.append(v)
# 最小共通祖先
def anc(self, u, v):
diff = self.depth[u] - self.depth[v]
if diff < 0: u, v = v, u
if (u, v) in self.memo: return self.memo[u, v]
diff = abs(diff)
lv = 0
while diff:
if diff & 1: u = self.ancestor[lv][u]
lv, diff = lv + 1, diff >> 1
if u == v: self.memo[u, v] = u;return u
for lv in range(self.depth[u].bit_length() - 1, -1, -1):
anclv = self.ancestor[lv]
if anclv[u] != anclv[v]: u, v = anclv[u], anclv[v]
self.memo[u, v] = self.parents[u]
return self.parents[u]
n, m = MI()
tt = LI1()
pos = list(range(m))
to = [[] for _ in range(2 * m - 1)]
for i in range(m, 2 * m - 1):
u, v = MI1()
pu = pos[u]
pv = pos[v]
to[i].append(pu)
to[i].append(pv)
pos[u] = i
#print(to)
lca=LCA(to,2*m-2)
cnt=[0]*m
for t0,t1 in zip(tt,tt[1:]):
if t0==t1:cnt[0]+=1
else:
a=lca.anc(t0,t1)-m+1
cnt[a]+=1
#print(cnt)
ans=n-1
for c in cnt:
ans-=c
print(ans)
``` | output | 1 | 19,611 | 8 | 39,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,612 | 8 | 39,224 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
class Dsu:
def __init__(self, _n):
self.n = _n
self.p = [-1] * _n
def get(self, v):
if self.p[v] == -1:
return v
self.p[v] = self.get(self.p[v])
return self.p[v]
def unite(self, v, u):
v = self.get(v)
u = self.get(u)
if v == u:
return
self.p[v] = u
n, m = map(int, input().split())
real = Dsu(m)
a = list(map(lambda x: int(x) - 1, input().split()))
idxs = [[] for i in range(n)]
for i in range(n):
idxs[a[i]].append(i)
ans = 0
for i in range(1, n):
if a[i] != a[i - 1]:
ans += 1
print(ans)
for _ in range(1, m):
v, u = map(lambda x: int(x) - 1, input().split())
v = real.get(v)
u = real.get(u)
if len(idxs[v]) > len(idxs[u]):
v, u = u, v
real.unite(v, u)
if v != u:
for i in idxs[v]:
if i >= 1 and a[i] == v and a[i - 1] == u:
ans -= 1
if i + 1 < n and a[i] == v and a[i + 1] == u:
ans -= 1
for i in idxs[v]:
idxs[u].append(i)
a[i] = u;
print(ans)
``` | output | 1 | 19,612 | 8 | 39,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,613 | 8 | 39,226 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
class UnionFindNode:
def __init__(self, group_id, parent=None):
self.group_id_ = group_id
self.parent_ = parent
self.ts = []
def is_root(self):
return not self.parent_
def root(self):
parent = self
while not parent.is_root():
parent = parent.parent_
self.parent_ = parent
return parent
def find(self):
root = self.root()
return root.group_id_
def unite(self, unite_node):
root = self.root()
unite_root = unite_node.root()
if len(root.ts) > len(unite_root.ts):
n_root, child = root, unite_root
else:
n_root, child = unite_root, root
c = 0
for x in child.ts:
x = nodes[x].root().group_id_
if x == n_root.group_id_:
c += 1
continue
n_root.ts.append(x)
child.parent_ = n_root
return c
if __name__ == "__main__":
import sys;input=sys.stdin.readline
N, M = map(int, input().split())
X = list(map(int, input().split()))
nodes = [UnionFindNode(i) for i in range(M)]
for i in range(N-1):
if X[i] != X[i+1]:
x = nodes[X[i]-1]
y = nodes[X[i+1]-1]
x.ts.append(X[i+1]-1)
y.ts.append(X[i]-1)
R = 0
for i in range(M):
R += len(nodes[i].ts)
R = R//2
print(R)
for _ in range(M-1):
a, b = map(int, input().split())
a, b = nodes[a-1], nodes[b-1]
R -= a.unite(b)
print(R)
``` | output | 1 | 19,613 | 8 | 39,227 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,614 | 8 | 39,228 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import sys
input=sys.stdin.readline
n,m=map(int,input().split())
a=[int(x) for x in input().split()]
s=[set() for i in range(m+1)]
for i in range(n):
s[a[i]].add(i+1)
f=[0]*(m+2)
for i in range(m+1):
f[i]=i
def fin(x):
if f[x]==x:
return x
f[x]=fin(f[x])
return f[x]
ans=0
for i in range(1,m+1):
for j in s[i]:
if j in s[i] and j-1 in s[i]:
ans+=1
out=[n-ans-1]
for i in range(m-1):
x,y=map(int,input().split())
x=fin(x)
y=fin(y)
if len(s[x])<len(s[y]):
x,y=y,x
for i in s[y]:
if i in s[y] and i-1 in s[x]:
ans+=1
if i in s[y] and i+1 in s[x]:
ans+=1
out.append(n-ans-1)
s[x]|=s[y]
f[y]=x
print ('\n'.join(str(x) for x in out))
``` | output | 1 | 19,614 | 8 | 39,229 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,615 | 8 | 39,230 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
import io, os
import sys
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
n,m=map(int,input().split())
A=list(map(int,input().split()))
#Q=[tuple(map(int,input().split())) for i in range(m-1)]
ANS=n-1
for i in range(n-1):
if A[i]==A[i+1]:
ANS-=1
SET=[set() for i in range(m+1)]
for i in range(n):
SET[A[i]].add(i)
A=[ANS]
for tests in range(m-1):
x,y=map(int,input().split())
if len(SET[x])<=len(SET[y]):
for j in SET[x]:
if j-1 in SET[y]:
ANS-=1
if j+1 in SET[y]:
ANS-=1
SET[y]|=SET[x]
SET[x]=SET[y]
else:
for j in SET[y]:
if j-1 in SET[x]:
ANS-=1
if j+1 in SET[x]:
ANS-=1
SET[x]|=SET[y]
SET[y]=SET[x]
A.append(ANS)
print("\n".join(map(str,A)))
main()
``` | output | 1 | 19,615 | 8 | 39,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1]. | instruction | 0 | 19,616 | 8 | 39,232 |
Tags: data structures, dsu, implementation, trees
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa=ifa[::-1]
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def binfun(x):
c=0
for w in arr:
c+=ceil(w/x)
return c
def lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
'''
class SMT:
def __init__(self,arr):
self.n=len(arr)-1
self.arr=[0]*(self.n<<2)
self.lazy=[0]*(self.n<<2)
def Build(l,r,rt):
if l==r:
self.arr[rt]=arr[l]
return
m=(l+r)>>1
Build(l,m,rt<<1)
Build(m+1,r,rt<<1|1)
self.pushup(rt)
Build(1,self.n,1)
def pushup(self,rt):
self.arr[rt]=self.arr[rt<<1]+self.arr[rt<<1|1]
def pushdown(self,rt,ln,rn):#lr,rn表区间数字数
if self.lazy[rt]:
self.lazy[rt<<1]+=self.lazy[rt]
self.lazy[rt<<1|1]=self.lazy[rt]
self.arr[rt<<1]+=self.lazy[rt]*ln
self.arr[rt<<1|1]+=self.lazy[rt]*rn
self.lazy[rt]=0
def update(self,L,R,c,l=1,r=None,rt=1):#L,R表示操作区间
if r==None: r=self.n
if L<=l and r<=R:
self.arr[rt]+=c*(r-l+1)
self.lazy[rt]+=c
return
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
if L<=m: self.update(L,R,c,l,m,rt<<1)
if R>m: self.update(L,R,c,m+1,r,rt<<1|1)
self.pushup(rt)
def query(self,L,R,l=1,r=None,rt=1):
if r==None: r=self.n
#print(L,R,l,r,rt)
if L<=l and R>=r:
return self.arr[rt]
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
ans=0
if L<=m: ans+=self.query(L,R,l,m,rt<<1)
if R>m: ans+=self.query(L,R,m+1,r,rt<<1|1)
return ans
'''
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]<self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
for v in graph[u]:
if v not in d or d[v]>d[u]+graph[u][v]:
d[v]=d[u]+graph[u][v]
heappush(heap,(d[v],v))
return d
def GP(it): return [(ch,len(list(g))) for ch,g in groupby(it)]
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
@bootstrap
def dfs(x,y):
global T
tin[x]=T
T+=1
up[x][0]=y
for i in range(1,19):
up[x][i]=up[up[x][i-1]][i-1]
for ch in g[x]:
yield dfs(ch,x)
tout[x]=T
T+=1
yield None
def isa(x,y):
return tin[x]<=tin[y] and tout[x]>=tout[y]
def lca(x,y):
#print('lci',x,y)
if(isa(x,y)):
return x
for i in range(18,-1,-1):
if not isa(up[x][i],y):
x=up[x][i]
#print('lc',x,y)
return up[x][0]
t=1
for i in range(t):
n,m=RL()
t=RLL()
idx=[0]*n
for i in range(n):
idx[i]=t[i]-1
cur=list(range(m))
g=[[] for i in range(2*m-1)]
for i in range(m-1):
x,y=RL()
x-=1
y-=1
nidx=m+i
g[nidx].append(cur[x])
g[nidx].append(cur[y])
cur[x]=nidx
root=2*m-2
tin=[0]*(2*m-1)
tout=[0]*(2*m-1)
up=[[0]*19 for i in range(2*m-1)]
T=0
dfs(root,root)
psum=[0]*m
for i in range(n-1):
lc=lca(idx[i],idx[i+1])
#print(idx[i],idx[i+1],lc)
if lc<m:
psum[0]+=1
else:
psum[lc-m+1]+=1
for i in range(m-1):
print(n-1-psum[i])
psum[i+1]+=psum[i]
print(n-1-psum[m-1])
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
``` | output | 1 | 19,616 | 8 | 39,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
T = list(map(int, input().split()))
ans = N-1
S = [set() for _ in range(M+1)]
for i, t in enumerate(T):
S[t].add(i+1)
for i in range(1, M+1):
for x in S[i]:
if x+1 in S[i]:
ans -= 1
print(ans)
for _ in range(M-1):
a, b = map(int, input().split())
if len(S[a]) < len(S[b]):
S[a], S[b] = S[b], S[a]
for x in S[b]:
if x-1 in S[a]:
ans -= 1
if x+1 in S[a]:
ans -= 1
for x in S[b]:
S[a].add(x)
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 19,617 | 8 | 39,234 |
Yes | output | 1 | 19,617 | 8 | 39,235 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
class UnionFind():
# 作りたい要素数nで初期化
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
# ノードxのrootノードを見つける
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
# 木の併合、入力は併合したい各ノード
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
# ノードxが属する木のサイズ
def Count(self, x):
return -self.root[self.Find_Root(x)]
import sys
input = sys.stdin.buffer.readline
N, M = map(int, input().split())
T = list(map(int, input().split()))
Query = [list(map(int, input().split())) for _ in range(M-1)]
uni = UnionFind(M)
dic = {}
for i, t in enumerate(T):
if t in dic:
dic[t].add(i)
else:
dic[t] = {i}
uniToKey = [i for i in range(M+1)]
ans = N-1
for L in dic.values():
for node in L:
if node - 1 in L:
ans -= 1
print(ans)
for a, b in Query:
a = uni.Find_Root(a)
b = uni.Find_Root(b)
ka = uniToKey[a]
kb = uniToKey[b]
if len(dic[ka]) < len(dic[kb]):
newkey = kb
for node in dic[ka]:
if node - 1 in dic[kb]:
ans -= 1
if node + 1 in dic[kb]:
ans -= 1
for node in dic[ka]:
dic[kb].add(node)
else:
newkey = ka
for node in dic[kb]:
if node - 1 in dic[ka]:
ans -= 1
if node + 1 in dic[ka]:
ans -= 1
for node in dic[kb]:
dic[ka].add(node)
uni.Unite(a, b)
r = uni.Find_Root(a)
uniToKey[r] = newkey
print(ans)
``` | instruction | 0 | 19,618 | 8 | 39,236 |
Yes | output | 1 | 19,618 | 8 | 39,237 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
import sys
def input():
return sys.stdin.readline().rstrip()
def input_split():
return [int(i) for i in input().split()]
n,m = input_split()
indices = input_split()
towers = [[] for i in range(m)]
for i in range(n):
ind = indices[i] - 1
towers[ind].append(i) #indth tower has disc i
#towers[i] is in ascending order
jumps = [0 for i in range(m)] #for each tower
for i in range(m):
temp = towers[i]
for j in range(1, len(temp)):
if temp[j] != temp[j-1] + 1:
jumps[i] += 1
answers = [sum(jumps) - 1 + m]
new_towers = [set(towers[i]) for i in range(m)]
# max_towers = [max(new_towers[i]) for i in range(m)]
queries = []
for _ in range(m-1):
# print(new_towers)
# breakpoint()
a, b = input_split()
a -= 1
b -= 1
queries.append((a,b))
# print()
# print('original towers are {}'.format(new_towers))
# print('original ans is {}'.format(answers[-1]))
# print()
for (a,b) in queries:
orig_a, orig_b = a, b
swapped = False
if len(new_towers[a]) < len(new_towers[b]):
pass
else:
b, a = a, b
swapped = True
# print('SWAPPED')
#insert from a to b
new_gaps = 0
for el in new_towers[a]:
# print('el is {}'.format(el))
if el == 0:
# print('c')
# print('h1')
if 1 in new_towers[b]:
new_gaps -= 0 #unchanged
else:
new_gaps += 1
elif el == n-1:
# print('h2')
if n-2 in new_towers[b]:
new_gaps -= 0 #unchanged
else:
new_gaps += 1
else:
# print('h3')
if el -1 in new_towers[b] and el + 1 in new_towers[b]:
# print('c1')
new_gaps -= 1
elif el -1 in new_towers[b] or el + 1 in new_towers[b]:
# print('c2')
new_gaps += 0 #unchanged
else:
# print('c3')
new_gaps += 1
new_towers[b].add(el)
jumps_in_new_tower = jumps[b] + new_gaps
answers.append(answers[-1] - (jumps[a] + jumps[b] + 2) + (jumps_in_new_tower + 1))
# print('merging tower a = {} and b = {} to pos a '.format(orig_a,orig_b))
# print('new gaps is {} and jumps in new tower: {}'.format(new_gaps, jumps_in_new_tower))
# print('after change towers look like {}'.format(new_towers))
# print('to fix we need {}'.format(answers[-1]))
# print()
jumps[orig_a] = jumps_in_new_tower
if not swapped:
new_towers[a] = new_towers[b]
print(*answers, sep = '\n')
# testCases = int(input())
# answers = []
# for _ in range(testCases):
#take input
# answers.append(ans)
# print(*answers, sep = '\n')
``` | instruction | 0 | 19,619 | 8 | 39,238 |
Yes | output | 1 | 19,619 | 8 | 39,239 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
def get_ints():
return map(int, input().split())
def main():
_, m = get_ints()
s = [set() for _ in range(m)]
prev, score = -1, -1
for index, dest in enumerate(get_ints()):
s[dest - 1].add(index)
if prev != dest:
score += 1
prev = dest
ans = [score]
for _ in range(m - 1):
x, y = get_ints()
x, y = x - 1, y - 1
target = x
if len(s[x]) < len(s[y]):
x, y = y, x
for e in s[y]:
if e - 1 in s[x]:
score -= 1
if e + 1 in s[x]:
score -= 1
for e in s[y]:
s[x].add(e)
s[target] = s[x]
ans.append(score)
print(*ans, sep='\n')
main()
``` | instruction | 0 | 19,620 | 8 | 39,240 |
Yes | output | 1 | 19,620 | 8 | 39,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
import math
value = input().split()
n, m = int(value[0]), int(value[1])
value = input().split()
vlist = []
for v in value:
if len(vlist) == 0:
vlist.append(v)
else:
if v is not vlist[-1]:
vlist.append(v)
print(len(vlist)-1)
for i in range(1,m):
value = input().split()
tlist = []
for v in vlist:
if v is value[1]:
v = value[0]
if len(tlist) == 0:
tlist.append(v)
else:
if v is not tlist[-1]:
tlist.append(v)
vlist = tlist
print(len(vlist)-1)
``` | instruction | 0 | 19,621 | 8 | 39,242 |
No | output | 1 | 19,621 | 8 | 39,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
class Node:
def __init__(self, value, left, right, parent, h, ind):
self.value = value
self.left = left
self.right = right
self.parent = parent
self.h = h
self.ind = ind
def merge_query_ind(tower_to_leaf, tower_1, tower_2):
node_1 = tower_to_leaf[tower_1]
node_2 = tower_to_leaf[tower_2]
while node_1.h > node_2.h:
node_1 = node_1.parent
while node_1.h < node_2.h:
node_2 = node_2.parent
while node_1 != node_2:
node_1 = node_1.parent
node_2 = node_2.parent
return node_1.ind
def make_queries_tree(m, queries):
tower_to_leaf = [None] * (m + 1)
root = Node(queries[-1][0], None, None, None, 0, len(queries))
tower_to_leaf[queries[-1][0]] = root
tower_to_leaf[queries[-1][1]] = root
query_ind = len(queries) - 1
for query in queries[::-1]:
node = tower_to_leaf[query[0]]
node.left = Node(query[0], None, None, node, node.h + 1, query_ind)
tower_to_leaf[query[0]] = node.left
node.right = Node(query[1], None, None, node, node.h + 1, query_ind)
tower_to_leaf[query[1]] = node.right
query_ind -= 1
return tower_to_leaf
def merge_disks(n, m, disks, queries):
complexity_diffs = [0] * m
tower_to_leaf = make_queries_tree(m, queries)
for i in range(2, len(disks)):
if disks[i - 1] != disks[i]:
complexity_diffs[merge_query_ind(tower_to_leaf, disks[i - 1], disks[i])] += 1
complexities = complexity_diffs
cur_sum = 0
for i in range(len(complexities) - 1, -1, -1):
t = complexities[i]
complexities[i] = cur_sum
cur_sum += t
return complexities
n, m = map(int, input().split())
disks = [-1] + [int(i) for i in input().split()]
queries = [None] * (m - 1)
for i in range(m - 1):
queries[i] = tuple(int(i) for i in input().split())
complexities = merge_disks(n, m, disks, queries)
print(*complexities, sep='\n')
``` | instruction | 0 | 19,622 | 8 | 39,244 |
No | output | 1 | 19,622 | 8 | 39,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
n, m = map(int, input().split())
towers = list(map(int, input().split()))
parent = [0 for i in range(m+1)]
rank = [0 for i in range(m+1)]
for i in range(1,m+1):
parent[i] = i
rank[i] = 1
def find(x):
if parent[x] == x:
return x
else:
p = find(parent[x])
parent[x] = p
return p
def union(x, y):
p_x = find(x)
p_y = find(y)
if p_x != p_y:
if rank[p_x] > rank[p_y]:
parent[p_y] = p_x
elif rank[p_x] == rank[p_y]:
parent[p_y] = p_x
rank[p_x] += 1
else:
parent[p_x] = p_y
count = 0
for i in range(n-1):
if towers[i] != towers[i+1]:
count += 1
print(count)
for j in range(m-1):
a, b = map(int, input().split())
union(a, b)
count = 0
n_towers = []
same = False
for i in range(len(n_towers)):
if find(towers[i]) != find(towers[i+1]):
count += 1
n_towers.append(towers[i])
same = False
else:
if not same:
n_towers.append(towers[i])
same = True
towers = n_towers
print(count)
``` | instruction | 0 | 19,623 | 8 | 39,246 |
No | output | 1 | 19,623 | 8 | 39,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a set of n discs, the i-th disc has radius i. Initially, these discs are split among m towers: each tower contains at least one disc, and the discs in each tower are sorted in descending order of their radii from bottom to top.
You would like to assemble one tower containing all of those discs. To do so, you may choose two different towers i and j (each containing at least one disc), take several (possibly all) top discs from the tower i and put them on top of the tower j in the same order, as long as the top disc of tower j is bigger than each of the discs you move. You may perform this operation any number of times.
For example, if you have two towers containing discs [6, 4, 2, 1] and [8, 7, 5, 3] (in order from bottom to top), there are only two possible operations:
* move disc 1 from the first tower to the second tower, so the towers are [6, 4, 2] and [8, 7, 5, 3, 1];
* move discs [2, 1] from the first tower to the second tower, so the towers are [6, 4] and [8, 7, 5, 3, 2, 1].
Let the difficulty of some set of towers be the minimum number of operations required to assemble one tower containing all of the discs. For example, the difficulty of the set of towers [[3, 1], [2]] is 2: you may move the disc 1 to the second tower, and then move both discs from the second tower to the first tower.
You are given m - 1 queries. Each query is denoted by two numbers a_i and b_i, and means "merge the towers a_i and b_i" (that is, take all discs from these two towers and assemble a new tower containing all of them in descending order of their radii from top to bottom). The resulting tower gets index a_i.
For each k ∈ [0, m - 1], calculate the difficulty of the set of towers after the first k queries are performed.
Input
The first line of the input contains two integers n and m (2 ≤ m ≤ n ≤ 2 ⋅ 10^5) — the number of discs and the number of towers, respectively.
The second line contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ m), where t_i is the index of the tower disc i belongs to. Each value from 1 to m appears in this sequence at least once.
Then m - 1 lines follow, denoting the queries. Each query is represented by two integers a_i and b_i (1 ≤ a_i, b_i ≤ m, a_i ≠ b_i), meaning that, during the i-th query, the towers with indices a_i and b_i are merged (a_i and b_i are chosen in such a way that these towers exist before the i-th query).
Output
Print m integers. The k-th integer (0-indexed) should be equal to the difficulty of the set of towers after the first k queries are performed.
Example
Input
7 4
1 2 3 3 1 4 3
3 1
2 3
2 4
Output
5
4
2
0
Note
The towers in the example are:
* before the queries: [[5, 1], [2], [7, 4, 3], [6]];
* after the first query: [[2], [7, 5, 4, 3, 1], [6]];
* after the second query: [[7, 5, 4, 3, 2, 1], [6]];
* after the third query, there is only one tower: [7, 6, 5, 4, 3, 2, 1].
Submitted Solution:
```
import math
value = input().split()
n, m = int(value[0]), int(value[1])
value = input().split()
vlist = []
for v in value:
if len(vlist) == 0:
vlist.append(v)
else:
if v != vlist[-1]:
vlist.append(v)
print(len(vlist)-1)
for i in range(1,m):
value = input().split()
tlist = []
for v in vlist:
if v is value[1]:
v = value[0]
if len(tlist) == 0:
tlist.append(v)
else:
if v != tlist[-1]:
tlist.append(v)
vlist = tlist
print(len(vlist)-1)
``` | instruction | 0 | 19,624 | 8 | 39,248 |
No | output | 1 | 19,624 | 8 | 39,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao has a monitor. The screen of the monitor has horizontal to vertical length ratio a:b. Now he is going to watch a movie. The movie's frame has horizontal to vertical length ratio c:d. Manao adjusts the view in such a way that the movie preserves the original frame ratio, but also occupies as much space on the screen as possible and fits within it completely. Thus, he may have to zoom the movie in or out, but Manao will always change the frame proportionally in both dimensions.
Calculate the ratio of empty screen (the part of the screen not occupied by the movie) to the total screen size. Print the answer as an irreducible fraction p / q.
Input
A single line contains four space-separated integers a, b, c, d (1 ≤ a, b, c, d ≤ 1000).
Output
Print the answer to the problem as "p/q", where p is a non-negative integer, q is a positive integer and numbers p and q don't have a common divisor larger than 1.
Examples
Input
1 1 3 2
Output
1/3
Input
4 3 2 2
Output
1/4
Note
Sample 1. Manao's monitor has a square screen. The movie has 3:2 horizontal to vertical length ratio. Obviously, the movie occupies most of the screen if the width of the picture coincides with the width of the screen. In this case, only 2/3 of the monitor will project the movie in the horizontal dimension: <image>
Sample 2. This time the monitor's width is 4/3 times larger than its height and the movie's frame is square. In this case, the picture must take up the whole monitor in the vertical dimension and only 3/4 in the horizontal dimension: <image> | instruction | 0 | 19,731 | 8 | 39,462 |
Tags: greedy, math, number theory
Correct Solution:
```
import math
a,b,c,d=map(int,input().split())
def gcd(a,b):
m=a*b
while(b):
a,b=b,a%b
return(m//a)
q=a
w=b
e=c
r=d
c1=gcd(a,c)
mbf=c1/a
b=b*mbf
mdf=c1/c
d=d*mdf
up1=b-d
do1=b
ch1=up1/do1
a=q
b=w
c=e
d=r
c2=gcd(b,d)
#print(c2)
maf=c2/b
##print(maf)
a=a*maf
mdf=c2/d
c=c*mdf
up2=a-c
do2=a
#print(a,c,up2)
ch2=up2/do2
if(ch1<0):
ch1=999999999999999
if(ch2<0):
ch2=999999999999999
if(up1==0):
do1=1
if(up2==0):
do2=1
#print(a,b,c,d,up1,do1,up2,do2,ch1,ch2)
if(ch1<ch2):
i=2
while(i<=int(min(up1,do1))+1):
if(up1%i==0 and do1%i==0):
up1=up1//i
do1=do1//i
else:
i=i+1
print(int(up1),"/",int(do1),sep="")
else:
i=2
while(i<=int(min(up2,do2))+1):
#print(up2%i,do2%i,"kihfdhu")
if(up2%i==0 and do2%i==0):
up2=up2//i
do2=do2//i
#print(i,up2,do2,"popi")
else:
i=i+1
print(int(up2),"/",int(do2),sep="")
``` | output | 1 | 19,731 | 8 | 39,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao has a monitor. The screen of the monitor has horizontal to vertical length ratio a:b. Now he is going to watch a movie. The movie's frame has horizontal to vertical length ratio c:d. Manao adjusts the view in such a way that the movie preserves the original frame ratio, but also occupies as much space on the screen as possible and fits within it completely. Thus, he may have to zoom the movie in or out, but Manao will always change the frame proportionally in both dimensions.
Calculate the ratio of empty screen (the part of the screen not occupied by the movie) to the total screen size. Print the answer as an irreducible fraction p / q.
Input
A single line contains four space-separated integers a, b, c, d (1 ≤ a, b, c, d ≤ 1000).
Output
Print the answer to the problem as "p/q", where p is a non-negative integer, q is a positive integer and numbers p and q don't have a common divisor larger than 1.
Examples
Input
1 1 3 2
Output
1/3
Input
4 3 2 2
Output
1/4
Note
Sample 1. Manao's monitor has a square screen. The movie has 3:2 horizontal to vertical length ratio. Obviously, the movie occupies most of the screen if the width of the picture coincides with the width of the screen. In this case, only 2/3 of the monitor will project the movie in the horizontal dimension: <image>
Sample 2. This time the monitor's width is 4/3 times larger than its height and the movie's frame is square. In this case, the picture must take up the whole monitor in the vertical dimension and only 3/4 in the horizontal dimension: <image> | instruction | 0 | 19,734 | 8 | 39,468 |
Tags: greedy, math, number theory
Correct Solution:
```
def gcd(a,b):
if a== 0:
return b
return gcd(b%a,a)
a,b,c,d = map(int,input().strip().split())
nr , dr = 0, 0
if a/b == c/d:
print("0/1")
elif a/b > c/d:
nr = a*d - b*c
dr = a*d
commDiv = gcd(nr,dr)
print(str(nr//commDiv) + "/" + str(dr//commDiv))
else:
nr = b*c - a*d
dr = b*c
commDiv = gcd(nr,dr)
print(str(nr//commDiv) + "/" + str(dr//commDiv))
``` | output | 1 | 19,734 | 8 | 39,469 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao has a monitor. The screen of the monitor has horizontal to vertical length ratio a:b. Now he is going to watch a movie. The movie's frame has horizontal to vertical length ratio c:d. Manao adjusts the view in such a way that the movie preserves the original frame ratio, but also occupies as much space on the screen as possible and fits within it completely. Thus, he may have to zoom the movie in or out, but Manao will always change the frame proportionally in both dimensions.
Calculate the ratio of empty screen (the part of the screen not occupied by the movie) to the total screen size. Print the answer as an irreducible fraction p / q.
Input
A single line contains four space-separated integers a, b, c, d (1 ≤ a, b, c, d ≤ 1000).
Output
Print the answer to the problem as "p/q", where p is a non-negative integer, q is a positive integer and numbers p and q don't have a common divisor larger than 1.
Examples
Input
1 1 3 2
Output
1/3
Input
4 3 2 2
Output
1/4
Note
Sample 1. Manao's monitor has a square screen. The movie has 3:2 horizontal to vertical length ratio. Obviously, the movie occupies most of the screen if the width of the picture coincides with the width of the screen. In this case, only 2/3 of the monitor will project the movie in the horizontal dimension: <image>
Sample 2. This time the monitor's width is 4/3 times larger than its height and the movie's frame is square. In this case, the picture must take up the whole monitor in the vertical dimension and only 3/4 in the horizontal dimension: <image> | instruction | 0 | 19,736 | 8 | 39,472 |
Tags: greedy, math, number theory
Correct Solution:
```
def main():
from fractions import Fraction
(a, b, c, d) = map(int, input().split(' '))
f = Fraction(a * d - b * c, a * d)
if a * d <= b * c:
f = Fraction(b * c - a * d, b * c)
print('{}/{}'.format(f.numerator, f.denominator))
main()
``` | output | 1 | 19,736 | 8 | 39,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Manao has a monitor. The screen of the monitor has horizontal to vertical length ratio a:b. Now he is going to watch a movie. The movie's frame has horizontal to vertical length ratio c:d. Manao adjusts the view in such a way that the movie preserves the original frame ratio, but also occupies as much space on the screen as possible and fits within it completely. Thus, he may have to zoom the movie in or out, but Manao will always change the frame proportionally in both dimensions.
Calculate the ratio of empty screen (the part of the screen not occupied by the movie) to the total screen size. Print the answer as an irreducible fraction p / q.
Input
A single line contains four space-separated integers a, b, c, d (1 ≤ a, b, c, d ≤ 1000).
Output
Print the answer to the problem as "p/q", where p is a non-negative integer, q is a positive integer and numbers p and q don't have a common divisor larger than 1.
Examples
Input
1 1 3 2
Output
1/3
Input
4 3 2 2
Output
1/4
Note
Sample 1. Manao's monitor has a square screen. The movie has 3:2 horizontal to vertical length ratio. Obviously, the movie occupies most of the screen if the width of the picture coincides with the width of the screen. In this case, only 2/3 of the monitor will project the movie in the horizontal dimension: <image>
Sample 2. This time the monitor's width is 4/3 times larger than its height and the movie's frame is square. In this case, the picture must take up the whole monitor in the vertical dimension and only 3/4 in the horizontal dimension: <image> | instruction | 0 | 19,737 | 8 | 39,474 |
Tags: greedy, math, number theory
Correct Solution:
```
a,b,c,d=[int(x) for x in input().split()]
if b/a>d/c:
u=(b*c-a*d)
v=(b*c)
else:
u=(a*d-b*c)
v=(a*d)
for i in range(2,min(u,v)+1):
while u%i==0 and v%i==0:
u=u//i
v=v//i
if u==0:
print("0/1")
else:
print(str(u)+"/"+str(v))
``` | output | 1 | 19,737 | 8 | 39,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n=int(input())
ans=[i for i in range(2,n+1)]+[1]
print(*ans)
``` | instruction | 0 | 19,813 | 8 | 39,626 |
Yes | output | 1 | 19,813 | 8 | 39,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n = int(input())
print(n, end = " ")
for i in range(1,n):
print(i, end = " ")
``` | instruction | 0 | 19,814 | 8 | 39,628 |
Yes | output | 1 | 19,814 | 8 | 39,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n=int(input())
if (n&1):
a=[1]+[i^1 for i in range(2,n+1)]
else:
a=[(i^1)+1 for i in range(n)]
for i in range(n): print(a[i],' ',end='')
``` | instruction | 0 | 19,815 | 8 | 39,630 |
Yes | output | 1 | 19,815 | 8 | 39,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=[i for i in range(1,n)]
l=[n]+l
print(*l,sep=" ")
``` | instruction | 0 | 19,816 | 8 | 39,632 |
Yes | output | 1 | 19,816 | 8 | 39,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n=int(input())
for i in range(n,0,-1):
print(i,end=' ')
``` | instruction | 0 | 19,817 | 8 | 39,634 |
No | output | 1 | 19,817 | 8 | 39,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n=int(input())
if n%2==0:
for i in range(n,0,-1):
print(i,end=' ')
else:
print(1,end=' ')
for i in range (n,1,-1):
print(i,end=' ')
``` | instruction | 0 | 19,818 | 8 | 39,636 |
No | output | 1 | 19,818 | 8 | 39,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
print(*range(1, n + 1))
``` | instruction | 0 | 19,819 | 8 | 39,638 |
No | output | 1 | 19,819 | 8 | 39,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya bought the collected works of a well-known Berland poet Petya in n volumes. The volumes are numbered from 1 to n. He thinks that it does not do to arrange the book simply according to their order. Vasya wants to minimize the number of the disposition’s divisors — the positive integers i such that for at least one j (1 ≤ j ≤ n) is true both: j mod i = 0 and at the same time p(j) mod i = 0, where p(j) is the number of the tome that stands on the j-th place and mod is the operation of taking the division remainder. Naturally, one volume can occupy exactly one place and in one place can stand exactly one volume.
Help Vasya — find the volume disposition with the minimum number of divisors.
Input
The first line contains number n (1 ≤ n ≤ 100000) which represents the number of volumes and free places.
Output
Print n numbers — the sought disposition with the minimum divisor number. The j-th number (1 ≤ j ≤ n) should be equal to p(j) — the number of tome that stands on the j-th place. If there are several solutions, print any of them.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Submitted Solution:
```
n=int(input())
if n%2==0:
for i in range(n,0,-1):
print(i,end=' ')
else:
for i in range (2,n+1):
print(i,end=' ')
print(1,end=' ')
``` | instruction | 0 | 19,820 | 8 | 39,640 |
No | output | 1 | 19,820 | 8 | 39,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
So many wall designs to choose from! Even modulo 106 + 3, it's an enormous number. Given that recently Heidi acquired an unlimited supply of bricks, her choices are endless! She really needs to do something to narrow them down.
Heidi is quick to come up with criteria for a useful wall:
* In a useful wall, at least one segment is wider than W bricks. This should give the zombies something to hit their heads against. Or,
* in a useful wall, at least one column is higher than H bricks. This provides a lookout from which zombies can be spotted at a distance.
This should rule out a fair amount of possibilities, right? Help Heidi compute the number of useless walls that do not confirm to either of these criteria. In other words, a wall is useless if every segment has width at most W and height at most H.
Parameter C, the total width of the wall, has the same meaning as in the easy version. However, note that the number of bricks is now unlimited.
Output the number of useless walls modulo 106 + 3.
Input
The first and the only line of the input contains three space-separated integers C, W and H (1 ≤ C ≤ 108, 1 ≤ W, H ≤ 100).
Output
Output the number of different walls, modulo 106 + 3, which are useless according to Heidi's criteria.
Examples
Input
1 1 1
Output
2
Input
1 2 2
Output
3
Input
1 2 3
Output
4
Input
3 2 2
Output
19
Input
5 4 9
Output
40951
Input
40 37 65
Output
933869
Note
If there is no brick in any of the columns, the structure is considered as a useless wall. | instruction | 0 | 19,888 | 8 | 39,776 |
Tags: dp
Correct Solution:
```
mod = 10 ** 6 + 3
def prod(a, b):
return [[sum([a[i][k] * b[k][j] for k in range(len(b))]) % mod for j in range(len(b[0]))] for i in range(len(a))]
c, w, h = map(int, input().split())
a = [[0] * (w + 1) for _ in range(w + 1)]
for i in range(w):
a[i][i + 1] = 1
for cnt in range(0, w + 1):
a[-1][-1 - cnt] = h ** cnt
ans = [[0] for _ in range(w + 1)]
ans[-1][0] = 1
ans[-2][0] = 1
while c > 0:
if c % 2 == 1:
ans = prod(a, ans)
c = c // 2
if c > 0:
a = prod(a, a)
print(ans[-1][0])
``` | output | 1 | 19,888 | 8 | 39,777 |
Provide a correct Python 3 solution for this coding contest problem.
There are N boxes arranged in a circle. The i-th box contains A_i stones.
Determine whether it is possible to remove all the stones from the boxes by repeatedly performing the following operation:
* Select one box. Let the box be the i-th box. Then, for each j from 1 through N, remove exactly j stones from the (i+j)-th box. Here, the (N+k)-th box is identified with the k-th box.
Note that the operation cannot be performed if there is a box that does not contain enough number of stones to be removed.
Constraints
* 1 ≦ N ≦ 10^5
* 1 ≦ A_i ≦ 10^9
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 … A_N
Output
If it is possible to remove all the stones from the boxes, print `YES`. Otherwise, print `NO`.
Examples
Input
5
4 5 1 2 3
Output
YES
Input
5
6 9 12 10 8
Output
YES
Input
4
1 2 3 1
Output
NO | instruction | 0 | 20,146 | 8 | 40,292 |
"Correct Solution:
```
import sys
import heapq
from operator import itemgetter
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
def sol():
N = int(input())
A = list(map(int, input().split()))
S = sum(A)
if S % (N * (N + 1) // 2) != 0:
print('NO')
return
K = S // (N * (N + 1) // 2)
for diff in [A[i] - A[i - 1] for i in range(N)]:
if K - diff < 0 or (K - diff) % N != 0:
print('NO')
return
print('YES')
sol()
``` | output | 1 | 20,146 | 8 | 40,293 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.