text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
"""
・適当な部分空間なので、達成可能でありさえすれば数え上げは簡単
・対角成分に関して向かい側はまとめる。「必ず0」「必ず1」「free」
・対角から遠いところについては調整不可能。「必ず1」がここにあると死亡
・そうでない場合、対角～対角+2までを矛盾なく作れれば勝ち
"""
import itertools
MOD = 998244353
N,M = map(int,readline().split())
m = map(int,read().split())
ABC = list(zip(m,m,m))
# ある：10点
from collections import defaultdict
counter = defaultdict(int)
for a,b,c in ABC:
if a>b:
a,b = b,a
counter[(a,b)] += 10+c
diag0 = [-1] * N
diag1 = [-1] * N # 後ろに足す
diag2 = [-1] * N # 前後に足す
free = N*(N-1)//2 # （盤面に対して対角ごとの和をとったもの）ごとの自由度
other = []
for (x,y),n in counter.items():
if x>y:
x,y = y,x
d = y-x
if d == 0:
diag0[x-1] = n-10
continue
n = -1 if n<20 else n&1 # 未確定(-1) or 確定(0,1)
if d >= 3:
other.append(n)
elif d == 1:
diag1[x-1] = n
elif d == 2:
diag2[x-1] = n
else:
raise Exception
if 1 in other:
print(0)
exit()
for i,x in enumerate(diag2[:-2]):
if x == -1:
continue
y = diag0[i+1]
if y == -1:
diag0[i+1] = x # 対角成分が強制される
continue
# どちらも強制されている
if x != y:
print(0)
exit()
"""
diag0, diag1 の状態を元に、完成図の通り数を数える。
列ごとに処理。対角成分に書き込まれるのが、0のときa通り、1のときb通り
"""
if diag0[0] == -1:
dp = [1,1]
elif diag0[0] == 0:
dp = [1,0]
else:
dp = [0,1]
for x0,x1 in zip(diag0[1:],diag1[:-1]):
it0 = ([0],[1],[0,1])[x0]
it1 = ([0],[1],[0,1])[x1]
prev = dp
dp = [0,0]
for y0,y1 in itertools.product(it0,it1):
dp[y0] += prev[y0^y1]
if dp[0] > MOD: dp[0] -= MOD
if dp[1] > MOD: dp[1] -= MOD
x = dp[0] + dp[1] # 完成盤面+transepose(完成盤面)が何通りあるか
# あとは、指定状態を固定したときの自由度
free = N*(N-1)//2
for (r,c),n in counter.items():
if r == c:
continue
if n >= 10:
free -= 1
answer = x * pow(2,free,MOD) % MOD
print(answer)
```
| 10,600 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
"Correct Solution:
```
from collections import Counter
import sys
MOD = 998244353
n, m = map(int, input().split())
decided = Counter()
ans = 1
d_num = 0
def kaijou(a, n):
x = 1
while n > 0:
if n & 1 == 1:
x = (x * a) % MOD
a = (a ** 2) % MOD
n >>= 1
return x
for _ in range(m):
a, b, c = map(int, input().split())
decided[(a-1) * n + b - 1] = c
if abs(a-b) >= 3:
if (b-1) * n + a - 1 not in decided:
d_num += 1
#ans = (ans * 2) % MOD
decided[(b-1) * n + a - 1] = c
elif decided[(b-1) * n + a - 1] != decided[(a-1) * n + b - 1]:
print(0)
sys.exit()
ans = (ans * kaijou(2, ((n-2) * (n-3) // 2) - d_num)) % MOD
#print(ans)
is_empty = 0
if n*0+0 not in decided:
is_empty += 1
if n*0+0+1 not in decided:
is_empty += 1
if n*0+0+n not in decided:
is_empty += 1
if n*0+0+n+1 not in decided:
is_empty += 1
if is_empty == 0 and n*0+0 in decided:
if (decided[n*0+0] + decided[n*0+0+n+1]) % 2 != (decided[n*0+0+1] + decided[n*0+0+n]) % 2:
ans *= 0
if is_empty == 1 and n*0+0+n+1 not in decided and n*0+0 in decided:
decided[n*0+0+n+1] = (decided[n*0+0+1] + decided[n*0+0+n]) % 2 - decided[n*0+0]
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
#print(ans)
for i in range(n-2):
is_empty = 0
#if n*i+i+n+1 not in decided:
#is_empty += 1
if n*i+i+2 not in decided:
is_empty += 1
if n*i+i+2*n not in decided:
is_empty += 1
if is_empty == 0 and n*i+i+n+1 in decided:
if (decided[n*i+i+2] + decided[n*i+i+n+1] + decided[n*i+i+2*n]) % 2 != 0:
#print("hoge")
ans *= 0
if is_empty == 0 and n*i+i+n+1 not in decided:
decided[n*i+i+n+1] = (decided[n*i+i+2] + decided[n*i+i+n*2]) % 2
ans = (ans * 499122177) % MOD
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
is_empty = 0
if n*(i+1)+(i+1)+1 not in decided:
is_empty += 1
if n*(i+1)+(i+1)+n not in decided:
is_empty += 1
if n*(i+1)+(i+1)+n+1 not in decided:
is_empty += 1
if is_empty == 0 and n*(i+1)+(i+1) in decided:
if (decided[n*(i+1)+(i+1)] + decided[n*(i+1)+(i+1)+n+1]) % 2 != (decided[n*(i+1)+(i+1)+1] + decided[n*(i+1)+(i+1)+n]) % 2:
ans *= 0
if is_empty == 0 and n*(i+1)+(i+1) not in decided:
ans = (ans * 499122177) % MOD
if is_empty == 1 and n*(i+1)+(i+1)+n+1 not in decided and n*(i+1)+(i+1) in decided:
decided[n*(i+1)+(i+1)+n+1] = (decided[n*(i+1)+(i+1)+1] + decided[n*(i+1)+(i+1)+n]) % 2 - decided[n*(i+1)+(i+1)]
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
print(int(ans))
```
| 10,601 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
"Correct Solution:
```
"""
https://atcoder.jp/contests/caddi2018/tasks/caddi2018_d
インラインdpを習得したから再挑戦
2*2→3*3…と塗っていくと、毎回2個を決めることとなる
新たに塗る2箇所をどう決められるかを考える
→偶奇を反転させる場合、01 or 10で塗り、させない場合は11 or 00で塗る
→1箇所までなら塗られていても自由度が下がるだけ？
→両方塗られていたらまずい場合がある
基本的に4列目以降は00 01の対以外不可能になる
→すでに片側置かれていたら1択、両側でダメだったら0になる
→つまり、考えるべきは3列目までである
3列目までは、片側は問題ないが、両側は制約として作動する
1列目(i=j)は文字を確定させる
2列目(abs(i-j)!=1)は隣り合う文字が同じ or 異なるを確定させる
3列目は、1列目の文字を確定させる
"""
from sys import stdin
import sys
mod = 998244353
N,M = map(int,stdin.readline().split())
neq = {}
eq = [None] * N
lock = [None] * (N-1)
for loop in range(M):
a,b,c = map(int,stdin.readline().split())
a -= 1
b -= 1
if a < b:
a,b = b,a
if a == b:
if eq[a] == None or eq[a] == c:
eq[a] = c
else:
print (0)
sys.exit()
elif a-b == 1:
if (a,b) in neq:
lock[b] = (neq[(a,b)] ^ c)
else:
neq[(a,b)] = c
elif a-b == 2:
if (a,b) in neq:
if eq[a-1] == None or eq[a-1] == neq[(a,b)]^c:
eq[a-1] = neq[(a,b)]^c
else:
print (0)
sys.exit()
else:
neq[(a,b)] = c
else:
if (a,b) in neq:
if neq[(a,b)] ^ c == 1:
print (0)
sys.exit()
else:
neq[(a,b)] = c
ableout = (N**2-N)//2 - len(neq)
outans = pow(2,ableout,mod)
dp = [[0,0] for i in range(N)]
dp[0] = [1,1]
for i in range(N):
if eq[i] == 0:
dp[i][1] = 0
if eq[i] == 1:
dp[i][0] = 0
if i == N-1:
break
if lock[i] == 0:
dp[i+1][0] = dp[i][0]
dp[i+1][1] = dp[i][1]
elif lock[i] == 1:
dp[i+1][0] = dp[i][1]
dp[i+1][1] = dp[i][0]
else:
dp[i+1][0] = sum(dp[i]) % mod
dp[i+1][1] = sum(dp[i]) % mod
#print (dp , ableout)
print (sum(dp[-1]) * outans % mod)
```
| 10,602 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
"Correct Solution:
```
import sys
from collections import Counter, defaultdict, deque
readline = sys.stdin.readline
MOD = 998244353
def calc():
N, M = map(int, readline().split())
D = Counter()
Grid = defaultdict(lambda: -1)
flag = True
geta = N
co = 0
for _ in range(M):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
if abs(b - a) >= 3:
if a > b:
a, b = b, a
if (a, b) in D:
if D[(a, b)] != c:
flag = False
else:
D[(a, b)] = c
co += 1
else:
Grid[a*geta+b] = c
if not flag:
return 0
for i in range(N-2):
g = Grid[(i+1)*geta+(i+1)]
g1 = Grid[i*geta+(i+2)]
g2 = Grid[(i+2)*geta+i]
if g1 == -1 or g2 == -1:
continue
if g != -1:
if (g1 == g2) == g:
return 0
else:
Grid[(i+1)*geta+(i+1)] = int(g1 != g2)
Edge = [[] for _ in range(N)]
for i in range(N-1):
g1 = Grid[(i+1)*geta+i]
g2 = Grid[i*geta+(i+1)]
if g1 == -1 or g2 == -1:
continue
k = int(g1 != g2)
Edge[i].append((i+1, k))
Edge[i+1].append((i, k))
Diag = [None]*N
Q = []
for i in range(N):
if Grid[i*geta+i] != -1:
Diag[i] = Grid[i*geta+i]
Q.append(i)
Q = deque(Q)
while Q:
vn = Q.pop()
for vf, k in Edge[vn]:
if Diag[vf] is None:
Diag[vf] = k^Diag[vn]
Q.appendleft(vf)
else:
if Diag[vf] != k^Diag[vn]:
return 0
jj = set()
for vn in range(N):
for vf, k in Edge[vn]:
if Diag[vn] is None:
jj.add((min(vn, vf), max(vn, vf)))
co += len(jj)
co += N - Diag.count(None)
used = set()
for i in range(N-1):
if Grid[i*geta + (i+1)] != -1:
used.add((i, i+1))
if Grid[(i+1)*geta + i] != -1:
used.add((i, i+1))
for i in range(N-2):
if Grid[i*geta + (i+2)] != -1:
used.add((i, i+2))
if Grid[(i+2)*geta + i] != -1:
used.add((i, i+2))
co += len(used)
return pow(2, N*(N+1)//2 - co, MOD)
print(calc())
```
| 10,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
Submitted Solution:
```
import sys
from collections import Counter, defaultdict, deque
readline = sys.stdin.readline
MOD = 998244353
def calc():
N, M = map(int, readline().split())
D = Counter()
Grid = defaultdict(lambda: -1)
flag = True
geta = N
co = 0
for _ in range(M):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
if abs(b - a) >= 3:
if a > b:
a, b = b, a
if (a, b) in D:
if D[(a, b)] != c:
flag = False
else:
D[(a, b)] = c
co += 1
else:
Grid[a*geta+b] = c
if not flag:
return 0
for i in range(N-2):
g = Grid[(i+1)*geta+(i+1)]
g1 = Grid[i*geta+(i+2)]
g2 = Grid[(i+2)*geta+i]
if g1 == -1 or g2 == -1:
continue
if g != -1:
if (g1 == g2) == g:
return 0
else:
Grid[(i+1)*geta+(i+1)] = int(g1 != g2)
Edge = [[] for _ in range(N)]
for i in range(N-1):
g1 = Grid[(i+1)*geta+i]
g2 = Grid[i*geta+(i+1)]
if g1 == -1 or g2 == -1:
continue
k = int(g1 != g2)
Edge[i].append((i+1, k))
Edge[i+1].append((i, k))
Diag = [None]*N
Q = []
for i in range(N):
if Grid[i*geta+i] != -1:
Diag[i] = Grid[i*geta+i]
Q.append(i)
Q = deque(Q)
while Q:
vn = Q.pop()
for vf, k in Edge[vn]:
if Diag[vf] is None:
Diag[vf] = k^Diag[vn]
Q.appendleft(vf)
else:
if Diag[vf] != k^Diag[vn]:
return 0
jj = set()
for vn in range(N):
for vf, k in Edge[vn]:
if Diag[vn] is None:
if vn > vf:
vn, vf = vf, vn
jj.add((vn, vf))
co += len(jj)
if len(jj) > 0:
return 0
co += N - Diag.count(None)
used = set()
for i in range(N-1):
if Grid[i*geta + (i+1)] != -1:
used.add((i, i+1))
if Grid[(i+1)*geta + i] != -1:
used.add((i, i+1))
for i in range(N-2):
if Grid[i*geta + (i+2)] != -1:
used.add((i, i+2))
if Grid[(i+2)*geta + i] != -1:
used.add((i, i+2))
co += len(used)
return pow(2, N*(N+1)//2 - co, MOD)
print(calc())
```
No
| 10,604 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
Submitted Solution:
```
from collections import Counter
import sys
MOD = 998244353
n, m = map(int, input().split())
decided = Counter()
ans = 1
d_num = 0
def kaijou(a, n):
x = 1
while n > 0:
if n & 1 == 1:
x = (x * a) % MOD
a = (a ** 2) % MOD
n >>= 1
return x
for _ in range(m):
a, b, c = map(int, input().split())
decided[(a-1) * n + b - 1] = c
if abs(a-b) >= 3:
if (b-1) * n + a - 1 not in decided:
d_num += 1
ans = (ans * 2) % MOD
decided[(b-1) * n + a - 1] = c
elif decided[(b-1) * n + a - 1] != decided[(a-1) * n + b - 1]:
print(0)
sys.exit()
ans = (ans * kaijou(2, ((n-2) * (n-3) // 2) - d_num)) % MOD
#print(ans)
is_empty = 0
if n*0+0 not in decided:
is_empty += 1
if n*0+0+1 not in decided:
is_empty += 1
if n*0+0+n not in decided:
is_empty += 1
if n*0+0+n+1 not in decided:
is_empty += 1
if is_empty == 0 and n*0+0 in decided:
if (decided[n*0+0] + decided[n*0+0+n+1]) % 2 != (decided[n*0+0+1] + decided[n*0+0+n]) % 2:
ans *= 0
if is_empty == 1 and n*0+0+n+1 not in decided and n*0+0 in decided:
decided[n*0+0+n+1] = (decided[n*0+0+1] + decided[n*0+0+n]) % 2 - decided[n*0+0]
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
#print(ans)
for i in range(n-2):
is_empty = 0
#if n*i+i+n+1 not in decided:
#is_empty += 1
if n*i+i+2 not in decided:
is_empty += 1
if n*i+i+2*n not in decided:
is_empty += 1
if is_empty == 0 and n*i+i+n+1 in decided:
if (decided[n*i+i+2] + decided[n*i+i+n+1] + decided[n*i+i+2*n]) % 2 != 0:
#print("hoge")
ans *= 0
if is_empty == 0 and n*i+i+n+1 not in decided:
decided[n*i+i+n+1] = (decided[n*i+i+2] + decided[n*i+i+n*2]) % 2
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
is_empty = 0
if n*(i+1)+(i+1)+1 not in decided:
is_empty += 1
if n*(i+1)+(i+1)+n not in decided:
is_empty += 1
if n*(i+1)+(i+1)+n+1 not in decided:
is_empty += 1
if is_empty == 0 and n*(i+1)+(i+1) in decided:
if (decided[n*(i+1)+(i+1)] + decided[n*(i+1)+(i+1)+n+1]) % 2 != (decided[n*(i+1)+(i+1)+1] + decided[n*(i+1)+(i+1)+n]) % 2:
ans *= 0
if is_empty == 1 and n*(i+1)+(i+1)+n+1 not in decided and n*(i+1)+(i+1) in decided:
decided[n*(i+1)+(i+1)+n+1] = (decided[n*(i+1)+(i+1)+1] + decided[n*(i+1)+(i+1)+n]) % 2 - decided[n*(i+1)+(i+1)]
ans = (ans * (2 ** max(0, is_empty-1))) % MOD
print(int(ans))
```
No
| 10,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
Submitted Solution:
```
import sys
from collections import Counter, defaultdict, deque
readline = sys.stdin.readline
MOD = 998244353
def calc():
N, M = map(int, readline().split())
D = Counter()
Grid = defaultdict(lambda: -1)
flag = True
geta = N
co = 0
for _ in range(M):
a, b, c = map(int, readline().split())
a -= 1
b -= 1
if abs(b - a) >= 3:
if a > b:
a, b = b, a
if (a, b) in D:
if D[(a, b)] != c:
flag = False
else:
D[(a, b)] = c
co += 1
else:
Grid[a*geta+b] = c
if not flag:
return 0
for i in range(1, N-1):
g = Grid[i*geta+i]
g1 = Grid[(i+1)*geta+i-1]
g2 = Grid[(i-1)*geta+i+1]
if g1 == -1 or g2 == -1:
continue
if g != -1:
if (g1 == g2) == g:
return 0
else:
Grid[i*geta+i] = int(g1 != g2)
Edge = [[] for _ in range(N)]
for i in range(N-1):
g1 = Grid[(i+1)*geta+i]
g2 = Grid[i*geta+i+1]
if g1 == -1 or g2 == -1:
continue
k = int(g1 != g2)
Edge[i].append((i+1, k))
Edge[i+1].append((i, k))
Diag = [None]*N
Q = []
for i in range(N):
if Grid[i*geta+i] != -1:
Diag[i] = Grid[i*geta+i]
Q.append(i)
Q = deque(Q)
while Q:
vn = Q.pop()
for vf, k in Edge[vn]:
if Diag[vf] is None:
Diag[vf] = k^Diag[vn]
Q.appendleft(vf)
else:
if Diag[vf] != k^Diag[vn]:
return 0
co += N - Diag.count(None)
used = set()
for i in range(N-1):
if Grid[i*geta + i+1] != -1:
used.add((i, i+1))
if Grid[(i+1)*geta + i] != -1:
used.add((i, i+1))
for i in range(N-2):
if Grid[i*geta + i+2] != -1:
used.add((i, i+2))
if Grid[(i+2)*geta + i] != -1:
used.add((i, i+2))
co += len(used)
return pow(2, N*(N+1)//2 - co, MOD)
print(calc())
```
No
| 10,606 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an N \times N grid. The square at the i-th row and the j-th column of the grid is denoted by (i,j). Particularly, the top-left square of the grid is (1,1), and the bottom-right square is (N,N).
An integer, 0 or 1, is written on M of the squares in the Takahashi's grid. Three integers a_i,b_i and c_i describe the i-th of those squares with integers written on them: the integer c_i is written on the square (a_i,b_i).
Takahashi decides to write an integer, 0 or 1, on each of the remaining squares so that the condition below is satisfied. Find the number of such ways to write integers, modulo 998244353.
* For all 1\leq i < j\leq N, there are even number of 1s in the square region whose top-left square is (i,i) and whose bottom-right square is (j,j).
Constraints
* 2 \leq N \leq 10^5
* 0 \leq M \leq min(5 \times 10^4,N^2)
* 1 \leq a_i,b_i \leq N(1\leq i\leq M)
* 0 \leq c_i \leq 1(1\leq i\leq M)
* If i \neq j, then (a_i,b_i) \neq (a_j,b_j).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
:
a_M b_M c_M
Output
Print the number of possible ways to write integers, modulo 998244353.
Examples
Input
3 3
1 1 1
3 1 0
2 3 1
Output
8
Input
4 5
1 3 1
2 4 0
2 3 1
4 2 1
4 4 1
Output
32
Input
3 5
1 3 1
3 3 0
3 1 0
2 3 1
3 2 1
Output
0
Input
4 8
1 1 1
1 2 0
3 2 1
1 4 0
2 1 1
1 3 0
3 4 1
4 4 1
Output
4
Input
100000 0
Output
342016343
Submitted Solution:
```
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.bit =[0]*N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
self.bit[gy]=max(self.bit[gy],self.bit[gx])
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
self.bit[gx]=max(self.bit[gy],self.bit[gx])
def freeze(self,x,b):
r=self.find_root(x)
self.bit[r]=1
def get_bit(self,x):
return self.bit[self.find_root(x)]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
import sys
input=sys.stdin.buffer.readline
N,M=map(int,input().split())
free=(N-3)*(N-2)//2
co=N-1
t=N-2
connect=[-1]*(N+1)
decide=[-1]*(N+1)
freedic={}
freeze=[-1]*(N+1)
uf=UnionFindVerSize(N)
for i in range(M):
a,b,c=map(int,input().split())
if b>a:
a,b=b,a
if a==b:
uf.freeze(a-1,c)
if freeze[a]==-1:
freeze[a]=c
elif freeze[a]!=c:
print(0)
exit()
elif a==b+1:
if connect[b]!=-1:
uf.unite(b-1,a-1)
connect[b]=(c+connect[b])%2
else:
connect[b]=c
co-=1
elif a==b+2:
id=(a+b)//2
if decide[id]!=-1:
check=(decide[id]+c)%2
uf.freeze(id-1,check)
if freeze[id]==-1:
freeze[id]=check
elif freeze[id]!=check:
print(0)
exit()
else:
decide[id]=c
t-=1
else:
if (a,b) not in freedic:
freedic[(a,b)]=0
freedic[(a,b)]=c
free-=1
else:
if freedic[(a,b)]!=c:
uf.in_ans(0)
for i in range(1,N):
if connect[i]!=-1:
if freeze[i]==-1 or freeze[i+1]==-1:
continue
elif (freeze[i]+freeze[i+1]+connect[i])%2==1:
print(0)
exit()
diag=set([])
for i in range(N):
r=uf.find_root(i)
if uf.get_bit(r)==0:
diag.add(uf.find_root(i))
dddd=len(diag)
mod=998244353
print(pow(2,free+co+t+dddd,mod))
#print(free)
#print(co)
#print(t)
#print(dddd)
```
No
| 10,607 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
N = int(input())
P = [int(input()) for _ in range(N)]
K = [0]*(N+1)
for p in P:
K[p] = K[p-1] + 1
print(N - max(K))
```
| 10,608 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
n = int(input())
P = [int(input()) for _ in range(n)]
Q = [0]*(n+1)
for i, j in enumerate(P):
Q[j-1] = i+1
count = 0
m = 0
for i in range(n):
count += 1
if Q[i] > Q[i+1]:
m = max(m, count)
count = 0
print(n-m)
```
| 10,609 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
n=int(input())
l=[0]*n
for i in range(n):
l[int(input())-1]=i
pre=-1
now=0
ans=n
for i in l:
if pre<i:
now+=1
else:
ans=min(ans,n-now)
now=1
pre=i
print(min(ans,n-now))
```
| 10,610 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
N = int(input())
P = [int(input()) for _ in range(N)]
dp = [0 for _ in range(N+1)]
for p in P:
dp[p] = dp[p-1]+1
print(N-max(dp))
```
| 10,611 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
import bisect
n = int(input())
p = [int(input()) for _ in range(n)]
idx = dict()
for i in range(n):
idx[p[i]] = i
c = 0
cnt = 1
for i in range(1, n):
if idx[i + 1] > idx[i]:
cnt += 1
else:
c = max(c, cnt)
cnt = 1
c = max(c, cnt)
print(n - c)
```
| 10,612 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
n,*p=map(int,open(0))
s=[0]*-~n
for i in p:s[i]=s[i-1]+1
print(n-max(s))
```
| 10,613 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
N=int(input())
P=[int(input())-1 for i in range(N)]
Q=[0 for i in range(N)]
for i in range(N):
Q[P[i]]=i
L=[1]
k=0
for i in range(1,N):
if Q[i-1]<Q[i]:
L[k]+=1
else:
L.append(0)
k+=1
L[k]+=1
print(N-max(L))
```
| 10,614 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
"Correct Solution:
```
N = int(input())
P = []
for i in range(N):
P.append(int(input()))
#print(P)
S = [0 for _ in range(N+1)]
for i in range(N):
S[P[i]] = S[P[i]-1] + 1
print(N-max(S))
```
| 10,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
N=int(input())
P=[int(input()) for i in range(N)]
pos=[-1]*N
for i,p in enumerate(P):
pos[p-1]=i
x,mx=0,0
for i in range(N-1):
if pos[i]<pos[i+1]:
x+=1
mx=max(mx,x)
else:
x=0
print(N-mx-1)
```
Yes
| 10,616 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
import bisect
N=int(input())
A=[int(input())for i in range(N)]
#print(A)
L=[0 for i in range(N+1)]
for i in range(N):
if L[A[i]-1]>0:
L[A[i]]=(L[A[i]-1]+1)
else:
L[A[i]]=1
print(N-max(L))
```
Yes
| 10,617 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
from collections import defaultdict
n = int(input())
p = [int(input()) for i in range(n)]
d = defaultdict(int)
for i in p:
d[i] = d[i - 1] + 1
print(n - max(d.values()))
```
Yes
| 10,618 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
n=int(input())
p=[int(input())-1for _ in[0]*n]
q=[0]*n
for i in range(n):q[p[i]]=i
r,c=0,1
for i in range(n-1):
c=c+1if q[i]<q[i+1]else 1
if r<c:r=c
if r<c:r=c
print(n-r)
```
Yes
| 10,619 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
N = int(input())
list = {0:0}
for i in range(1,N):
list[int(input())] = i
x = 0
for j in range(2,N-1):
if list[j-1] > list[j] :
x = x + 1
print(x)
```
No
| 10,620 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
n = int(input())
p = []
for i in range(n):
p.append(int(input()))
dic = {p[0]:1}
for i in range(1,n):
print(dic)
check = 0
for k in list(dic):
#print(k, dic[k])
if p[i] == k + dic[k]:
dic[k] += 1
check = 1
break
elif p[i] == k - 1:
dic[p[i]] = 1
if dic[k] < max(dic.values()) or dic[k] == 1:
dic.pop(k)
else:
dic[p[i]] = 1
print(n - max(dic.values()))
```
No
| 10,621 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
n=int(input())
f,s=n//2,n//2+1
p=[int(input()) for _ in range(n)]
fi=p.index(f)
si=p.index(s)
ans=0
if fi>si:
ans+=1
for i in range(fi-1,-1,-1):
if p[i]==f-1: f-=1
for i in range(si+1,n):
if p[i]==s+1: s+=1
ans+=f-1+n-s
print(f-1+n-s)
```
No
| 10,622 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence (P_1,P_2,...,P_N) which is a permutation of the integers from 1 through N. You would like to sort this sequence in ascending order by repeating the following operation:
* Choose an element in the sequence and move it to the beginning or the end of the sequence.
Find the minimum number of operations required. It can be proved that it is actually possible to sort the sequence using this operation.
Constraints
* 1 \leq N \leq 2\times 10^5
* (P_1,P_2,...,P_N) is a permutation of (1,2,...,N).
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
P_1
:
P_N
Output
Print the minimum number of operations required.
Examples
Input
4
1
3
2
4
Output
2
Input
6
3
2
5
1
4
6
Output
4
Input
8
6
3
1
2
7
4
8
5
Output
5
Submitted Solution:
```
import sys
input = sys.stdin.readline
def main():
N = int(input())
A = [int(input()) for i in range(N)]
dp = [0] * N
for i in range(N):
if A[i] > 1 or i == 0:
dp[A[i]-1] = dp[A[i]-2] + 1
print(N - max(dp))
if __name__ == "__main__":
main()
```
No
| 10,623 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
def main():
n,q,*t=map(int,open(0).read().split())
for v,w in zip(t[::2],t[1::2]):
if n<2:
print(min(v,w))
continue
s,t=[],[]
while v:
s.append(v)
v=(v+n-2)//n
while w:
t.append(w)
w=(w+n-2)//n
print(max(set(s)&set(t)))
if __name__=='__main__':
main()
```
| 10,624 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
N,Q = map(int,input().split())
if N == 1:
for i in range(Q):
print(min(map(int,input().split())))
exit()
def solve(s):
a,b = map(int,s.split())
while a != b:
if a < b: a,b = b,a
a = (a+N-2) // N
return str(a)
print('\n'.join(map(solve, [input() for i in range(Q)])))
```
| 10,625 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
import sys
input=sys.stdin.readline
n,q=map(int,input().split())
for i in range(q):
u,v=map(int,input().split())
if n==1:
print(min(u,v))
continue
u-=1
v-=1
while u!=v:
if u>v:
if (u-1)//n>v:
u=(((u-1)//n)-1)//n
else:
u=(u-1)//n
else:
if (v-1)//n>v:
v=(((v-1)//n)-1)//n
else:
v=(v-1)//n
print(u+1)
```
| 10,626 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
N, Q = map(int, input().split())
if N == 1:
for i in range(Q):
V, W = map(int, input().split())
print(min(V, W))
else:
p = []
p.append(1)
for i in range(40):
p.append(p[-1] * N)
for i in range(Q):
V, W = map(int, input().split())
v = []
w = []
dv = 0
dw = 0
while V > (p[dv + 1] - 1) // (N - 1): dv = dv + 1
while W > (p[dw + 1] - 1) // (N - 1): dw = dw + 1
v.append(V)
e = V
for j in range(dv, 0, -1):
e = (e - (p[j] - 1) // (N - 1) - 1) // N + (p[j - 1] - 1) // (N - 1) + 1;
v.append(e)
v.reverse()
w.append(W)
e = W
for j in range(dw, 0, -1):
e = (e - (p[j] - 1) // (N - 1) - 1) // N + (p[j - 1] - 1) // (N - 1) + 1;
w.append(e)
w.reverse()
ans = 1
j = 0
while j < len(v) and j < len(w) and v[j] == w[j]:
ans = v[j]
j = j + 1
print(ans)
```
| 10,627 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
from bisect import *
from sys import stdin, stdout
readline = stdin.readline
N, Q = map(int, readline().split())
ans = []
if N == 1:
for q in range(Q):
v, w = map(int, readline().split())
ans.append(str(v))
else:
c = 1
B = [1]
while c < 10**9:
B.append(c+1)
c = c*N + 1
for q in range(Q):
v, w = map(int, readline().split())
lv = bisect(B, v)
lw = bisect(B, w)
if lv < lw:
w = (w + (B[lw-lv]-1)*(N-2)) // N**(lw-lv)
while v != w:
v = (v + (N - 2)) // N
w = (w + (N - 2)) // N
ans.append(str(v))
stdout.write("\n".join(ans))
stdout.write("\n")
```
| 10,628 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
import sys
input = sys.stdin.readline
N,Q = map(int,input().split())
VW = [tuple(map(int,input().split())) for i in range(Q)]
ans = []
if N==1:
for v,w in VW:
ans.append(min(v,w))
else:
for v,w in VW:
while v != w:
if v > w: v,w = w,v
w = (w+N-2)//N
ans.append(v)
print(*ans, sep='\n')
```
| 10,629 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, Q = map(int, input().split())
if N == 1:
ans = [min(map(int, input().split())) for _ in range(Q)]
print(*ans, sep="\n")
exit()
ans = [-1] * Q
for i in range(Q):
x, y = map(int, input().split())
x_memo = [x]
y_memo = [y]
while x:
x = (x + N - 2) // N
x_memo.append(x)
while y:
y = (y + N - 2) // N
y_memo.append(y)
res = -1
while x_memo and y_memo:
xi = x_memo.pop()
yi = y_memo.pop()
if xi == yi:
res = xi
else:
break
ans[i] = res
print(*ans, sep="\n")
```
| 10,630 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
"Correct Solution:
```
import math
N, Q = map(int, input().split())
queries = []
for i in range(Q):
v, w = map(int, input().split())
queries.append([v, w])
if N == 1:
for v, w in queries:
print(min(v, w))
else:
for v, w in queries:
if 1 in [v, w]:
print(1)
else:
# v < w にする
v, w = min(v,w), max(v, w)
v -= 2
w -= 2
v_parents = [v]
isReported = False
while v > 0:
v_parents.append(v // N - 1)
v = v//N-1
while w > 0:
w = w // N-1
if w in v_parents:
print(w+2)
isReported = True
break
if not isReported:
print(1)
```
| 10,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
def main():
n,m=map(int,input().split())
ab=[list(map(int,input().split())) for _ in [0]*m]
if n==1:
for a,b in ab:
print(min(a,b))
return
for a,b in ab:
while a!=b:
a,b=min(a,b),max(a,b)
b=(b+n-2)//n
print(a)
main()
```
Yes
| 10,632 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LIM(): return list(map(lambda x:int(x) - 1, sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def LIRM(n): return [LIM() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
mod = 1000000007
n, q = LI()
for i, j in LIR(q):
if n == 1:
print(min(i, j))
else:
while i != j:
if i < j:
i, j = j, i
i = (i - 2) // n + 1
print(i)
```
Yes
| 10,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
def main():
n,m=map(int,input().split())
ab=[list(map(int,input().split())) for _ in [0]*m]
if n==1:
for a,b in ab:
print(min(a,b))
return
for a,b in ab:
while a!=b:
if a<b:
b=(b+n-2)//n
else:
a=(a+n-2)//n
print(a)
main()
```
Yes
| 10,634 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
n,q = map(int, input().split())
if n == 1:
for _ in range(q):
print(min(map(int, input().split())))
else:
for _ in range(q):
v,w = map(int, input().split())
while v != w:
if v > w:
v,w = w,v
w = (w+n-2)//n
print(v)
```
Yes
| 10,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
def pre(x):
return (x + 1) // 3
N, Q = map(int, input().split())
for i in range(Q):
v, w = map(int, input().split())
while v != w:
if v < w:
w = pre(w)
else:
v = pre(v)
print(v)
```
No
| 10,636 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
import math
def get_parent(child,n):
parent = 0
if(child%n <= 1):
parent = (child)//n
else:
parent = child//n + 1
return parent
n, q = list(map(int,input().split()))
if(n == 1):
for i in range(q):
v, w = list(map(int,input().split()))
print(min(v,w))
else:
right = [0 for i in range(int(math.log(10**9,n)+2))]
for i in range(len(right)):
right[i] = (n**(i+1)-1)//(n-1)
#print(right)
for i in range(q):
v, w = list(map(int,input().split()))
hv, hw = -1, -1
vparent, wparent = v, w
for j,r in enumerate(right):
if(hv == -1 and v<=r):hv = j
if(hw == -1 and w<=r):hw = j
for j in range(abs(hw-hv)):
if(hw>hv):
wparent = get_parent(wparent,n)
elif(hv>hw):
vparent = get_parent(vparent,n)
while(wparent!=vparent):
wparent = get_parent(wparent,n)
vparent = get_parent(vparent,n)
print(wparent)
```
No
| 10,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
n,q=map(int,input().split())
for _ in range(q):
v,w=map(int,input().split())
while(v is not w):
if v < w:
w = (w+1)//3
else:
v = (v+1)//3
print(v)
```
No
| 10,638 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer N. Consider an infinite N-ary tree as shown below:
<image>
Figure: an infinite N-ary tree for the case N = 3
As shown in the figure, each vertex is indexed with a unique positive integer, and for every positive integer there is a vertex indexed with it. The root of the tree has the index 1. For the remaining vertices, vertices in the upper row have smaller indices than those in the lower row. Among the vertices in the same row, a vertex that is more to the left has a smaller index.
Regarding this tree, process Q queries. The i-th query is as follows:
* Find the index of the lowest common ancestor (see Notes) of Vertex v_i and w_i.
Constraints
* 1 ≤ N ≤ 10^9
* 1 ≤ Q ≤ 10^5
* 1 ≤ v_i < w_i ≤ 10^9
Input
Input is given from Standard Input in the following format:
N Q
v_1 w_1
:
v_Q w_Q
Output
Print Q lines. The i-th line (1 ≤ i ≤ Q) must contain the index of the lowest common ancestor of Vertex v_i and w_i.
Examples
Input
3 3
5 7
8 11
3 9
Output
2
1
3
Input
100000 2
1 2
3 4
Output
1
1
Submitted Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,Q = map(int,input().split())
VW = [[int(x) for x in input().split()] for _ in range(Q)]
if N == 1:
answer = [min(v,w) for v,w in VW]
else:
answer = []
for v,w in VW:
while v != w:
if v > w:
v,w = w,v
w = (w+N-2)//N
answer.append(v)
print('\n'.join(map(str,answer)))
```
No
| 10,639 |
Provide a correct Python 3 solution for this coding contest problem.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
"Correct Solution:
```
from collections import Counter
N,M = map(int,input().split())
A = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
ctr = Counter(A)
cover = [0] * (2*N+1)
for k,v in ctr.items():
for i in range(k,k-v,-1):
cover[i+N] += 1
ans = cover[N+1:].count(0)
for x,y in src:
ctr[A[x-1]] -= 1
ai = A[x-1]+N - ctr[A[x-1]]
cover[ai] -= 1
if ai > N and cover[ai] == 0: ans += 1
A[x-1] = y
bi = y+N - ctr[y]
if bi > N and cover[bi] == 0: ans -= 1
cover[bi] += 1
ctr[y] += 1
print(ans)
```
| 10,640 |
Provide a correct Python 3 solution for this coding contest problem.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
"Correct Solution:
```
import sys
from collections import Counter
# sys.stdin = open('c1.in')
def read_int_list():
return list(map(int, input().split()))
def read_int():
return int(input())
def read_str_list():
return input().split()
def read_str():
return input()
def vanish(p, details=False):
while p:
if details:
print(p)
n = len(p)
q = [x for x in p if x != n]
if len(q) == len(p):
return False
p = q[:]
return True
def check(n):
if n == 3:
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
p = [i, j, k]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
if n == 5:
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
for l in range(k, n + 1):
p = [i, j, k, l]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
if n == 5:
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
for l in range(k, n + 1):
for m in range(l, n + 1):
p = [i, j, k, l, m]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
def solve_small():
# check(3)
# check(4)
# check(5)
n, m = read_int_list()
a = read_int_list()
p = [read_int_list() for _ in range(m)]
c = Counter(a)
res = []
for x, y in p:
c[a[x - 1]] -= 1
a[x - 1] = y
c[a[x - 1]] += 1
covered = set(range(n))
for i, ni in c.items():
for j in range(i - ni, i):
if j in covered:
covered.remove(j)
r = len(covered)
res.append(r)
return '\n'.join(map(str, res))
def solve():
n, m = read_int_list()
a = read_int_list()
p = [read_int_list() for _ in range(m)]
c = Counter(a)
covered = Counter({i: 0 for i in range(n)})
for i, ni in c.items():
for j in range(i - ni, i):
if 0 <= j:
covered[j] += 1
r = 0
for i, v in covered.items():
if 0 <= i:
if v == 0:
r += 1
res = []
for x, y in p:
x -= 1
i = a[x] - c[a[x]]
covered[i] -= 1
if 0 <= i:
if covered[i] == 0:
r += 1
c[a[x]] -= 1
a[x] = y
c[a[x]] += 1
i = a[x] - c[a[x]]
if 0 <= i:
if covered[i] == 0:
r -= 1
covered[i] += 1
res.append(r)
return '\n'.join(map(str, res))
def main():
res = solve()
print(res)
if __name__ == '__main__':
main()
```
| 10,641 |
Provide a correct Python 3 solution for this coding contest problem.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
"Correct Solution:
```
import sys
input = sys.stdin.readline
"""
・とりあえず部分点解法：各クエリに対してO(N)
・いくつかを残していくつかを自由に埋める
・残すもの：被覆区間がoverlapしないように残す
・つまり、区間で覆えている点が処理できて、区間で覆えていない点が他所から持ってこないといけない。
"""
N,M = map(int,input().split())
A = [int(x) for x in input().split()]
XY = [tuple(int(x) for x in input().split()) for _ in range(M)]
def subscore_solution():
from collections import Counter
for x,y in XY:
A[x-1] = y
covered = [False] * (N+N+10)
for key,cnt in Counter(A).items():
for i in range(cnt):
covered[max(0,key-i)] = True
print(sum(not bl for bl in covered[1:N+1]))
counter = [0] * (N+1)
covered = [0] * (N+N+10)
for a in A:
counter[a] += 1
covered[a-counter[a]+1] += 1
magic = sum(x==0 for x in covered[1:N+1])
for i,y in XY:
x = A[i-1]
A[i-1] = y
rem = x - counter[x] + 1
counter[x] -= 1
counter[y] += 1
add = y - counter[y] + 1
covered[rem] -= 1
if 1<=rem<=N and covered[rem] == 0:
magic += 1
if 1<=add<=N and covered[add] == 0:
magic -= 1
covered[add] += 1
print(magic)
```
| 10,642 |
Provide a correct Python 3 solution for this coding contest problem.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
"Correct Solution:
```
from collections import Counter
n, m = map(int, input().split())
an = list(map(int, input().split()))
ac_ = Counter(an)
ac = {i: ac_[i] if i in ac_ else 0 for i in range(1, n + 1)}
ad = [0] * n
for a, c in ac.items():
for i in range(max(0, a - c), a):
ad[i] += 1
ans = ad.count(0)
anss = []
for x, y in (map(int, input().split()) for _ in range(m)):
ax = an[x - 1]
xdi = ax - ac[ax]
if xdi >= 0:
ad[xdi] -= 1
if ad[xdi] == 0:
ans += 1
ac[ax] -= 1
ac[y] += 1
ydi = y - ac[y]
if ydi >= 0:
ad[ydi] += 1
if ad[ydi] == 1:
ans -= 1
an[x - 1] = y
anss.append(ans)
print('\n'.join(map(str, anss)))
```
| 10,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
Submitted Solution:
```
import sys
from collections import Counter
# sys.stdin = open('c1.in')
def read_int_list():
return list(map(int, input().split()))
def read_int():
return int(input())
def read_str_list():
return input().split()
def read_str():
return input()
def vanish(p, details=False):
while p:
if details:
print(p)
n = len(p)
q = [x for x in p if x != n]
if len(q) == len(p):
return False
p = q[:]
return True
def check(n):
if n == 3:
for i in range(1, n+1):
for j in range(i, n+1):
for k in range(j, n+1):
p = [i, j, k]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
if n == 5:
for i in range(1, n+1):
for j in range(i, n+1):
for k in range(j, n+1):
for l in range(k, n+1):
p = [i, j, k, l]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
if n == 5:
for i in range(1, n+1):
for j in range(i, n+1):
for k in range(j, n+1):
for l in range(k, n+1):
for m in range(l, n+1):
p = [i, j, k, l, m]
if vanish(p):
print(p)
# print()
# vanish(p, details=True)
def solve():
# check(3)
# check(4)
# check(5)
n, m = read_int_list()
a = read_int_list()
p = [read_int_list() for _ in range(m)]
c = Counter(a)
res = []
for x, y in p:
c[a[x-1]] -= 1
a[x-1] = y
c[a[x-1]] += 1
covered = set(range(n))
for i, ni in c.items():
for j in range(i - ni, i):
if j in covered:
covered.remove(j)
r = len(covered)
res.append(r)
return '\n'.join(map(str, res))
def main():
res = solve()
print(res)
if __name__ == '__main__':
main()
```
No
| 10,644 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
Submitted Solution:
```
import sys
input = sys.stdin.readline
"""
・とりあえず部分点解法：各クエリに対してO(N)
・いくつかを残していくつかを自由に埋める
・残すもの：被覆区間がoverlapしないように残す
・つまり、区間で覆えている点が処理できて、区間で覆えていない点が他所から持ってこないといけない。
"""
N,M = map(int,input().split())
A = [int(x) for x in input().split()]
XY = [tuple(int(x) for x in input().split()) for _ in range(M)]
def subscore_solution():
from collections import Counter
for x,y in XY:
A[x-1] = y
covered = [False] * (N+N+10)
for key,cnt in Counter(A).items():
for i in range(cnt):
covered[max(0,key-i)] = True
print(sum(not bl for bl in covered[1:N+1]))
if N <= 200 and M <= 200:
subscore_solution()
exit()
raise Exception
```
No
| 10,645 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
Submitted Solution:
```
from collections import Counter, defaultdict
n, m = map(int, input().split())
an = list(map(int, input().split()))
ac = defaultdict(int, Counter(an))
ad = [0] * (n * 2)
for a, c in ac.items():
for i in range(a - c, a):
ad[i] += 1
ans = ad[:n].count(0)
for _ in range(m):
x, y = map(int, input().split())
ax = an[x - 1]
xdi = ax - ac[ax]
ad[xdi] -= 1
if xdi >= 0 and ad[xdi] == 0:
ans += 1
ac[ax] -= 1
ac[y] += 1
ydi = y - ac[y]
ad[ydi] += 1
if ydi >= 0 and ad[ydi] == 1:
ans -= 1
an[x - 1] = y
print(ans)
```
No
| 10,646 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N balls in a row. Initially, the i-th ball from the left has the integer A_i written on it.
When Snuke cast a spell, the following happens:
* Let the current number of balls be k. All the balls with k written on them disappear at the same time.
Snuke's objective is to vanish all the balls by casting the spell some number of times. This may not be possible as it is. If that is the case, he would like to modify the integers on the minimum number of balls to make his objective achievable.
By the way, the integers on these balls sometimes change by themselves. There will be M such changes. In the j-th change, the integer on the X_j-th ball from the left will change into Y_j.
After each change, find the minimum number of modifications of integers on the balls Snuke needs to make if he wishes to achieve his objective before the next change occurs. We will assume that he is quick enough in modifying integers. Here, note that he does not actually perform those necessary modifications and leaves them as they are.
Constraints
* 1 \leq N \leq 200000
* 1 \leq M \leq 200000
* 1 \leq A_i \leq N
* 1 \leq X_j \leq N
* 1 \leq Y_j \leq N
Input
Input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_N
X_1 Y_1
X_2 Y_2
:
X_M Y_M
Output
Print M lines. The j-th line should contain the minimum necessary number of modifications of integers on the balls to make Snuke's objective achievable.
Examples
Input
5 3
1 1 3 4 5
1 2
2 5
5 4
Output
0
1
1
Input
4 4
4 4 4 4
4 1
3 1
1 1
2 1
Output
0
1
2
3
Input
10 10
8 7 2 9 10 6 6 5 5 4
8 1
6 3
6 2
7 10
9 7
9 9
2 4
8 1
1 8
7 7
Output
1
0
1
2
2
3
3
3
3
2
Submitted Solution:
```
from collections import Counter
N,M = map(int,input().split())
arr = list(map(int,input().split()))
for i in range(M):
X,Y = map(int,input().split())
arr[X-1] = Y
counter = Counter(arr)
balls = N
count = 0
for n in range(N,0,-1):
if n > balls: continue
if balls in counter:
balls -= counter[balls]
else:
count += 1
balls -= 1
print(count)
```
No
| 10,647 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
import sys
sys.setrecursionlimit(500000)
N=int(input())
depth=[-1]*N
parent=[-1]*N
childs=[[] for i in range(N)]
depth[0]=0
def calc_depth(n):
for child in childs[n]:
depth[child]=depth[n]+1
calc_depth(child)
def calc_height(n):
if childs[n]==[]:
return 0
childs_height=[]
for child in childs[n]:
childs_height.append(calc_height(child))
childs_height.sort(reverse=True)
heightlist=[childs_height[i]+i for i in range(len(childs_height))]
return max(heightlist)+1
for i in range (1,N):
a=int(input())-1
childs[a].append(i)
print(calc_height(0))
```
| 10,648 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
#12:36
n = int(input())
peer = [[] for _ in range(n)]
for i in range(1,n):
j = int(input())-1
peer[i].append(j)
peer[j].append(i)
pre = [0 for _ in range(n)]
pre[0] = 10**6
seen = [0 for _ in range(n)]
seen[0] = 1
rank = []
now = [0]
while now:
rank.append(now)
last = now
now = []
for x in last:
for y in peer[x]:
if seen[y] == 0:
seen[y] = 1
pre[y] = x
now.append(y)
#print(pre)
#print(rank)
pstd = [[] for _ in range(n)]
rank.reverse()
l = len(rank)
for k in range(l):
if k == 0:
for z in rank[k]:
pstd[pre[z]].append(0)
continue
for z in rank[k]:
pstz = pstd[z]
pstz.sort()
tmp = -1
for w in pstz:
if tmp >= w:
tmp += 1
else:
tmp = w
if k != l-1:
pstd[pre[z]].append(tmp+1)
else:
print(tmp+1)
#print(pstd)
```
| 10,649 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5 + 5) # 再帰回数の上限！！
n = int(input())
A = [-1] + [int(input()) - 1 for i in range(n-1)]
M = [[] for i in range(n)]
for i in range(1, n):
M[A[i]].append(i)
# 0-indexedの場合
V = [0] * n
# print(M)
def des(x):
D = []
V[x] = 1
for i in M[x]:
if V[i] == 0:
V[i] = 1
D.append(des(i))
D.sort(reverse=True)
# print(x,D)
for i in range(len(D)):
D[i] += i+1
if len(D) == 0:
ans = 0
else:
ans = max(D)
return ans
print(des(0))
```
| 10,650 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
n = I()
G = [[] for _ in range(n)]
win_against = [[] for _ in range(n)]
A = [-1]
for i in range(n - 1):
a = I()
A += [a - 1]
win_against[a - 1] += [i + 1]
in_degree = [len(i) for i in win_against]
dp = [0] * n
dq = deque()
for i in range(n):
if not in_degree[i]:
dq += ([i])
order = []
while dq:
x = dq.popleft()
order += [x]
if x == 0:
break
in_degree[A[x]] -= 1
if in_degree[A[x]] == 0:
dq += [A[x]]
for i in order:
ret = 0
s = sorted([dp[k] for k in win_against[i]])
for l in range(1, len(win_against[i]) + 1):
ret = max(ret, l + s.pop())
dp[i] = ret
print(dp[0])
```
| 10,651 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
def main():
N, *A = map(int, open(0))
E = [[] for _ in range(N + 1)]
for i, v in enumerate(A, 1):
E[v - 1].append(i)
def dfs(v):
D = sorted(map(dfs, E[v]))
return max([0] + [len(D) - i + d for i, d in enumerate(D)])
print(dfs(0))
main()
```
| 10,652 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
from collections import deque
import sys
input = sys.stdin.buffer.readline
N = int(input())
child = [[] for _ in range(N+1)]
for i in range(2, N+1):
par = int(input())
child[par].append(i)
que = deque()
que.append(1)
seq = []
while que:
v = que.popleft()
seq.append(v)
for u in child[v]:
que.append(u)
seq.reverse()
dp = [0] * (N+1)
for v in seq:
if child[v]:
w_child = []
for u in child[v]:
w_child.append(dp[u])
w_child.sort(reverse=True)
w = [w_child[i] + i + 1 for i in range(len(w_child))]
dp[v] = max(w)
print(dp[1])
```
| 10,653 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**6)
n = int(input())
tree = [list() for _ in range(n+1)]
for i in range(2,n+1):
a = int(input())
tree[a].append(i)
win = [0]*(n+1)
def dfs(v,win):
if tree[v] == []:
win[v] = 0
return win[v]
l = list()
for x in tree[v]:
dfs(x,win)
l.append(win[x])
l.sort(reverse=True)
win[v] = max(i+1+l[i] for i in range(len(l)))
return win[v]
print(dfs(1,win))
```
| 10,654 |
Provide a correct Python 3 solution for this coding contest problem.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
"Correct Solution:
```
# -*- coding: utf-8 -*-
from sys import setrecursionlimit
setrecursionlimit(10000000)
N = int(input())
C = [[] for _ in range(N)]
for i in range(1, N):
C[int(input())-1].append(i)
def cal(x):
if len(C[x]) == 0:
return 0
else:
D = sorted([cal(a) for a in C[x]], reverse=True)
res = 0
for i, d in enumerate(D, start=1):
res = max(res, i+d)
return res
print(cal(0))
```
| 10,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
from sys import stdin, setrecursionlimit
setrecursionlimit(10**7)
def solve():
N = int(stdin.readline())
Adj = [[] for i in range(N)]
for i in range(N - 1):
a = int(stdin.readline()) - 1
Adj[a].append(i + 1)
ans = dfs(N, Adj, 0, -1)
print(ans)
def dfs(N, Adj, v, p):
dl = []
for u in Adj[v]:
if u == p:
continue
dl.append(dfs(N, Adj, u, v))
dl.sort(reverse=True)
if not dl:
return 0
res = max(dl[i] + i + 1 for i in range(len(dl)))
return res
if __name__ == '__main__':
solve()
```
Yes
| 10,656 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**9)
n=int(input())
A=[int(input())-1 for _ in range(n-1)]
C=[[] for _ in range(n)]
for i,a in enumerate(A):
C[a].append(i+1)
def depth(k):
l=len(C[k])
if not l:
return 0
else:
D=[]
ret=-1
for c in C[k]:
D.append(depth(c))
D.sort(reverse=True)
for i,d in enumerate(D):
ret=max(ret,d+i+1)
return ret
print(depth(0))
```
Yes
| 10,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import sys
sys.setrecursionlimit(10 ** 7)
N = int(input())
edge = [[] for _ in range(N)]
for node in range(1, N):
a = int(input())
edge[a-1].append(node)
def dfs(n):
"""
dfs(n) := nを根としたトーナメントの深さ
nの深さを浅くしたい
-> 深い場所に浅い頂点vを割り当てる
-> 対戦数が少ない人から対戦していく
"""
if not edge[n]:
return 0
que = []
for v in edge[n]:
que.append(dfs(v))
que.sort(reverse=True)
res = 0
for plus, depth in enumerate(que, start=1):
# 今までの対戦数 + どれくらい深くするか
res = max(res, depth + plus)
return res
print(dfs(0))
```
Yes
| 10,658 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import sys
input = sys.stdin.readline
N = int(input())
v = [[] for _ in range(N)]
for i in range(N - 1) :
a = int(input())
v[a-1].append(i + 1)
l = [0]
i = 0
while i < len(l) :
cur = l[i]
for nex in v[cur] :
l.append(nex)
i += 1
dp = [0] * N
while len(l) > 0 :
cur = l.pop()
ret = []
for nex in v[cur] :
ret.append(dp[nex])
if len(ret) == 0 :
continue
ret.sort(reverse=True)
dp[cur] = max([i + 1 + ret[i] for i in range(len(ret))])
print(dp[0])
```
Yes
| 10,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
n = int(input())
tree = [[] for i in range(n)]
for i in range(n - 1):
j = int(input())
j -= 1
i += 1
tree[i].append(j)
tree[j].append(i)
def dfs(pos):
if pos != 0 and len(tree[pos]) == 1:
return 1
li = []
for next_pos in tree[pos]:
if visited[next_pos]:
continue
visited[next_pos] = True
li.append(dfs(next_pos))
max_li = max(li)
len_li = len(li)
res = max(len_li + 1, max_li + 1)
return res
visited = [False] * n
visited[0] = True
print(dfs(0) - 1)
```
No
| 10,660 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
import queue
n = int(input())
wl = [[] for i in range(n+1)]
for i in range(2,n+1):
ai = int(input())
wl[ai].append(i)
dp = [-1 for i in range(n+1)]
def calc_dp(a):
if len(wl[a]) == 0:
return 0
else:
dps = []
for i in wl[a]:
dps.append(calc_dp(i))
dps.sort(reverse=True)
ma = 0
for i,dpi in enumerate(dps):
if ma < dpi+i:
ma = dpi+i
return ma+1
print(calc_dp(1))
```
No
| 10,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
#優勝者からの深さmax?
#優勝者が最初に負かした奴が沢山倒しているなら
n = int(input())
a=[0]+[int(input())-1 for _ in range(n-1)]
b = [[] for _ in range(n)]
for i in range(1,n):
b[a[i]].append(i)
from collections import deque
Q = deque()
d=[-1]*n
d[0]=0
Q.append(0)
while Q:
p=Q.popleft()
for q in b[p]:
if d[q]<0:
d[q]=d[p]+1
Q.append(q)
mxd = max(d)##保存しないと毎回求める
ans = mxd-1
for i in range(n):
if d[i]==mxd:
ans += 1
print(ans)
```
No
| 10,662 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
N contestants participated in a competition. The total of N-1 matches were played in a knockout tournament. For some reasons, the tournament may not be "fair" for all the contestants. That is, the number of the matches that must be played in order to win the championship may be different for each contestant. The structure of the tournament is formally described at the end of this statement.
After each match, there were always one winner and one loser. The last contestant standing was declared the champion.
<image>
Figure: an example of a tournament
For convenience, the contestants were numbered 1 through N. The contestant numbered 1 was the champion, and the contestant numbered i(2 ≦ i ≦ N) was defeated in a match against the contestant numbered a_i.
We will define the depth of the tournament as the maximum number of the matches that must be played in order to win the championship over all the contestants.
Find the minimum possible depth of the tournament.
The formal description of the structure of the tournament is as follows. In the i-th match, one of the following played against each other:
* Two predetermined contestants
* One predetermined contestant and the winner of the j-th match, where j(j<i) was predetermined
* The winner of the j-th match and the winner of the k-th match, where j and k (j,k<i, j ≠ k) were predetermined
Such structure is valid structure of the tournament, if and only if no contestant who has already been defeated in a match will never play in a match, regardless of the outcome of the matches.
Constraints
* 2 ≦ N ≦ 10^5
* 1 ≦ a_i ≦ N(2 ≦ i ≦ N)
* It is guaranteed that the input is consistent (that is, there exists at least one tournament that matches the given information).
Input
The input is given from Standard Input in the following format:
N
a_2
:
a_N
Output
Print the minimum possible depth of the tournament.
Examples
Input
5
1
1
2
4
Output
3
Input
7
1
2
1
3
1
4
Output
3
Input
4
4
4
1
Output
3
Submitted Solution:
```
n = int(input())
lst = [0 for i in range(n+1)]
a = [-1 for i in range(n+1)]
for i in range(n+1):
if i <= 1: continue
ai = int(input())
a[i] = ai
lst[ai] += 1
dic = {}
for i in range(n+1):
if i <= 1: continue
if a[i] in dic:
dic[a[i]].append((lst[i], i))
else:
dic[a[i]] = [(lst[i], i)]
for key in dic:
dic[key].sort()
tempmax = 0
now = 0
nxt = 1
while nxt != None:
tempmax = max(tempmax, lst[nxt]+now)
if nxt in dic:
nxt = dic[nxt].pop()[1]
else:
nxt = None
now += 1
print(tempmax)
```
No
| 10,663 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
"Correct Solution:
```
from functools import reduce
mod = 924844033
frac = [1]*5555
for i in range(2,5555):
frac[i] = i * frac[i-1]%mod
fraci = [None]*5555
fraci[-1] = pow(frac[-1], mod -2, mod)
for i in range(-2, -5555, -1):
fraci[i] = fraci[i+1] * (5555 + i + 1) % mod
N, K = map(int, input().split())
dp = [[[0]*3 for _ in range(N)] for _ in range(-(-N//(2*K)) + 1)]
def merge(A, B):
C = [0]*(len(A) + len(B) - 1)
for i in range(len(A)):
for j in range(len(B)):
C[i+j] = (C[i+j] + A[i]*B[j]) % mod
return C
for j in range(min(N, 2*K)):
dp[0][j][2] = 1
if j + K <= N-1:
dp[1][j][0] = 1
if j - K >= 0:
dp[1][j][1] = 1
for i in range(-(-N//(2*K)) + 1):
for j in range(N):
if j + 2*K > N - 1:
break
r = dp[i][j][0]
l = dp[i][j][1]
n = dp[i][j][2]
if i == -(-N//(2*K)):
dp[i][j+2*K][2] = (dp[i][j+2*K][2] + r + l + n) % mod
continue
if j + 3*K <= N - 1:
dp[i+1][j+2*K][0] = (dp[i+1][j+2*K][0] + r + l + n) % mod
dp[i][j+2*K][2] = (dp[i][j+2*K][2] + r + l + n) % mod
dp[i+1][j+2*K][1] = (dp[i+1][j+2*K][1] + l + n) % mod
Ans = []
for j in range(min(2*K, N)):
j = - 1 - j
Ans.append([sum(dp[i][j]) for i in range(-(-N//(2*K)) + 1)])
A = reduce(merge, Ans)
A = [((-1)**i * frac[N - i] * a)%mod for i, a in enumerate(A)]
print(sum(A)%mod)
```
| 10,664 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
"Correct Solution:
```
from collections import defaultdict
n,k = map(int,input().split())
mod = 924844033
rng = 2010
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
for i in range(1,rng):
finv.append(pow(fctr[i],mod-2,mod))
def cmb(n,k):
if n<0 or k<0:
return 0
else:
return fctr[n]*finv[n-k]*finv[k]%mod
if (n-k)*2 <= n:
x = (n-k)*2
ans = 0
for i in range(x+1):
if i%2 == 0:
ans += cmb(x,i)*fctr[n-i]
else:
ans -= cmb(x,i)*fctr[n-i]
ans %= mod
print(ans)
exit()
dc = defaultdict(int)
for j in range(1,k+1):
a = j
b = k+j
cnt = 0
while a<=n and b<=n:
if a>b:
b += 2*k
else:
a += 2*k
cnt += 1
dc[cnt] += 2
nn = (n-k)*2
cp = set()
cpp = 1
for i,x in dc.items():
for j in range(x):
cpp += i
cp.add(cpp)
cp.add(1)
dp = [[0 for j in range(n+1)] for i in range(nn+1)]
dp[0][0] = 1
for i in range(1,nn+1):
dp[i] = dp[i-1][:]
if i not in cp:
for j in range(1,min(i,n)+1):
dp[i][j] += dp[i-2][j-1]
dp[i][j] %= mod
else:
for j in range(1,min(i,n)+1):
dp[i][j] += dp[i-1][j-1]
dp[i][j] %= mod
ans = 0
for i in range(n+1):
if i%2 == 0:
ans += fctr[n-i]*dp[nn][i]
else:
ans -= fctr[n-i]*dp[nn][i]
ans %= mod
print(ans)
```
| 10,665 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
"Correct Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod=924844033
n,k=LI()
fac = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
dp=[[0]*2 for _ in range(n+1)]
dp[0][0]=1
last=0
for i in range(min(n,2*k)):
idx=i
while idx<n:
ndp = [[0] * 2 for _ in range(n+1)]
if idx==i:
for ll in range(n+1):
dp[ll][0]+=dp[ll][1]
dp[ll][1]=0
for l in range(1,n+1):
ndp[l][0]=sum(dp[l])
if idx-k>=0:
ndp[l][0]+=dp[l-1][0]
if idx+k<n:
ndp[l][1]=sum(dp[l-1])
ndp[l][0]%=mod
ndp[0][0]=1
dp=ndp
idx+=2*k
ans=fac[n]
for m in range(1,n+1):
if m%2:
ans-=sum(dp[m])*fac[n-m]%mod
else:
ans+=sum(dp[m])*fac[n-m]%mod
ans%=mod
print(ans)
```
| 10,666 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
Submitted Solution:
```
from itertools import permutations
MAX = 924844033
n, k = [int(x) for x in input().split()]
k_perm = permutations(range(1, n+1))
ans = 0
# ans_list = []
for perm in k_perm:
like = True
for i in range(n):
if abs(perm[i] - (i+1)) == k:
like = False
if like:
# ans_list.append(perm)
ans +=1
print(ans % MAX)
# print(ans_list)
```
No
| 10,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
Submitted Solution:
```
from collections import defaultdict
n,k = map(int,input().split())
mod = 924844033
rng = 2010
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
for i in range(1,rng):
finv.append(pow(fctr[i],mod-2,mod))
def cmb(n,k):
if n<0 or k<0:
return 0
else:
return fctr[n]*finv[n-k]*finv[k]%mod
if (n-k)*2 <= n:
x = (n-k)*2
ans = 0
for i in range(x+1):
if i%2 == 0:
ans += cmb(x,i)*fctr[n-i]
else:
ans -= cmb(x,i)*fctr[n-i]
ans %= mod
print(ans)
exit()
dc = defaultdict(int)
for j in range(1,k+1):
a = j
b = k+j
cnt = 0
while a<=n and b<=n:
if a>b:
b += 2*k
else:
a += 2*k
cnt += 1
dc[cnt] += 2
nn = (n-k)*2
cp = set()
cpp = 1
for i,x in dc.items():
for j in range(x):
cpp += i
cp.add(cpp)
cp.add(1)
dp = [[0 for j in range(n+1)] for i in range(nn+1)]
dp[0][0] = 1
for i in range(1,nn+1):
dp[i] = dp[i-1][:]
if i not in cp:
for j in range(1,min(i,n)+1):
dp[i][j] += dp[i-2][j-1]
else:
for j in range(1,min(i,n)+1):
dp[i][j] += dp[i-1][j-1]
dp[i][j] %= mod
ans = 0
for i in range(n+1):
if i%2 == 0:
ans += fctr[n-i]*dp[nn][i]
else:
ans -= fctr[n-i]*dp[nn][i]
ans %= mod
print(ans)
```
No
| 10,668 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
Submitted Solution:
```
import itertools
import numpy
a = input().split(" ")
N = int(a[0])
K = int(a[1])
l = list([i+1 for i in range(N)])
it = itertools.permutations(l,N)
itNum = numpy.array(list(it))
lNum = numpy.array(l)
isK = itNum - lNum
ans = 0
for i in isK:
if not(K in i or -K in i):
ans += 1
print(ans%924844033)
```
No
| 10,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke loves permutations. He is making a permutation of length N.
Since he hates the integer K, his permutation will satisfy the following:
* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.
Among the N! permutations of length N, how many satisfies this condition?
Since the answer may be extremely large, find the answer modulo 924844033(prime).
Constraints
* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1
Input
The input is given from Standard Input in the following format:
N K
Output
Print the answer modulo 924844033.
Examples
Input
3 1
Output
2
Input
4 1
Output
5
Input
4 2
Output
9
Input
4 3
Output
14
Input
425 48
Output
756765083
Submitted Solution:
```
import itertools
def isContainedValueK(tup, k):
for i, t in enumerate(tup):
if t - (i + 1) == k or t - (i + 1) == -k:
return True
return False
n, k = map(int, input().split())
r = [i for i in range(1, n + 1)]
cnt = 0
for tup in itertools.permutations(r, n):
if not isContainedValueK(tup, k):
cnt += 1
print(cnt)
```
No
| 10,670 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while 1:
res = ""
check = []
try:
s = input()
for i in range(len(s)):
if i in check:
continue
elif s[i] == "@":
res = res + s[i+2] * int(s[i+1])
check.append(i+1)
check.append(i+2)
else:
res = res + s[i]
print(res)
except EOFError:
break
```
| 10,671 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while 1:
try:
s=list(input())
ans=""
while len(s)>0:
i=s.pop(0)
if i=="@":
c=s.pop(0)
l=s.pop(0)
ans+=l*int(c)
else:ans+=i
print(ans)
except:break
```
| 10,672 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while 1:
try:
word = input()
except EOFError:
break
newword = []
word = list(word)
while word != []:
w = word.pop(0)
if w == "@":
count = int(word.pop(0))
s = word.pop(0)
for _ in range(count):
newword.append(s)
else:
newword.append(w)
print(''.join(w for w in newword))
```
| 10,673 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while True :
try :
s = list(input())
except EOFError :
break
i = 0
while i < len(s) :
if s[i] == "@" :
for j in range(int(s[i+1])) :
print(s[i+2], end="")
i += 3
else :
print(s[i], end="")
i += 1
print()
```
| 10,674 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while True:
try:
s = input()
except EOFError:
break
r = ''
n = 1
for c in s:
if n < 0:
n = int(c)
elif c == '@':
n = -1
else:
r += c * n
n = 1
print(r)
```
| 10,675 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
import sys
for e in sys.stdin:
a,n='',1
for c in e[:-1]:
if'@'==c:n=0
elif n<1:n=int(c)
else:a+=c*n;n=1
print(a)
```
| 10,676 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while True:
try:
a = list(input())
except:
break
ans = ""
for i in range(len(a)-a.count("@")*2):
if a[i] == "@":
ans += a[i+2]*int(a[i+1])
del a[i+1:i+3]
else:
ans += a[i]
print(ans)
```
| 10,677 |
Provide a correct Python 3 solution for this coding contest problem.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
"Correct Solution:
```
while True:
try:
Tlist = list(input())
except:
break
while '@' in Tlist:
at = Tlist.index('@')
t = Tlist[at+2]
x = int(Tlist[at+1])
del(Tlist[at:at+3])
Tlist.insert(at,t*x)
print(''.join(Tlist))
```
| 10,678 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
# Aizu Problem 0077: Run Length
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def run_length(string):
out = ""
k = 0
while k < len(string):
char = string[k]
if char != '@':
out += char
k += 1
else:
cnt = int(string[k+1])
char = string[k+2]
out += char * cnt
k += 3
return out
for line in sys.stdin:
print(run_length(line.strip()))
```
Yes
| 10,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
if __name__ == '__main__':
ans = ""
while True:
try:
tmp = ""
ans = ""
line = input()
for x in line:
if x == "@":
tmp += "@"
else:
if len(tmp) == 0:
ans += x
else:
tmp += x
if len(tmp) == 3:
ans += tmp[2]*int(tmp[1])
tmp = ""
print(ans)
except EOFError:
break
```
Yes
| 10,680 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
while True:
try:
s_inp = input()
s_out = ""
flag = 0
for c in s_inp:
if flag == 1:
n = int(c)
flag = 2
elif flag == 2:
for i in range(n):
s_out = s_out + c
flag = 0
elif c == "@":
flag = 1
else:
s_out = s_out + c
print(s_out)
except:
break
```
Yes
| 10,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
while 1:
try:s=input()
except:break
i,a,n=0,'',1
for i in s:
if n==0:n=int(i)
elif i=='@': n=0
else:
a+=i*n
n=1
print(a)
```
Yes
| 10,682 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
import sys
for line in sys.stdin:
line = line.strip()
i = 0
ans = ""
while i < len(line):
if line[i] == "@":
m = int(line[i+1])
c = line[i+2]
i += 2
ans += m*c
else:
ans += line[i]
i += 1
print(ans)
```
No
| 10,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
import sys
for line in sys.stdin:
appendStrs = []
for i in range(0, len(line) ) :
if line[i] == "@" :
appendStrs.append((line[i:i+3], "".join([ line[i+2] for _ in range(0, int(line[i+1]) )]))) ;
for a in appendStrs :
line = line.replace(*a, 1)
print(line)
```
No
| 10,684 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
import re
import sys
for s in sys.stdin:
print(re.sub(r"@(\d)(.)", lambda m: m.group(2)*int(m.group(1)), s))
```
No
| 10,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If the strings are consecutive, you can replace the characters with a rule to shorten the string. For example, for the string AAAA, the expression @ 4A will compress one character. Create a program that restores the character string compressed by this rule to the original character string. However, it is assumed that the @ character does not appear in the restored character string.
In addition, the original character string is uppercase letters, lowercase letters, numbers, and symbols, and can be up to 100 characters, and consecutive characters can be up to 9 characters.
input
Multiple strings are given. One string is given per line. The number of strings does not exceed 50.
output
For each character string, output the restored character string for each character on one line.
Example
Input
ab@5C1@8050
@99+1=1@90
Output
abCCCCC10000000050
999999999+1=1000000000
Submitted Solution:
```
while True:
try:
string = input()
except:
break
ans = ""
for i in range(len(string)):
if string[i] == "@":
ans += int(string[i+1])*string[i+2]
else:
ans += string[i]
print(ans)
```
No
| 10,686 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
"Correct Solution:
```
from sys import stdin
readline = stdin.readline
from itertools import product
from operator import itemgetter
from math import isinf
def scrap_top_left(picture):
for py, px in product(range(len(picture)), repeat=2):
if picture[py][px] != -1:
return px, py
def is_match(window, picture, wx, wy):
for py, px in product(range(len(picture)), repeat=2):
if picture[py][px] == -1:
continue
if window[wy + py][wx + px] != picture[py][px]:
return False
return True
def search(window, picture):
for wy, wx in product(range(len(window) - len(picture) + 1), repeat=2):
if is_match(window, picture, wx, wy):
px, py = scrap_top_left(picture)
return wx + px + 1, wy + py + 1
return float('inf'), float('inf')
# http://d.hatena.ne.jp/odz/20070622/1182497414
def rotate_clockwise(matrix):
return [list(row) for row in zip(*reversed(matrix))]
while True:
window_size, picture_size = map(int, readline().split())
if window_size == 0:
break
window = [list(map(int, readline().split())) for _ in range(window_size)]
picture = [list(map(int, readline().split())) for _ in range(picture_size)]
top_left = []
for _ in range(4):
top_left.append(search(window, picture))
picture = rotate_clockwise(picture)
top_left = min(top_left, key=itemgetter(1, 0))
if isinf(top_left[0]):
print('NA')
else:
print(*top_left)
```
| 10,687 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
"Correct Solution:
```
from sys import stdin
from itertools import product
# from line_profiler import LineProfiler
def rotate_clockwise(matrix):
return list(map(list, zip(*matrix)))[::-1]
def main():
while(True):
n,m = map(int, stdin.readline().split())
if not n:
break
w = [list(map(int, stdin.readline().split())) for _ in range(n)]
p = [list(map(int, stdin.readline().split())) for _ in range(m)]
rp = [p]
for _ in range(3):
p = rotate_clockwise(p)
rp.append(p)
ds = [[ [i,j,rp[r][i][j]] for i,j in product(range(m),range(m)) if rp[r][i][j] != -1] for r in range(4)]
flag = True
for i,j,a in product(range(n-m+1),range(n-m+1),ds):
for b in a:
if w[i+b[0]][j+b[1]] - b[2]:
break
else:
print(j+a[0][1]+1,i+a[0][0]+1)
flag = False
break
if flag: print("NA")
if __name__ == "__main__":
# prf = LineProfiler()
# prf.add_function(main)
# prf.runcall(main)
# prf.print_stats()
main()
```
| 10,688 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
"Correct Solution:
```
while 1:
N, M = map(int, input().split())
if N == 0:
break
W = [list(map(int, input().split())) for i in range(N)]
P = [list(map(int, input().split())) for i in range(M)]
P0 = [[0]*M for i in range(M)]
ans = []
for t in range(4):
P1 = []
for i in range(M):
for j in range(M):
if P[i][j] == -1:
continue
P1.append((i, j, P[i][j]))
for y in range(N-M+1):
for x in range(N-M+1):
for i, j, p in P1:
if W[y+i][x+j] != p:
break
else:
i, j, p = P1[0]
ans.append((y+i+1, x+j+1))
break
else:
continue
break
for i in range(M):
for j in range(M):
P0[M-1-j][i] = P[i][j]
P0, P = P, P0
if ans:
y, x = min(ans)
print(x, y)
else:
print("NA")
```
| 10,689 |
Provide a correct Python 3 solution for this coding contest problem.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
"Correct Solution:
```
from itertools import product
def rotate(a):
return [[a[y][x] for y in range(len(a)-1, -1, -1)] for x in range(len(a))]
while True:
n, m = map(int, input().split())
if n == 0:
break
picture = [list(map(int, input().split())) for _ in [0]*n]
piece = [list(map(int, input().split())) for _ in [0]*m]
ans = []
for i in range(4):
for y, x in product(range(m), repeat=2):
if piece[y][x] != -1:
dx, dy = x+1, y+1
break
for (from_y, to_y), (from_x, to_x) in product(zip(range(n), range(m, n+1)), repeat=2):
for j, y in zip(range(m), range(from_y, to_y)):
if not all(v1 == -1 or v1 == v2 for v1, v2 in zip(piece[j], picture[y][from_x:to_x])):
break
else:
ans.append((from_y+dy, from_x+dx))
piece = rotate(piece)
ans.sort()
print(" ".join(map(str, ans[0][::-1])) if ans else "NA")
```
| 10,690 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
Submitted Solution:
```
def rotated(pic):
m = []
t = zip(*pic[::-1])
for row in t:
m.append(row)
return m
def is_match(window, pic_map, curr_x, curr_y):
for k, v in pic_map.items():
if k == 'head':
continue
for x, y in v:
if window[curr_x + x][curr_y + y] != k:
return False
return True
def really_pic(pic):
pic_map = {}
for i in range(len(pic)):
for j in range(len(pic[i])):
if pic[i][j] != -1:
if not pic_map.get('head'):
pic_map['head'] = (i, j)
if pic_map.get(pic[i][j]):
pic_map[pic[i][j]].append((i, j))
else:
pic_map[pic[i][j]] = [(i, j)]
return pic_map
def start():
while True:
m, n = map(int, input().split())
if m == 0 and n == 0:
break
window = []
pic = []
for _ in range(m):
window.append(list(map(int, input().split())))
for _ in range(n):
pic.append(list(map(int, input().split())))
map0 = really_pic(pic)
pic_rotated90 = rotated(pic)
map90 = really_pic(pic_rotated90)
pic_rotated180 = rotated(pic_rotated90)
map180 = really_pic(pic_rotated180)
pic_rotated270 = rotated(pic_rotated180)
map270 = really_pic(pic_rotated270)
map_rotated = [map0, map90, map180, map270]
res = algorithm(window, m, n, map_rotated)
print(res if type(res) == str else str(res[0]) + ' ' + str(res[1]))
def algorithm(window, m, n, map_rotated):
for map_ro in map_rotated:
for i in range(m - n + 1):
for j in range(m - n + 1):
if is_match(window, map_ro, i, j):
return j + map_ro['head'][1] + 1, i + map_ro['head'][0] + 1
return 'NA'
start()
```
No
| 10,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
Submitted Solution:
```
def rotated(pic):
m = []
t = zip(*pic[::-1])
for row in t:
m.append(row)
return m
def is_match(window, pic_map, curr_x, curr_y):
for k, v in pic_map.items():
if k == 'head':
continue
for x, y in v:
if window[curr_x + x][curr_y + y] != k:
return False
return True
def really_pic(pic):
pic_map = {}
for i in range(len(pic)):
for j in range(len(pic[i])):
if pic[i][j] != -1:
if not pic_map.get('head'):
pic_map['head'] = (i, j)
if pic_map.get(pic[i][j]):
pic_map[pic[i][j]].append((i, j))
else:
pic_map[pic[i][j]] = [(i, j)]
return pic_map
def start():
while True:
m, n = map(int, input().split())
if m == 0 and n == 0:
break
window = []
pic = []
for _ in range(m):
window.append(list(map(int, input().split())))
for _ in range(n):
pic.append(list(map(int, input().split())))
# print(pic)
map0 = really_pic(pic)
pic_rotated90 = rotated(pic)
# print(pic_rotated90)
map90 = really_pic(pic_rotated90)
pic_rotated180 = rotated(pic_rotated90)
# print(pic_rotated180)
map180 = really_pic(pic_rotated180)
pic_rotated270 = rotated(pic_rotated180)
# print(pic_rotated270)
map270 = really_pic(pic_rotated270)
map_rotated = [map0, map90, map180, map270]
res = algorithm(window, m, n, map_rotated)
print(res if type(res) == str else str(res[0]) + ' ' + str(res[1]))
def algorithm(window, m, n, map_rotated):
for map_ro in map_rotated:
for i in range(m - n + 1):
for j in range(m - n + 1):
if is_match(window, map_ro, i, j):
return j + map_ro['head'][1] + 1, i + map_ro['head'][0] + 1
return 'NA'
start()
```
No
| 10,692 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
Submitted Solution:
```
def rotated(pic):
m = []
t = zip(*pic[::-1])
for row in t:
m.append(row)
return m
def is_match(window, pic_map, curr_x, curr_y):
for k, v in pic_map.items():
if k == 'head':
continue
for x, y in v:
if window[curr_x + x][curr_y + y] != k:
return False
return True
def really_pic(pic):
pic_map = {}
for i in range(len(pic)):
for j in range(len(pic[i])):
if pic[i][j] != -1:
if not pic_map.get('head'):
pic_map['head'] = (i, j)
if pic_map.get(pic[i][j]):
pic_map[pic[i][j]].append((i, j))
else:
pic_map[pic[i][j]] = [(i, j)]
return pic_map
def start():
while True:
m, n = map(int, input().split())
if m == 0 and n == 0:
break
window = []
pic = []
for _ in range(m):
window.append(list(map(int, input().split())))
for _ in range(n):
pic.append(list(map(int, input().split())))
map0 = really_pic(pic)
pic_rotated90 = rotated(pic)
map90 = really_pic(pic_rotated90)
pic_rotated180 = rotated(pic_rotated90)
map180 = really_pic(pic_rotated180)
pic_rotated270 = rotated(pic_rotated180)
map270 = really_pic(pic_rotated270)
map_rotated = [map0, map270, map180, map90]
res = algorithm(window, m, n, map_rotated)
print(res if type(res) == str else str(res[0]) + ' ' + str(res[1]))
def algorithm(window, m, n, map_rotated):
for map_ro in map_rotated:
for i in range(m - n + 1):
for j in range(m - n + 1):
if is_match(window, map_ro, i, j):
return j + map_ro['head'][1] + 1, i + map_ro['head'][0] + 1
return 'NA'
start()
```
No
| 10,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. A came to Aizu for sightseeing. You can overlook the Aizu Basin from the window of the hotel where you stayed. As I was looking at the scenery, I noticed a piece of the photo on the floor. Apparently I took the outside view from the window. "Which area did you take?" A asked, holding the photo so that the view outside the window and the picture were the same size, and began looking for a place where the picture and the view outside the window matched. ..
Now let's do what Mr. A is doing on his computer. Divide the view outside the window into squares of n x n squares (n is called the size of the view). Each cell has an integer greater than or equal to 0 that represents the information in the image of that cell. The position of the cell is represented by the coordinates (x, y). The coordinates of each square are as follows.
<image>
A piece of a photo is represented by a square of m x m squares (m is called the size of the piece of the photo). In this square, the image information is written in the square of the piece, and -1 is written in the square of the part not included in the piece. For example, in the figure below, the colored areas represent the shape of the actual photo scraps. There may be holes in the pieces, but they are always connected together. (If cells with a value greater than or equal to 0 touch only at the vertices, they are considered unconnected.) Also, cells with a value of -1 are not lined up in a vertical or horizontal column from end to end.
<image>
In the view through the window, look for an area that matches a piece of the photo rotated 0, 90, 180, or 270 degrees. For example, if the landscape looks like the one below, you can rotate the piece in the above figure 90 degrees counterclockwise to match the colored area.
<image>
Entering the information of the view from the window and the piece of the photo, the square closest to the top of the area that matches any of the pieces rotated by 0, 90, 180, or 270 degrees is the closest to the left end. Create a program that outputs the coordinates of the mass.
If there are multiple matching areas, output the coordinates of the cell closest to the leftmost of the cells in those areas. If there is no matching area, NA is output.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
n m
w11 w12 ... w1n
w21 w22 ... w2n
::
wn1 wn2 ... wnn
p11 p12 ... p1m
p21 p22 ... p2m
::
pm1 pm2 ... pmm
The first line gives n, m (1 ≤ n ≤ 100, 1 ≤ m ≤ 50, m ≤ n).
The next n lines give information about the view from the window wij (0 ≤ wij ≤ 15), and the following m lines give information about the data of the photo scraps pij (-1 ≤ pij ≤ 15).
The number of datasets does not exceed 100.
Output
Outputs the coordinates or NA of the mass position on one line for each input dataset.
Example
Input
8 4
2 1 3 1 1 5 1 3
2 3 2 4 1 0 2 1
0 3 1 2 1 1 4 2
1 2 3 2 1 1 5 4
0 2 0 1 1 3 2 1
1 3 1 2 2 4 3 2
5 1 2 1 4 1 1 5
4 1 1 0 1 2 2 1
2 -1 -1 -1
0 3 -1 -1
-1 2 2 4
-1 1 -1 1
5 3
1 0 2 3 5
2 3 7 2 1
2 5 4 2 2
8 9 0 3 3
3 6 0 4 7
-1 -1 2
-1 3 5
0 4 -1
0 0
Output
4 2
NA
Submitted Solution:
```
""" Created by Jieyi on 10/9/16. """
import io
import sys
# Simulate the redirect stdin.
if len(sys.argv) > 1:
filename = sys.argv[1]
inp = ''.join(open(filename, "r").readlines())
sys.stdin = io.StringIO(inp)
def print_map(window):
for i in range(len(window)):
print(window[i])
def rotated(pic):
return [list(row) for row in zip(*reversed(pic))]
def input_source():
while True:
m, n = map(int, input().split())
if m == 0 and n == 0:
break
window = [list(map(int, input().split())) for _ in range(m)]
pic = [list(map(int, input().split())) for _ in range(n)]
res = algorithm(m, n, window, pic)
print(res if type(res) == str else str(res[0]) + ' ' + str(res[1]))
def match(start_x, start_y, window, fragment):
for h in range(len(fragment)):
for w in range(len(fragment[h])):
if fragment[h][w] == -1:
continue
if fragment[h][w] != window[start_x + h][start_y + w]:
return False
return True
def algorithm(m, n, window, fragment):
origin = fragment
rotated_270 = rotated(origin)
rotated_180 = rotated(rotated_270)
rotated_90 = rotated(rotated_180)
array = [origin, rotated_90, rotated_180, rotated_270]
for pic in array:
for h in range(m - n + 1):
for w in range(m - n + 1):
if match(h, w, window, pic):
for h_p in range(len(pic)):
for w_p in range(len(pic[h_p])):
if pic[h_p][w_p] != -1:
return w + w_p + 1, h + h_p + 1
return 'NA'
def main():
input_source()
if __name__ == '__main__':
main()
```
No
| 10,694 |
Provide a correct Python 3 solution for this coding contest problem.
If you visit Aizu Akabeko shrine, you will find a unique paper fortune on which a number with more than one digit is written.
Each digit ranges from 1 to 9 (zero is avoided because it is considered a bad omen in this shrine). Using this string of numeric values, you can predict how many years it will take before your dream comes true. Cut up the string into more than one segment and compare their values. The difference between the largest and smallest value will give you the number of years before your wish will be fulfilled. Therefore, the result varies depending on the way you cut up the string. For example, if you are given a string 11121314 and divide it into segments, say, as 1,11,21,3,14, then the difference between the largest and smallest is 21 - 1 = 20. Another division 11,12,13,14 produces 3 (i.e. 14 - 11) years. Any random division produces a game of luck. However, you can search the minimum number of years using a program.
Given a string of numerical characters, write a program to search the minimum years before your wish will be fulfilled.
Input
The input is given in the following format.
n
An integer n is given. Its number of digits is from 2 to 100,000, and each digit ranges from 1 to 9.
Output
Output the minimum number of years before your wish will be fulfilled.
Examples
Input
11121314
Output
3
Input
123125129
Output
6
Input
119138
Output
5
"Correct Solution:
```
n = input()
length = len(n)
ans = 10
#2桁,1桁混合
lst = []
ind = 0
while ind < length:
if n[ind] == "1" and ind + 1 <= length - 1:
lst.append(int(n[ind:ind + 2]))
ind += 2
else:
lst.append(int(n[ind]))
ind += 1
if len(lst) >= 2:
ans = min(ans, max(lst) - min(lst))
#n桁のみ
divisors = []
for i in range(1, length // 2 + 1):
if length % i == 0:
divisors.append(i)
for i in divisors:
lst = []
for j in range(0, length, i):
lst.append(int(n[j:j + i]))
ans = min(ans, max(lst) - min(lst))
print(ans)
```
| 10,695 |
Provide a correct Python 3 solution for this coding contest problem.
If you visit Aizu Akabeko shrine, you will find a unique paper fortune on which a number with more than one digit is written.
Each digit ranges from 1 to 9 (zero is avoided because it is considered a bad omen in this shrine). Using this string of numeric values, you can predict how many years it will take before your dream comes true. Cut up the string into more than one segment and compare their values. The difference between the largest and smallest value will give you the number of years before your wish will be fulfilled. Therefore, the result varies depending on the way you cut up the string. For example, if you are given a string 11121314 and divide it into segments, say, as 1,11,21,3,14, then the difference between the largest and smallest is 21 - 1 = 20. Another division 11,12,13,14 produces 3 (i.e. 14 - 11) years. Any random division produces a game of luck. However, you can search the minimum number of years using a program.
Given a string of numerical characters, write a program to search the minimum years before your wish will be fulfilled.
Input
The input is given in the following format.
n
An integer n is given. Its number of digits is from 2 to 100,000, and each digit ranges from 1 to 9.
Output
Output the minimum number of years before your wish will be fulfilled.
Examples
Input
11121314
Output
3
Input
123125129
Output
6
Input
119138
Output
5
"Correct Solution:
```
def sub(maxs, mins):
for i in range(len(maxs)):
if maxs[i] != mins[i]:
if i == len(maxs)-1:
return int(maxs[i]) - int(mins[i])
if i == len(maxs)-2:
return int(maxs[i:i+2]) - int(mins[i:i+2])
return 10
return 0
def checkEqual(S):
ans = 8
for k in range(1, len(S)):
if len(S)%k != 0: continue
mins = maxs = S[0:k]
for s in range(0, len(S), k):
maxs = max(maxs, S[s:s+k])
mins = min(mins, S[s:s+k])
ans = min(ans, sub(maxs, mins))
return ans
def check12(S):
maxv = 0
minv = 10
p = 0
while p < len(S):
v = int(S[p])
if S[p] == '1' and p+1 < len(S):
v = 10 + int(S[p+1])
p += 1
maxv = max(maxv, v)
minv = min(minv, v)
p += 1
return maxv - minv
S = input()
print(min(checkEqual(S), check12(S)))
```
| 10,696 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you visit Aizu Akabeko shrine, you will find a unique paper fortune on which a number with more than one digit is written.
Each digit ranges from 1 to 9 (zero is avoided because it is considered a bad omen in this shrine). Using this string of numeric values, you can predict how many years it will take before your dream comes true. Cut up the string into more than one segment and compare their values. The difference between the largest and smallest value will give you the number of years before your wish will be fulfilled. Therefore, the result varies depending on the way you cut up the string. For example, if you are given a string 11121314 and divide it into segments, say, as 1,11,21,3,14, then the difference between the largest and smallest is 21 - 1 = 20. Another division 11,12,13,14 produces 3 (i.e. 14 - 11) years. Any random division produces a game of luck. However, you can search the minimum number of years using a program.
Given a string of numerical characters, write a program to search the minimum years before your wish will be fulfilled.
Input
The input is given in the following format.
n
An integer n is given. Its number of digits is from 2 to 100,000, and each digit ranges from 1 to 9.
Output
Output the minimum number of years before your wish will be fulfilled.
Examples
Input
11121314
Output
3
Input
123125129
Output
6
Input
119138
Output
5
Submitted Solution:
```
n = input()
length = len(n)
ans = 10
#2桁,1桁混合
lst = []
ind = 0
while ind < length:
if n[ind] == "1" and ind + 1 <= length - 1:
lst.append(int(n[ind:ind + 2]))
ind += 2
else:
lst.append(int(n[ind]))
ind += 1
ans = min(ans, max(lst) - min(lst))
#n桁のみ
divisors = []
for i in range(1, length // 2 + 1):
if length % i == 0:
divisors.append(i)
for i in divisors:
lst = []
for j in range(0, length, i):
lst.append(int(n[j:j + i]))
ans = min(ans, max(lst) - min(lst))
print(ans)
```
No
| 10,697 |
Provide a correct Python 3 solution for this coding contest problem.
Compute A + B.
Constraints
* -1000 ≤ A, B ≤ 1000
Input
The input will consist of a series of pairs of integers A and B separated by a space, one pair of integers per line. The input will be terminated by EOF.
Output
For each pair of input integers A and B, you must output the sum of A and B in one line.
Example
Input
1 2
10 5
100 20
Output
3
15
120
"Correct Solution:
```
import sys
for line in sys.stdin:
line = line.split(' ')
print(sum(map(int, line)))
```
| 10,698 |
Provide a correct Python 3 solution for this coding contest problem.
Compute A + B.
Constraints
* -1000 ≤ A, B ≤ 1000
Input
The input will consist of a series of pairs of integers A and B separated by a space, one pair of integers per line. The input will be terminated by EOF.
Output
For each pair of input integers A and B, you must output the sum of A and B in one line.
Example
Input
1 2
10 5
100 20
Output
3
15
120
"Correct Solution:
```
while True:
try:
a, b = map(int, input().split())
print(a+b)
except EOFError as e:
break
```
| 10,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.