text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n=int(input())
s=input()
r=s.count("R")
g=s.count("G")
b=s.count("B")
ans=0
for i in range(1,(n-1)//2+1):
for k in range(n-2*i):
if s[k]!=s[k+i] and s[k+i]!=s[k+2*i] and s[k+2*i]!=s[k]:
ans-=1
print(r*g*b+ans)
```
| 12,300 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n=int(input())
s=input()
r=s.count("R")
g=s.count("G")
b=n-r-g
ans=r*g*b
for i in range(1,n):
for j in range(n):
if(j+i*2>=n):break
d1,d2,d3=s[j],s[j+i],s[j+i*2]
if(not(d1==d2 or d2==d3 or d1==d3)):ans-=1
print(ans)
```
| 12,301 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n=int(input())
s=input()
ans=s.count("R")*s.count("G")*s.count("B")
for j in range(n):
J=s[j]
for i in range(j):
k=2*j-i
if k<n:
I=s[i]
K=s[k]
if I!=J!=K!=I:
ans-=1
print(ans)
```
| 12,302 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n=int(input());s=input();c=s.count;print(c('R')*c('G')*c('B')-sum(len(set(s[i:j+1:(j-i)//2]))>2for i in range(n-2)for j in range(i+2,n,2)))
```
| 12,303 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
N=int(input())
S=list(input())
ans=S.count('R')*S.count('G')*S.count('B')
i=0
while i<N-1:
j=i+1
while 2*j-i<N:
ans-=1*(S[i]!=S[j])*(S[j]!=S[2*j-i])*(S[2*j-i]!=S[i])
j+=1
i+=1
print(ans)
```
| 12,304 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n=int(input());s=[*input()]
count=s.count('R')*s.count('G')*s.count('B')
for i in range(n+1):
for j in range(i,n+1):
k=2*j-i
if k<n:
if s[i]!=s[j] and s[j]!=s[k] and s[i]!=s[k]:
count-=1
print(count)
```
| 12,305 |
Provide a correct Python 3 solution for this coding contest problem.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
"Correct Solution:
```
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n - 2):
for j in range(1, (n - i + 1) // 2):
if s[i] != s[i+j] and s[i+j] != s[i+j*2] and s[i+j*2] != s[i]:
ans -= 1
print(ans)
```
| 12,306 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
N = int(input())
S = input()
ans, gap = S.count('R') * S.count('G') * S.count('B'), 1
while gap * 2 + 1 <= N:
ans -= sum([1 for i in range(N - gap * 2)
if {'R', 'G', 'B'} == {S[i], S[i + gap], S[i + 2 * gap]}])
gap += 1
print(ans)
```
Yes
| 12,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
N = int(input())
S = input()
ans = S.count('R') * S.count('G') * S.count('B')
for i in range(N-1):
for j in range(i+1, N):
k = 2*j-i
if k <= N-1 and S[i] != S[j] and S[j] != S[k] and S[k] != S[i]:
ans -= 1
print(ans)
```
Yes
| 12,308 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
n=int(input())
a = input()
c = 0
for i in range(1,n//2 +1):
for j in range(n-2*i):
if a[j] != a[j+i] and a[j+i] != a[j+2*i] and a[j] != a[j+2*i]:
c+=1
ans = a.count("R") * a.count("G") * a.count("B") - c
print(ans)
```
Yes
| 12,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
n = int(input())
s = list(input())
cnt = 0
cnt += s.count('R')*s.count('G')*s.count('B')
for i in range(1,n-1):
for j in range(1,min(i,n-i-1)+1):
if s[i-j]!=s[i] and s[i]!=s[i+j] and s[i+j]!=s[i-j]:
cnt -= 1
print(cnt)
```
Yes
| 12,310 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
# input
N = int(input())
S = input()
# process
R = []
G = []
B = []
for i, s in enumerate(list(S)):
if s == 'R':
R.append(i)
elif s == 'G':
G.append(i)
else:
B.append(i)
ans = 0
for r in R:
for g in G:
for b in B:
if r < g:
if g < b:
if b-g != g-r:
ans += 1
else:
if r < b:
if g-b != b-r:
ans += 1
else:
if g-r != r-b:
ans += 1
else:
if r < b:
if b-r != r-g:
ans += 1
else:
if g < b:
if r-b != b-g:
ans += 1
else:
if r-g != g-b:
ans += 1
# output
print(ans)
```
No
| 12,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
c =0
N = int(input())+1
S = tuple(input())
for i in range(1,N):
for j in range(1,N):
if i > j:
continue
elif S[i-1] == S[j-1]:
continue
for k in range(1,N):
if j > k:
continue
elif S[i-1] == S[k-1]:
continue
elif S[j-1] == S[k-1]:
continue
elif j - i == k - j:
continue
else:
c += 1
print(c)
```
No
| 12,312 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
s=str(input())
s=list(s)
import numpy as np
def なんか(a,b,c):
ans=0
for i in a:
tmp_b = b[b>i]
for j in tmp_b:
if j+j-i in c:
ans+=len(c[(c>j)])-1
else:
ans+=len(c[(c>j)])
tmp_c = c[c>i]
for j in tmp_c:
if j+j-i in b:
ans+=len(b[(b>j)])-1
else:
ans+=len(b[(b>j)])
return ans
r1=[]
b1=[]
g1=[]
for i, v in enumerate(s):
if v=="R":
r1+=[i]
elif v=="B":
b1+=[i]
else:
g1+=[i]
r1 = np.array(r1)
b1 = np.array(b1)
g1 = np.array(g1)
print(なんか(r1, g1, b1)+なんか(g1, b1, r1)+なんか(b1,r1,g1))
```
No
| 12,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a string S of length N consisting of `R`, `G`, and `B`.
Find the number of triples (i,~j,~k)~(1 \leq i < j < k \leq N) that satisfy both of the following conditions:
* S_i \neq S_j, S_i \neq S_k, and S_j \neq S_k.
* j - i \neq k - j.
Constraints
* 1 \leq N \leq 4000
* S is a string of length N consisting of `R`, `G`, and `B`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of triplets in question.
Examples
Input
4
RRGB
Output
1
Input
39
RBRBGRBGGBBRRGBBRRRBGGBRBGBRBGBRBBBGBBB
Output
1800
Submitted Solution:
```
N = int(input())
I = input()
R = I.count('R')
G = I.count('G')
B = I.count('B')
sum = R * G * B
for i in range(N):
for j in range(i+1,N):
if I[i] != I[j]:
k = j + j - i
if k >= N:
continue
if I[i] != I[k] and I[j] != I[k]:
sum -= 1
print(sum)
```
No
| 12,314 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
import sys
X = int(input())
if (X//100)*5 >= X%100:
print(1)
else:
print(0)
```
| 12,315 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
a=int(input())
b=a//100
if b*5>=a%100:
print(1)
else:
print(0)
```
| 12,316 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
X = int(input())
if X % 100 <= ((X // 100) * 5):
print(1)
else:
print(0)
```
| 12,317 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
x=int(input())
y=x//100
z=x-y*100
if z>5*y:
print(0)
else:
print(1)
```
| 12,318 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
x = int(input())
q = x // 100
print('1') if (x <= q*100 + q*5) else print('0')
```
| 12,319 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
x=int(input())
if x%100>(x//100)*5:
print(0)
else:
print(1)
```
| 12,320 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
X=int(input())
print(1 if X>=2100 or X//100*5>=X%100 else 0)
```
| 12,321 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
"Correct Solution:
```
X=int(input())
a=X//100
print(0 if a*5<X-a*100 else 1)
```
| 12,322 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
x = int(input())
a = x//100
b = x%100
if b <= 5*a:
print(1)
exit()
print(0)
```
Yes
| 12,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
n=int(input())
try:print(+(n%100/(n//100)<=5))
except:print(+(n<1))
```
Yes
| 12,324 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
x = int(input())
if x%100 <= x//100 * 5:
print(1)
else:
print(0)
```
Yes
| 12,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
x = int(input())
k = x//100
if k*5+k*100 >= x:
print(1)
else:
print(0)
```
Yes
| 12,326 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
def is_eq(X):
# 品数の個数をaとする
a_list = range(1, 1000)
for a in a_list:
if 100 * a <= x & x <= a * 105:
return 1
else:
return 0
X = int(input())
print(is_eq(X))
```
No
| 12,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
X = int(input())
# 100 * 21 = 105 * 20, が最大の可換性であり，基本的にはあり得る組み合わせは非常に少ない.それ以外は
# 100 * 26 = 104 * 25, 100 * 101 = 101 * 100,これとかはありえない,100*51 = 102 * 50,とかはありえる
#100000/100 = 1000せいぜい商品の合計は1000子である10^3ならば10^3 ６回ループ回してもOK10^18になるけど?
import sys
for a in range(1001): # aだけは1000の場合がありうるわ
for b in range(1000):
for c in range(1000):
for d in range(1000):
for e in range(1000):
for f in range(1000):
price = a*100 + b*101 + c*102 + d*103 + e*104 + f*105
rest = X-price
if rest >= 0:
if rest%100 == 0 or rest%101==0 or rest%102==0 or rest%103==0 or rest%104==0 or rest%105==0:
print(1)
sys.exit()
print(0)
```
No
| 12,328 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
N = int(input())
l = 100; r = 105
for i in range(5000):
if l <= N <= r:
print(1)
break
l += 100
r += 105
print(0)
```
No
| 12,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoder Mart sells 1000000 of each of the six items below:
* Riceballs, priced at 100 yen (the currency of Japan) each
* Sandwiches, priced at 101 yen each
* Cookies, priced at 102 yen each
* Cakes, priced at 103 yen each
* Candies, priced at 104 yen each
* Computers, priced at 105 yen each
Takahashi wants to buy some of them that cost exactly X yen in total. Determine whether this is possible.
(Ignore consumption tax.)
Constraints
* 1 \leq X \leq 100000
* X is an integer.
Input
Input is given from Standard Input in the following format:
X
Output
If it is possible to buy some set of items that cost exactly X yen in total, print `1`; otherwise, print `0`.
Examples
Input
615
Output
1
Input
217
Output
0
Submitted Solution:
```
def subset_sum(numbers, target, partial=[]):
s = sum(partial)
# check if the partial sum is equals to target
if s == target:
print("1")
return
if s > target:
print("0")
exit()
for i in range(len(numbers)):
n = numbers[i]
remaining = numbers[i+1:]
subset_sum(remaining, target, partial + [n])
N = int(input())
subset_sum([100,101,102,103,104,105],N)
```
No
| 12,330 |
Provide a correct Python 3 solution for this coding contest problem.
We have a square grid with N rows and M columns. Takahashi will write an integer in each of the squares, as follows:
* First, write 0 in every square.
* For each i=1,2,...,N, choose an integer k_i (0\leq k_i\leq M), and add 1 to each of the leftmost k_i squares in the i-th row.
* For each j=1,2,...,M, choose an integer l_j (0\leq l_j\leq N), and add 1 to each of the topmost l_j squares in the j-th column.
Now we have a grid where each square contains 0, 1, or 2. Find the number of different grids that can be made this way, modulo 998244353. We consider two grids different when there exists a square with different integers.
Constraints
* 1 \leq N,M \leq 5\times 10^5
* N and M are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of different grids that can be made, modulo 998244353.
Examples
Input
1 2
Output
8
Input
2 3
Output
234
Input
10 7
Output
995651918
Input
314159 265358
Output
70273732
"Correct Solution:
```
N, M = map(int, input().split())
mod = 998244353
if N > M:
N, M = M, N
fact = [0] * (M + 1)
powm = [0] * (M + 1)
pown = [0] * (M + 1)
fact[0] = 1
powm[0] = 1
pown[0] = 1
for i in range(1, M + 1):
fact[i] = fact[i - 1] * i % mod
powm[i] = powm[i - 1] * (M + 1) % mod
pown[i] = pown[i - 1] * (N + 1) % mod
def pow(n, m):
if m == 0:
return 1
elif m == 1:
return n
elif m % 2 == 0:
return pow(n, m // 2)**2 % mod
else:
return pow(n, m // 2)**2 % mod * n % mod
inv_fact = [0] * (M + 1)
inv_fact[M] = pow(fact[M], mod-2)
for i in reversed(range(0, M)):
inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod
def C(n, r):
return fact[n] * inv_fact[r] % mod * inv_fact[n - r] % mod
ans = 0
for i in range(N+1):
ans += (-1)**i * C(N, i) * C(M, i) * fact[i] * powm[N - i] * pown[M - i]
ans = ans % mod
print(ans)
```
| 12,331 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a square grid with N rows and M columns. Takahashi will write an integer in each of the squares, as follows:
* First, write 0 in every square.
* For each i=1,2,...,N, choose an integer k_i (0\leq k_i\leq M), and add 1 to each of the leftmost k_i squares in the i-th row.
* For each j=1,2,...,M, choose an integer l_j (0\leq l_j\leq N), and add 1 to each of the topmost l_j squares in the j-th column.
Now we have a grid where each square contains 0, 1, or 2. Find the number of different grids that can be made this way, modulo 998244353. We consider two grids different when there exists a square with different integers.
Constraints
* 1 \leq N,M \leq 5\times 10^5
* N and M are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number of different grids that can be made, modulo 998244353.
Examples
Input
1 2
Output
8
Input
2 3
Output
234
Input
10 7
Output
995651918
Input
314159 265358
Output
70273732
Submitted Solution:
```
def p(i):
ans = 1
while i != 1:
ans *= i
i -= 1
return ans
def comb_dp_sub(n, r):
global comb_table
if r == 0 or n == r:
return 1
else:
return comb_table[n - 1][r] + comb_table[n - 1][r - 1]
def comb_dp(n, r):
global comb_table
comb_table = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n + 1):
for j in range(i + 1):
comb_table[i][j] = comb_dp_sub(i, j)
return comb_table[n][r]
n,m = map(int, input().split())
st = ((n+1)**m) * ((m+1)**n)
general = 0
for i in range(1,min(n,m)+1):
general += comb_dp(n,i) * comb_dp(m,i) * p(i)
print(st - general)
```
No
| 12,332 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
h,w = map(int,input().split())
lst = [list(map(int,input().split())) for _ in range(h)]
cnt = 0
ans = []
for i in range(h):
for j in range(w-1):
if lst[i][j] %2 == 1:
lst[i][j] -= 1
lst[i][j+1] += 1
ans.append([i+1,j+1,i+1,j+2])
for i in range(h-1):
if lst[i][-1] %2 == 1:
lst[i][-1] -= 1
lst[i+1][-1] += 1
ans.append([i+1,w,i+2,w])
print(len(ans))
for a in ans:
print(*a)
```
| 12,333 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
h, w = map(int, input().split())
A = [[int(i) for i in input().split()] for i in range(h)]
B = []
count = 0
for i in range(h):
for j in range(w-1):
if A[i][j] % 2 == 1:
count += 1
A[i][j+1] += 1
B.append([i+1, j+1, i+1, j+2])
for i in range(h-1):
if A[i][-1] % 2 == 1:
count += 1
A[i+1][-1] += 1
B.append([i+1, w, i+2, w])
print(count)
for b in B:
print(b[0], b[1], b[2], b[3])
```
| 12,334 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
def f(i,w):
p = i%w
q = i//w
if q%2 == 1:
p = w-1-p
return [q,p]
h,w = map(int,input().split())
a = [[]]*h
for i in range(h):
a[i] = list(map(int,input().split()))
k = 0
s = []
for i in range(h*w-1):
if a[f(i,w)[0]][f(i,w)[1]]%2 == 1:
k = 1-k
if k == 1:
s += [f(i,w)[0],f(i,w)[1],f(i+1,w)[0],f(i+1,w)[1]]
m = len(s)//4
print(m)
for i in range(m):
print(s[4*i]+1,s[4*i+1]+1,s[4*i+2]+1,s[4*i+3]+1)
```
| 12,335 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
H,W = (int(i) for i in input().split())
a = [[int(i) for i in input().split()] for i in range(H)]
ans = []
ans_list = []
for h in range(H):
for w in range(W):
if w!=W-1:
if a[h][w]%2==1:
a[h][w+1]+=1
ans.append([h+1,w+1,h+1,w+2])
else:
if a[h][w]%2==1 and h!=H-1:
a[h+1][w]+=1
ans.append([h+1,w+1,h+2,w+1])
print(len(ans))
for i in range(len(ans)):
print(*ans[i])
```
| 12,336 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
H,W=[int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(H)]
res = []
for h in range(H):
for w in range(W-1):
if a[h][w] % 2 is not 0:
res += ["{0} {1} {2} {3}".format(h+1,w+1,h+1,w+2)]
a[h][w+1] += 1
for h in range(H-1):
w = W - 1
if a[h][w] % 2 is not 0:
res += ["{0} {1} {2} {3}".format(h+1,w+1,h+2,w+1)]
a[h+1][w]+=1
print(len(res))
for t in res:
print(t)
```
| 12,337 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
H,W=map(int,input().split())
a=[list(map(int,input().split())) for i in range(H)]
A=[]
for y in range(H):
for x in range(W):
if y%2==0:
A.append([y,x,a[y][x]])
else:
A.append([y,W-1-x,a[y][W-1-x]])
OUTPUT=[]
for i in range(H*W-1):
if A[i][2]%2==1:
OUTPUT.append((A[i][0]+1,A[i][1]+1,A[i+1][0]+1,A[i+1][1]+1))
A[i+1][2]+=1
print(len(OUTPUT))
for out in OUTPUT:
print(*out)
```
| 12,338 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
ans = []
for i in range(h):
for j in range(w):
if i==h-1 and j==w-1:
pass
elif j==w-1 and a[i][j]%2==1:
a[i+1][j] += 1
ans.append((i+1, j+1, i+2, j+1))
elif a[i][j]%2==1:
a[i][j+1] += 1
ans.append((i+1, j+1, i+1, j+2))
print(len(ans))
for e in ans:
print(*e)
```
| 12,339 |
Provide a correct Python 3 solution for this coding contest problem.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
"Correct Solution:
```
H, W = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(H)]
cnt = 0
path = []
for h in range(H):
for w in range(W-1):
if A[h][w]%2:
A[h][w+1] += 1
cnt += 1
path.append((h+1, w+1, h+1, w+2))
for h in range(H-1):
if A[h][-1]%2:
A[h+1][-1] += 1
cnt += 1
path.append((h+1, W, h+2, W))
print(cnt)
for p in path:
print(*p)
```
| 12,340 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
h,w=map(int,input().split())
a=[]
for _ in range(h):
a.append(list(map(int, input().split())))
ans=[]
cnt=0
for i in range(h):
for j in range(w-1):
if a[i][j]%2==1:
a[i][j+1]+=1
a[i][j]-=1
cnt+=1
ans.append((i+1,j+1,i+1,j+2))
for i in range(h-1):
if a[i][w-1]%2==1:
a[i][w-1]-=1
a[i+1][w-1]+=1
cnt+=1
ans.append((i+1,w,i+2,w))
print(cnt)
for i,j,k,l in ans:
print(i,j,k,l)
```
Yes
| 12,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
H,W = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(H)]
#print(A)
ans = []
for i in range(H):
for j in range(W-1):
if A[i][j] % 2 == 1:
A[i][j] -= 1
A[i][j+1] += 1
ans.append([i+1,j+1,i+1,j+2])
for i in range(H-1):
if A[i][W-1] % 2 == 1:
A[i][W-1] -= 1
A[i+1][W-1] += 1
ans.append([i+1,W,i+2,W])
print(len(ans))
for a in ans:
print(*a)
```
Yes
| 12,342 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
H,W=[int(s) for s in input().split()]
ls=[[int(s) for s in input().split()] for i in range(H)]
ans=[]
#まず各列ごとに右に寄せる
for i in range(H):
for j in range(W-1):
if ls[i][j]%2==1:
ans.append([i+1,j+1,i+1,j+2])
ls[i][j+1]+=1
#一番右の列を下に寄せる
for i in range(H-1):
if ls[i][W-1]%2==1:
ans.append([i+1, W, i+2, W])
ls[i+1][W-1]+=1
print(len(ans))
for e in ans:
print(*e)
```
Yes
| 12,343 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
def solve():
t,*a=open(0)
h,w=map(int,t.split())
a=[[int(x)%2 for x in y.split()] for y in a]
ret=[]
for i in range(h):
for j in range(w-1):
if a[i][j]:
a[i][j+1]^=1
ret+=[" ".join(map(str,[i+1,j+1,i+1,j+2]))]
for i in range(h-1):
if a[i][-1]:
a[i+1][-1]^=1
ret+=[" ".join(map(str,[i+1,w,i+2,w]))]
print(len(ret),*ret,sep="\n")
if __name__=="__main__":
solve()
```
Yes
| 12,344 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
def solve(string):
ins = string.split("\n")
h, w = map(int, ins[0].split(" "))
a = [list(map(lambda x: int(x) % 2, _i.split(" "))) for _i in ins[1:]]
move = []
for j in range(h):
for i in range(w):
a[j][i] -= 1
if i < w - 1:
a[j][i + 1] += 1
move.append("{} {} {} {}".format(j + 1, i + 1, j + 1, i + 2))
elif j < h - 1:
a[j + 1][i] += 1
move.append("{} {} {} {}".format(j + 1, i + 1, j + 2, i + 1))
return "{}\n{}".format(len(move), "\n".join(move))
if __name__ == '__main__':
line = input()
tmp = [line]
for _ in range(int(line[0])):
tmp.append(input())
print(solve('\n'.join(tmp)))
```
No
| 12,345 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
h, w = map(int, input().split())
a = [list(map(int, input().split())) for i in range(h)]
c = []
hold = False
for y in range(h):
for x in list(range(w))[::-1+(y % 2 == 0)*2]:
# print((y + 1, x + 1))
if hold:
c.append((*back, y + 1, x + 1))
if a[y][x] % 2 == 1:
hold = False
continue
if not hold and a[y][x] % 2 == 1:
hold = True
back = (y + 1, x + 1)
print(len(c))
for i in range(len(c)):
print(*c[i])
```
No
| 12,346 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
import sys, os
f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
sys.stdin = open('./input.txt', 'r')
def solve():
h,w = f()
g = [ f() for i in range(h)]
cnt = 0
ans = []
for i in range(h):
for j in range(w):
if g[i][j]%2 == 0:
continue
else:
if (j+1<w and g[i][j+1]%2 == 1) or i+1 == h:
g[i][j+1] += 1
cnt+=1
ans += [(i+1, j+1, i+1, j+1+1)]
elif i+1<h:
g[i+1][j] += 1
cnt+=1
ans += [(i+1, j+1, i+2, j+1)]
print(cnt)
for i in ans:
print(i[0], i[1], i[2], i[3])
solve()
```
No
| 12,347 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a grid of square cells with H horizontal rows and W vertical columns. The cell at the i-th row and the j-th column will be denoted as Cell (i, j).
In Cell (i, j), a_{ij} coins are placed.
You can perform the following operation any number of times:
Operation: Choose a cell that was not chosen before and contains one or more coins, then move one of those coins to a vertically or horizontally adjacent cell.
Maximize the number of cells containing an even number of coins.
Constraints
* All values in input are integers.
* 1 \leq H, W \leq 500
* 0 \leq a_{ij} \leq 9
Input
Input is given from Standard Input in the following format:
H W
a_{11} a_{12} ... a_{1W}
a_{21} a_{22} ... a_{2W}
:
a_{H1} a_{H2} ... a_{HW}
Output
Print a sequence of operations that maximizes the number of cells containing an even number of coins, in the following format:
N
y_1 x_1 y_1' x_1'
y_2 x_2 y_2' x_2'
:
y_N x_N y_N' x_N'
That is, in the first line, print an integer N between 0 and H \times W (inclusive), representing the number of operations.
In the (i+1)-th line (1 \leq i \leq N), print four integers y_i, x_i, y_i' and x_i' (1 \leq y_i, y_i' \leq H and 1 \leq x_i, x_i' \leq W), representing the i-th operation. These four integers represents the operation of moving one of the coins placed in Cell (y_i, x_i) to a vertically or horizontally adjacent cell, (y_i', x_i').
Note that if the specified operation violates the specification in the problem statement or the output format is invalid, it will result in Wrong Answer.
Examples
Input
2 3
1 2 3
0 1 1
Output
3
2 2 2 3
1 1 1 2
1 3 1 2
Input
3 2
1 0
2 1
1 0
Output
3
1 1 1 2
1 2 2 2
3 1 3 2
Input
1 5
9 9 9 9 9
Output
2
1 1 1 2
1 3 1 4
Submitted Solution:
```
H,W=map(int,input().split())
a=[]
place=[]
doubleN=0
for i in range(H):
a.append(list(map(int,input().split())))
for j in range(W):
if a[i][j]%2==1:
doubleN+=1
place.append([i+1,j+1])
count=0
answer=0
anslist=[]
while(count!=(doubleN//2)):
if place[2*count][0]==place[2*count+1][0] and place[2*count][1]==place[2*count+1][1]:
count+=1
continue;
answer+=1
if place[2*count][0]==place[2*count+1][0]:
if place[2*count][1]<place[2*count+1][1]:
anslist.append([place[2*count][0],place[2*count][1],place[2*count][0],place[2*count][1]+1])
place[2*count][1]+=1
continue;
else:
anslist.append([place[2*count][0],place[2*count][1],place[2*count][0],place[2*count][1]-1])
place[2*count][1]-=1
continue;
else:
anslist.append([place[2*count][0],place[2*count][1],place[2*count][0]+1,place[2*count][1]])
place[2*count][0]+=1
continue;
print(answer)
for i in range(len(anslist)):
print(anslist[i][0],anslist[i][1],anslist[i][2],anslist[i][3])
```
No
| 12,348 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
N, A, B = map(int, input().split())
if N < A + B - 1 :
print(-1)
else :
if A > B :
mode = 0
A -= 1
else :
mode = 1
B -= 1
ret = []
u = N - A + 1
l = B
while len(ret) < N :
if (mode and A == 0) or (not mode and B == 0) :
ret = [-1]
break
if mode :
for i in range(max(u, l - B + 1), u + A) :
ret.append(i)
A -= 1
u -= A
mode ^= 1
else :
for i in range(min(l, u + A - 1), l - B, -1) :
ret.append(i)
B -= 1
l += B
mode ^= 1
print(*ret)
```
| 12,349 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
import sys
input = sys.stdin.readline
"""
n-増大列、m-減少列まで -> 長さ nm 以下であることを示す。帰納法。
(n+1)m + 1 項があるとする。(n+2増大 or m+1減少)の存在をいう。
A：左 nm 項 B：右 m+1 項
Aに1項加えると、(n+1,m+1)のどちらかができる。(n+1)-増大ができるとしてよい。
Bの各項 b に対して、bで終わる(n+1)-増大列が存在する。
Bの中に2-増大列があれば(n+2)増大列ができる。そうでなければBが(m+1)-減少列なのでよい
"""
N,A,B = map(int,input().split())
if A+B-1 > N:
print(-1)
exit()
if A*B < N:
print(-1)
exit()
# 減少列をA個並べる
if B == 1:
size = [1] * A
else:
q,r = divmod(N-A,B-1)
if q < A:
size = [B] * q + [1+r] + [1] * (A-q-1)
else:
size = [B] * A
answer = []
start = 1
for s in size:
end = start + s
answer += list(range(end-1, start-1, -1))
start = end
print(*answer)
```
| 12,350 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
N, A, B = map(int, input().split())
if A * B < N:
print(-1)
elif A + B - 1 > N:
print(-1)
else:
P = [0] * N
b = (N - A) // (B - 1) if B > 1 else 0
r = (N - A) % (B - 1) + 1 if B > 1 else 1
i = 1
pos = 0
while i <= N:
if b:
for j in range(B):
P[pos + B - j - 1] = i
i += 1
pos += B
b -= 1
elif r:
for j in range(r):
P[pos + r - j - 1] = i
i += 1
pos += r
r = 0
else:
P[pos] = i
i += 1
pos += 1
for p in P:
print(p, end=' ')
```
| 12,351 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
N, A, B = map(int, input().split())
ans = list(range(A))
m = 0
rest = N - A
B -= 1
if rest < B:
print(-1)
exit()
if rest / A > B:
print(-1)
exit()
while rest > B:
s = min(A, rest - B + 1)
ans += list(range(m - s, m))
m -= s
rest -= s
B -= 1
ans += list(range(m - B, m))[::-1]
m -= B
print(" ".join([str(x - m + 1) for x in ans]))
```
| 12,352 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, A, B = mapint()
from collections import deque
if A+B-1>N or N>A*B:
print(-1)
else:
blocks = []
blocks.append(' '.join(map(str, range(B, 0, -1))))
now = B+1
rest = N-A+2
while now:
if now==rest:
break
if now+B>rest:
blocks.append(' '.join(map(str, range(rest, now-1, -1))))
rest += 1
break
blocks.append(' '.join(map(str, range(now+B-1, now-1, -1))))
now = now+B
rest += 1
blocks.append(' '.join(map(str, range(rest, N+1))))
print(' '.join(blocks))
```
| 12,353 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
n,a,b=map(int,input().split())
if a+b-1>n:exit(print(-1))
if a*b<n:exit(print(-1))
ans=[]
c=0
nn=n
for i in range(a):
ans.append([])
t=0--nn//(a-i)
if i==0:
t=b
nn-=min(t,b)
for j in range(min(b,t)):
ans[-1].append((i+1)*b-j)
c+=1
if c==n:break
if c==n:break
anss=[]
for i in ans:anss+=i
def position_zip(a,flag):
j=1
d={}
for i in sorted(a):
if i in d:continue
d[i]=j
j+=1
if flag==1:return d
return [d[i] for i in a]
print(*position_zip(anss,0))
```
| 12,354 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
r,p=range,print
n,a,b=map(int,input().split())
if a+b>n+1or a*b<n:exit(p(-1))
l=[[]for i in r(b-1)]+[list(r(1,a+1))]
for i in r(a,n):l[-2-(i-a)%(b-1)]+=[i+1]
for i in l:p(*i,end=" ")
```
| 12,355 |
Provide a correct Python 3 solution for this coding contest problem.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
"Correct Solution:
```
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
import sys
def main(N, A, B):
if A + B - 1 > N or A * B < N:
print(-1)
return
P = []
r = A * B - N
for b in range(B):
for a in range(A):
if b >= 1 and a >= 1 and r > 0:
if r >= A - 1:
r -= A - 1
break
r -= 1
continue
P.append((B - b) * A + a + 1)
s = sorted([(p, i) for i, p in enumerate(P)], key=lambda x: x[0])
s = sorted([(i, j) for j, (p, i) in enumerate(s)], key=lambda x: x[0])
s = [j + 1 for i, j in s]
print(*s)
if __name__ == '__main__':
input = sys.stdin.readline
N, A, B = map(int, input().split())
main(N, A, B)
```
| 12,356 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
r,p=range,print
n,a,b=map(int,input().split())
if a+b>n+1or a*b<n:exit(p(-1))
l=[[]for i in r(b-1)]+[list(r(1,a+1))]
for i in r(a+1,n+1):l[-2-(i-a-1)%(b-1)].append(i)
for i in l:p(*i,end=" ")
```
Yes
| 12,357 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
N, A, B = map(int, input().split())
if A*B < N or A+B-1 > N:
print(-1)
else:
array = [i for i in reversed(range(1, N+1))]
if A > 1:
f = array[:B]
r = array[B:]
L = [f]
span = len(r)//(A-1)
rem = len(r)%(A-1)
i = 0
for _ in range(A-1):
if rem > 0:
L.append(r[i:i+span+1])
rem -= 1
i += span + 1
else:
L.append(r[i:i+span])
i += span
array = []
for l in reversed(L):
array += l
print(' '.join([str(a) for a in array]))
```
Yes
| 12,358 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
import sys
N,A,B = map(int,input().split())
if A+B-1 > N or A*B < N:
print (-1)
sys.exit()
ans = []
for i in range(N-A+1,N+1,1):
ans.append(i)
now = []
for i in range(1,N-A+1,1):
now.append(i)
if len(now) == B-1:
now.reverse()
for j in now:
ans.append(j)
now = []
now.reverse()
for j in now:
ans.append(j)
print (" ".join(map(str,ans)))
```
Yes
| 12,359 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
N,A,B = map(int,input().split())
if A+B-1>N or N>A*B:
print(-1)
else:
G = {i:[] for i in range(1,A+1)}
i = A
cnt = 0
cur = N
while cur>A:
G[i].append(cur)
cnt += 1
cur -= 1
if cnt==B-1:
cnt = 0
i -= 1
C = []
for i in range(1,A+1):
C += G[i]
C.append(i)
print(*C)
```
Yes
| 12,360 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
#!/usr/bin/env python
import numpy as np
def compress(array_like, num):
tmp = sorted(array_like)
m = {}
for i, v in enumerate(tmp):
if i == num:
break
m[v] = i + 1
ret = []
for a in array_like:
if a in m:
ret.append(m[a])
return ret
def main():
N, A, B = map(int, input().split())
# N, A, B = 300000, 1000, 1000
# N, A, B = 10, 4, 5
if A + B - 1 > N:
return -1
if A * B < N:
return -1
ans = np.arange(
1, A * B + 1, dtype="int32").reshape(A, B).T[::-1, :].reshape(A * B)
ans = list(ans)
j = 0
i = 0
for _ in range(A * B - N):
ans[j * A + i] = 1000000
i += 1
if i == A - j - 1:
i += 1
if i >= A:
i = 0
j += 1
if i == A - j - 1:
i += 1
# print(ans)
# ans = np.array(ans).reshape(A * B)
# ans = ans[ans != -1]
# return
return ' '.join(map(str, compress(ans, N)))
if __name__ == '__main__':
print(main())
```
No
| 12,361 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, A, B = MAP()
remain = N - A
if remain < B - 1:
print(-1)
exit()
d = ceil(remain, B-1) if B > 1 else 0
li = [[] for i in range(B)]
li[0] = list(range(1, A+1))
j = A + 1
for i in range(1, B):
tmp = []
for _ in range(d):
tmp.append(j)
j += 1
if j > N:
break
li[i] = tmp
li = li[::-1]
ans = []
for grp in li:
ans += grp
print(*ans)
```
No
| 12,362 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
n,a,b = map(int,input().split())
if not (a+b-1 <= n <= a*b):
print(-1)
exit()
k = a*b - n
ans = [x + (b-1)*10**6 for x in range(a)]
for i in range(b-2,-1,-1):
t = min(a-1,k)
ans += [x+i*10**6 for x in range(a)][:-t]
k -= t
dic = {x:str(i+1) for i,x in enumerate(sorted(ans))}
print(" ".join(list(map(lambda x:dic[x],ans))))
```
No
| 12,363 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Determine if there exists a sequence obtained by permuting 1,2,...,N that satisfies the following conditions:
* The length of its longest increasing subsequence is A.
* The length of its longest decreasing subsequence is B.
If it exists, construct one such sequence.
Constraints
* 1 \leq N,A,B \leq 3\times 10^5
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B
Output
If there are no sequences that satisfy the conditions, print `-1`.
Otherwise, print N integers. The i-th integer should be the i-th element of the sequence that you constructed.
Examples
Input
5 3 2
Output
2 4 1 5 3
Input
7 7 1
Output
1 2 3 4 5 6 7
Input
300000 300000 300000
Output
-1
Submitted Solution:
```
#!/usr/bin/env python
import numpy as np
def compress(array_like):
tmp = sorted(array_like)
m = {}
for i, v in enumerate(tmp):
m[v] = i + 1
ret = []
for a in array_like:
ret.append(m[a])
return ret
def main():
N, A, B = map(int, input().split())
# # N, A, B = 300000, 4, 100000
# N, A, B = 10, 4, 5
if A + B - 1 > N:
return -1
if A * B < N:
return -1
ans = np.arange(1, A * B + 1, dtype="int32").reshape(A, B).T[::-1, :]
j = 0
i = 0
for _ in range(A * B - N):
ans[j, i] = -1
i += 1
if i == A - j - 1:
i += 1
if i >= A:
i = 0
j += 1
if i == A - j - 1:
i += 1
# print(ans)
ans = ans.reshape(A * B)
ans = ans[ans != -1]
# return
return ' '.join(map(str, compress(list(ans))))
if __name__ == '__main__':
print(main())
```
No
| 12,364 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
from collections import deque
import sys
sys.setrecursionlimit(10 ** 7)
n, m = map(int, input().split())
edges = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
edges[a-1].append(b-1)
edges[b-1].append(a-1)
colors = [0] * n
def dfs(v, color):
colors[v] = color
for to in edges[v]:
if colors[to] == color:
return False
if colors[to] == 0 and (not dfs(to, -color)):
return False
return True
if dfs(0, 1):
x = colors.count(1)
print(x * (n - x) - m)
else:
print(n * (n - 1) // 2 - m)
```
| 12,365 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
import sys
sys.setrecursionlimit(100000)
from collections import defaultdict
G = defaultdict(list)
N, M = map(int, input().split())
visited = [[False for i in range(N)] for j in range(5)]
for i in range(M):
v,u = map(int, input().split())
G[v-1].append(u-1)
G[u-1].append(v-1)
# 頂点間に奇数長のパスがあるかどうか確認するために 2部グラフ 判定をする
COLOR = [0 for i in range(N)]
def dfs(pos, color):
global COLOR
COLOR[pos] = color
ans = True
for to in G[pos]:
if COLOR[to] == color:
return False
elif COLOR[to] == 0:
ans &= dfs(to, -color)
return ans
if dfs(0, 1):
count = 0
for i in COLOR:
if i == -1:
count += 1
another = N-count
print(count*another-M)
else:
# 2 部グラフではなかったので、完全グラフから M を引いた値を出力する
print(N*(N-1)//2-M)
```
| 12,366 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
from collections import deque
n,m=map(int,input().split())
e=[[] for _ in range(n+1)]
d=[-1]*(n+1)
for i in range(m):
a,b=map(int,input().split())
e[a]+=[b]
e[b]+=[a]
q=deque([(1,0)])
d[1]=0
a,b=0,0
while q:
now,par=q.popleft()
for to in e[now]:
if to==par:continue
if d[to]==-1:
d[to]=(d[now]+1)%2
a+=1
q.append((to,now))
elif d[to]!=d[now]%2:b+=1
else:
print(n*(n-1)//2-m)
exit()
p=sum(d)+1
print(p*(n-p)-a-b//2)
```
| 12,367 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
def bipartite():
color = {v: None for v in V}
stack = [(V[0], 0)]
parts = {0: [], 1:[]}
while stack:
v, c = stack.pop()
if color[v] is not None: # consistent
continue
color[v] = c
parts[c].append(v)
for u in E[v]:
if color[u] is None: # not visited yet
stack.append((u, c^1)) # paint u with different color from v's one
elif color[u] != c: # consistent
continue
else: # inconsistent
return (None, None)
return (parts[0], parts[1])
N, M = map(int, input().split())
V = range(1, N+1)
E = {v: [] for v in V}
for _ in range(M):
a, b = map(int, input().split())
E[a].append(b)
E[b].append(a)
p1, p2 = bipartite()
if p1 is None:
print(N * (N-1) // 2 - M)
else:
print(len(p1) * len(p2) - M)
```
| 12,368 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
N, M = map(int, input().split())
v = [set() for _ in range(N)]
for _ in range(M) :
A, B = map(int, input().split())
v[A-1].add(B-1)
v[B-1].add(A-1)
visited = [[False] * N for _ in range(2)]
visited[0][0] = True
q = [(0, 0)]
while q :
parity, cur = q.pop()
parity ^= 1
for nex in v[cur] :
if visited[parity][nex] :
continue
visited[parity][nex] = True
q.append((parity, nex))
o, e = 0, 0
for i in range(N) :
if visited[0][i] and not visited[1][i] :
e += 1
elif not visited[0][i] and visited[1][i] :
o += 1
print((N * (N - 1) - o * (o - 1) - e * (e - 1)) // 2 - M)
```
| 12,369 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
import sys
sys.setrecursionlimit(pow(10, 7))
n, m = map(int, input().split())
G = [[] for _ in range(n)]
color = [-1]*n
for i in range(m):
a, b = map(int, input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
def dfs(v, c):
color[v] = c
ans = True
for u in G[v]:
if color[u] == c:
return False
if color[u] != -1:
continue
ans &= dfs(u, 1-c)
return ans
if dfs(v=0, c=0):
k = sum(color)
print(k*(n-k) - m)
else:
print(n*(n-1)//2 - m)
```
| 12,370 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
n,m,*t=map(int,open(0).read().split())
e=[[]for _ in'_'*n]
for a,b in zip(*[iter(t)]*2):
e[a-1]+=b-1,
e[b-1]+=a-1,
s=[0]
f=s+[-1]*~-n
while s:
v=s.pop()
p=f[v]^1
for w in e[v]:
if-1<f[w]:
if f[w]!=p:
print(n*~-n//2-m)
exit()
else:
f[w]=p
s+=w,
r=sum(f)
print(r*(n-r)-m)
```
| 12,371 |
Provide a correct Python 3 solution for this coding contest problem.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**6)
n,m=map(int,input().split())
s=[[]for i in range(n+1)]
c=[0]*(n+1)
for i in range(m):
a,b=map(int,input().split())
s[a].append(b)
s[b].append(a)
def dfs(v,t):
c[v]=t
# print('start :'+str(c))
for i in s[v]:
if c[i]==t:
return False
if c[i]==0 and not dfs(i,-t):
return False
else:
return True
if dfs(1,1):
q=c.count(1)
print((n-q)*q-m)
else:
print((n*(n-1)//2)-m)
```
| 12,372 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
N, M = map(int, input().split())
A, B = (
zip(*(map(int, input().split()) for _ in range(M))) if M else
((), ())
)
# グラフが二部グラフならば二集合間に辺を張れる
# そうでなければ完全グラフになるように辺を張れる
G = [set() for _ in range(N + 1)]
for x, y in zip(A, B):
G[x].add(y)
G[y].add(x)
dp = [0 for _ in range(N + 1)]
q = []
q.append(1)
dp[1] = 1
is_bi = True
while q:
i = q.pop()
for j in G[i]:
if dp[j] == 0:
dp[j] = -dp[i]
q.append(j)
else:
is_bi &= dp[j] == -dp[i]
ans = (
sum(x == 1 for x in dp) * sum(x == -1 for x in dp) - M if is_bi else
N * (N - 1) // 2 - M
)
print(ans)
```
Yes
| 12,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,m = map(int, input().split())
ns = [[] for _ in range(n)]
for i in range(m):
a,b = map(int, input().split())
a -= 1
b -= 1
ns[a].append(b)
ns[b].append(a)
def is_bip(ns):
start = 0
q = [start]
cs = [None]*n
cs[start] = 1
while q:
u = q.pop()
c = cs[u]
cc = int(not c)
for v in ns[u]:
if cs[v] is None:
cs[v] = cc
q.append(v)
elif cs[v]==c:
return False, None
return True, cs
res, cs = is_bip(ns)
if res:
n1 = sum(cs)
n2 = n - n1
ans = n1*n2 - m
else:
ans = n*(n-1)//2 - m
print(ans)
```
Yes
| 12,374 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**7)
N,M=map(int,input().split())
E=[[]for _ in'_'*-~N]
for _ in'_'*M:
a,b=map(int,input().split())
E[a]+=[b]
E[b]+=[a]
V=[0]*-~N
def f(i,x):
if V[i]:
return V[i]==x
V[i]=x
r=1
for j in E[i]:
r*=f(j,-x)
return r
if f(1,1):
print(V.count(1)*V.count(-1)-M)
else:
print(N*~-N//2-M)
```
Yes
| 12,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
# 解説AC
# 二部グラフでないグラフの性質や，パスの長さを考察する
def main():
N, M = (int(i) for i in input().split())
G = [[] for _ in range(N)]
for _ in range(M):
a, b = (int(i) for i in input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
def dfs(s):
"""
二部グラフか判定
"""
stack = [s]
color = [-1]*N
color[s] = 0
while stack:
v = stack.pop()
for u in G[v]:
if color[u] != -1:
if color[u] == color[v]:
# 二部グラフでない
return False, color
continue
color[u] = color[v] ^ 1
stack.append(u)
return True, color
is_bipartite, color = dfs(0)
if is_bipartite:
# 二部グラフである
b = sum(color)
w = N - b
print(b*w - M)
else:
# 二部グラフでない
# 完全グラフになるので，{}_N C_2 - (既に張られている辺の数)
print(N*(N-1)//2 - M)
if __name__ == '__main__':
main()
```
Yes
| 12,376 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
from collections import deque
n, m = map(int, input().split())
if n==2 or n==3:
print(0)
exit()
connect = [[] for _ in range(n)]
for _ in range(m):
a, b = map(lambda x: int(x)-1, input().split())
connect[a].append(b)
connect[b].append(a)
#print(connect)
color= [-1]*n
color[0]=0
explored= {0}
next = deque(connect[0])
exploring =deque()
Yes = True
explored.add(0)
while next:
now = next.popleft()
exploring.extend(connect[now])
while exploring:
a=exploring.popleft()
if color[a]==-1 or color[a]==(color[now]+1)%2:
color[a]=(color[now]+1)%2
else:
Yes = False
if a not in explored:
next.append(a)
explored.add(a)
Yes = False
if Yes:
s=sum(color)
print(s*(n-s)-m)
else:
print(int(n*(n-1)/2-m))
```
No
| 12,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
import sys
sys.setrecursionlimit(200000)
N,M = map(int,input().split())
edges = [[]for _ in range(N+1)]
for _ in range(M):
u,v = map(int,input().split())
edges[u].append(v)
edges[v].append(u)
colors = [-1]*(N+1)
def choose(n,k):
import math
return math.factorial(n)//(math.factorial(n-k)*math.factorial(k))
def dfs(n,c):
if colors[n] == -1:
colors[n] = c
for nx in edges[n]:
dfs(nx,(c+1)%2)
else:
if colors[n] != c:
print(choose(N,2)-M)
exit()
dfs(1,0)
white = colors.count(0)
black = N - white
print(white*black-M)
```
No
| 12,378 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
def is_bipartite(G):
n = len(G)
color = [-1]*n
que = deque([0])
color[0] = 0
while que:
v = que.pop()
c = color[v]
for nv in G[v]:
if color[nv]<0:
color[nv] = 1-c
que.append(nv)
elif color[nv] == c:
return False
return color
color = is_bipartite(G)
if color:
a = color.count(0)
b = N-a
print(a*b-M)
else:
print(N*(N-1)//2-M)
```
No
| 12,379 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Rng has a connected undirected graph with N vertices. Currently, there are M edges in the graph, and the i-th edge connects Vertices A_i and B_i.
Rng will add new edges to the graph by repeating the following operation:
* Operation: Choose u and v (u \neq v) such that Vertex v can be reached by traversing exactly three edges from Vertex u, and add an edge connecting Vertices u and v. It is not allowed to add an edge if there is already an edge connecting Vertices u and v.
Find the maximum possible number of edges that can be added.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq A_i,B_i \leq N
* The graph has no self-loops or multiple edges.
* The graph is connected.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
A_2 B_2
:
A_M B_M
Output
Find the maximum possible number of edges that can be added.
Examples
Input
6 5
1 2
2 3
3 4
4 5
5 6
Output
4
Input
5 5
1 2
2 3
3 1
5 4
5 1
Output
5
Submitted Solution:
```
# coding:utf-8
class Tree(object):
def __init__(self, N):
self.tree = [[] for _ in range(N)]
self.colors = [0 for _ in range(N)]
def add_node(self, a, b):
self.tree[a].append(b)
# 二部グラフか判定する関数
def is_bipartite_graph(self, v, color):
self.colors[v] = color
for to in self.tree[v]:
if self.colors[to] == color:
return False
if self.colors[to] == 0 and not self.is_bipartite_graph(to, -color):
return False
return True
def count_node(self, color):
return self.colors.count(color)
if __name__ == "__main__":
# input data
N, M = map(int, input().split())
tree = Tree(N)
for _ in range(M):
a, b = map(int, input().split())
tree.add_node(a-1, b-1)
tree.add_node(b-1, a-1)
# tree dp
is_bpr = tree.is_bipartite_graph(0, 1)
if is_bpr:
bla = tree.count_node(1)
whi = N - bla
print(bla*whi-M)
else:
print(int(N*(N-1)/2-M))
```
No
| 12,380 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
INF = 10**12
class Rmin():
def __init__(self, size):
#the number of nodes is 2n-1
self.n = 1 << (size.bit_length())
self.node = [INF] * (2*self.n-1)
def Access(self, x):
return self.node[x+self.n-1]
def Update(self, x, val):
x += self.n-1
self.node[x] = val
while x > 0:
x = (x-1)>>1
self.node[x] = min(self.node[(x<<1)+1], self.node[(x<<1)+2])
return
#[l, r)
def Get(self, l, r):
L, R = l+self.n, r+self.n
s = INF
while L<R:
if R & 1:
R -= 1
s = min(s, self.node[R-1])
if L & 1:
s = min(s, self.node[L-1])
L += 1
L >>= 1
R >>= 1
return s
n, q, a, b, *qs = map(int, read().split())
dp_l, dp_r = Rmin(n+1), Rmin(n+1)
dp_l.Update(b, -b)
dp_r.Update(b, b)
total_diff = 0
x = a
for y in qs:
diff = abs(y - x)
l_min = dp_l.Get(1, y)
r_min = dp_r.Get(y, n+1)
res = min(l_min + y, r_min - y)
dp_l.Update(x, res - diff - x)
dp_r.Update(x, res - diff + x)
total_diff += diff
x = y
N = dp_l.n
print(total_diff + min((l+r)>>1 for l, r in zip(dp_l.node[N:], dp_r.node[N:])))
```
| 12,381 |
Provide a correct Python 3 solution for this coding contest problem.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,Q,A,B,*X = map(int,read().split())
class MinSegTree():
def __init__(self,N):
self.Nelem = N
self.size = 1<<(N.bit_length()) # 葉の要素数
def build(self,raw_data):
# raw_data は 0-indexed
INF = 10**18
self.data = [INF] * (2*self.size)
for i,x in enumerate(raw_data):
self.data[self.size+i] = x
for i in range(self.size-1,0,-1):
x = self.data[i+i]; y = self.data[i+i+1]
self.data[i] = x if x<y else y
def update(self,i,x):
i += self.size
self.data[i] = x
i >>= 1
while i:
x = self.data[i+i]; y = self.data[i+i+1]
self.data[i] = x if x<y else y
i >>= 1
def get_value(self,L,R):
# [L,R] に対する値を返す
L += self.size
R += self.size + 1
# [L,R) に変更
x = 10**18
while L < R:
if L&1:
y = self.data[L]
if x > y: x = y
L += 1
if R&1:
R -= 1
y = self.data[R]
if x > y: x = y
L >>= 1; R >>= 1
return x
INF = 10**18
dpL = MinSegTree(N+10); dpL.build([INF] * (N+10))
dpR = MinSegTree(N+10); dpR.build([INF] * (N+10))
dpL.update(A,0-A)
dpR.update(A,0+A)
prev_x = B
add = 0
for x in X:
from_left = dpL.get_value(0,x) + x
from_right = dpR.get_value(x,N+10) - x
dist = x-prev_x if x>prev_x else prev_x-x
y = from_left if from_left < from_right else from_right
y -= dist
dpL.update(prev_x,y-prev_x)
dpR.update(prev_x,y+prev_x)
add += dist
prev_x = x
dp = [(x+y)//2 for x,y in zip(dpL.data[dpL.size:],dpR.data[dpR.size:])]
answer = min(dp) + add
print(answer)
```
| 12,382 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N,Q,A,B,*X = map(int,read().split())
class MinSegTree():
def __init__(self,N):
self.Nelem = N
self.size = 1<<(N.bit_length()) # 葉の要素数
def build(self,raw_data):
# raw_data は 0-indexed
INF = 10**18
self.data = [INF] * (2*self.size)
for i,x in enumerate(raw_data):
self.data[self.size+i] = x
for i in range(self.size-1,0,-1):
x = self.data[i+i]; y = self.data[i+i+1]
self.data[i] = x if x<y else y
def update(self,i,x):
i += self.size
self.data[i] = x
i >>= 1
while i:
x = self.data[i+i]; y = self.data[i+i+1]
self.data[i] = x if x<y else y
i >>= 1
def get_value(self,L,R):
# [L,R] に対する値を返す
L += self.size
R += self.size + 1
# [L,R) に変更
x = 10**18
while L < R:
if L&1:
y = self.data[L]
if x > y: x = y
L += 1
if R&1:
R -= 1
y = self.data[R]
if x > y: x = y
L >>= 1; R >>= 1
return x
INF = 10**18
dpL = MinSegTree(N+10); dpL.build([INF] * (N+10))
dpR = MinSegTree(N+10); dpR.build([INF] * (N+10))
dpL.update(A,0-A)
dpR.update(A,0+A)
prev_x = B
add = 0
for x in X:
from_left = dpL.get_value(0,x) + x
from_right = dpR.get_value(x,N+10) - x
dist = x-prev_x if x>prev_x else prev_x-x
y = from_left if from_left < from_right else from_right
y -= dist
dpL.update(prev_x,y-prev_x)
dpR.update(prev_x,y+prev_x)
add += dist
prev_x = x
dp = [(x+y)//2 for x,y in zip(dpL.data[dpL.size:],dpR.data[dpR.size:])]
answer = min(dp) + add
print(answer)
```
No
| 12,383 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
Submitted Solution:
```
INF = 10**15
class Rmin():
def __init__(self, size):
#the number of nodes is 2n-1
self.n = 1
while self.n < size:
self.n *= 2
self.node = [INF] * (2*self.n-1)
def Access(self, x):
return self.node[x+self.n-1]
def Update(self, x, val):
x += self.n-1
self.node[x] = val
while x > 0:
x = (x-1)//2
self.node[x] = min(self.node[2*x+1], self.node[2*x+2])
return
#[l, r)
def Get(self, l, r):
L, R = l+self.n, r+self.n
s = INF
while L<R:
if R & 1:
R -= 1
s = min(s, self.node[R-1])
if L & 1:
s = min(s, self.node[L-1])
L += 1
L >>= 1
R >>= 1
return s
n, q, a, b = map(int, input().split())
qs = [a] + list(map(int, input().split()))
dp_l, dp_r = Rmin(n+1), Rmin(n+1)
dp_l.Update(b, -b)
dp_r.Update(b, b)
total_diff = 0
for i in range(q):
x, y = qs[i], qs[i+1]
diff = abs(y - x)
l_min = dp_l.Get(1, y)
r_min = dp_r.Get(y, n+1)
res = min(l_min + y, r_min - y)
dp_l.Update(x, res - diff - x)
dp_r.Update(x, res - diff + x)
total_diff += diff
ans_l, ans_r = INF, INF
for i in range(1, n+1):
ans_l = min(ans_l, dp_l.Access(i) + i)
ans_r = min(ans_r, dp_r.Access(i) - i)
print(ans_l + total_diff)
```
No
| 12,384 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
Submitted Solution:
```
#####segfunc#####
def segfunc(x, y):
return (min(x[0],y[0]),min(x[1],y[1]))
#################
#####ide_ele#####
ide_ele = (10**20,10**20)
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, n,segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] =self.segfunc(self.tree[k],x)
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
import random
def main():
N,Q,A,B=map(int,input().split())
x=list(map(int,input().split()))
Sx=[abs(x[0]-A)]
Sy=[abs(x[0]-B)]
for i in range(1,Q):
Sx.append(abs(x[i]-x[i-1]))
Sy.append(abs(x[i]-x[i-1]))
for i in range(1,Q):
Sx[i]+=Sx[i-1]
Sy[i]+=Sy[i-1]
rmqx=SegTree(N+1,segfunc,ide_ele)
rmqy=SegTree(N+1,segfunc,ide_ele)
dpx=Sx[0]
dpy=Sy[0]
test1=Sx[Q-1]
test2=Sy[Q-1]
rmqx.update(A,(-A,A))
rmqy.update(B,(-B,B))
for i in range(2,Q+1):
testx1=rmqx.query(0,x[i-1])[0]+x[i-1]+Sy[i-2]
testx2=rmqx.query(x[i-1],N+1)[1]-x[i-1]+Sy[i-2]
dpx=min(testx2,testx1)
testy1=rmqy.query(0,x[i-1])[0]+x[i-1]+Sx[i-2]
testy2=rmqy.query(x[i-1],N+1)[1]-x[i-1]+Sx[i-2]
dpy=min(testy2,testy1)
rmqx.update(x[i-2],(dpy-Sy[i-1]-x[i-2],dpy-Sy[i-1]+x[i-2]))
rmqy.update(x[i-2],(dpx-Sx[i-1]-x[i-2],dpx-Sx[i-1]+x[i-2]))
test1=min(test1,dpx+Sx[Q-1]-Sx[i-1])
test2=min(test2,dpy+Sy[Q-1]-Sy[i-1])
print(min(test1,test2))
if __name__=="__main__":
main()
```
No
| 12,385 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N squares in a row. The squares are numbered 1, 2, ..., N from left to right.
You have two pieces, initially placed on square A and B, respectively. You will be asked to process Q queries of the following kind, in the order received:
* Given an integer x_i, move one of the two pieces of your choice to square x_i.
Here, it takes you one second to move a piece one square. That is, the time it takes to move a piece from square X to Y is |X-Y| seconds.
Your objective is to process all the queries in the shortest possible time.
You may only move the pieces in response to queries, and you may not move both pieces at the same time. Also, it is not allowed to rearrange the order in which queries are given. It is, however, allowed to have both pieces in the same square at the same time.
Constraints
* 1 ≤ N, Q ≤ 200,000
* 1 ≤ A, B ≤ N
* 1 ≤ x_i ≤ N
Input
Input is given from Standard Input in the following format:
N Q A B
x_1 x_2 ... x_Q
Output
Let the shortest possible time to process all the queries be X seconds. Print X.
Examples
Input
8 3 1 8
3 5 1
Output
7
Input
9 2 1 9
5 1
Output
4
Input
9 2 1 9
5 9
Output
4
Input
11 16 8 1
1 1 5 1 11 4 5 2 5 3 3 3 5 5 6 7
Output
21
Submitted Solution:
```
class MinSegTree:
def __init__(self, initial_data):
initial_data = list(initial_data)
self.original_size = len(initial_data)
self.depth = (len(initial_data)-1).bit_length()
self.size = 1 << self.depth
self.data = [0]*self.size + initial_data + [0]*(self.size - len(initial_data))
self.offset = 0
for d in reversed(range(self.depth)):
a = 1 << d
b = a << 1
for i in range(a,b):
self.data[i] = min(self.data[2*i],self.data[2*i+1])
def _min_interval(self, a, b):
def rec(i, na, nb):
if b <= na or nb <= a:
return float('inf')
if a <= na and nb <= b:
return self.data[i]
split = (na+nb)//2
return min(rec(2*i, na, split), rec(2*i+1, split, nb))
return rec(1, 0, self.size)
def _set_val(self, a, val):
def rec(i, na, nb):
if na == a == nb-1:
self.data[i] = val
elif na <= a < nb:
split = (na+nb)//2
self.data[i] = min(rec(2*i, na, split), rec(2*i+1, split, nb))
return self.data[i]
rec(1, 0, self.size)
def add_to_all(self, val):
self.offset += val
def __getitem__(self, i):
if isinstance(i, slice):
return self.offset + self._min_interval(
0 if i.start is None else i.start,
self.original_size if i.stop is None else i.stop)
elif isinstance(i, int):
return self.data[i+self.size]+self.offset
def __setitem__(self, i, x):
self._set_val(i,x-self.offset)
def __iter__(self):
def gen():
for x in self.data[self.size:]:
yield x
return gen
"""
dp[i][b] = dp[i-1][b] + |x-a| for all b
dp[i][a] = min(dp[i-1][b] + |x-b| for all b)
= min(dp[i-1][j] - j + x for j = [0,x]), min(dp[i-1][j]+j-x for j = (x,n])
dp[i][j] - j と dp[i][j] + jをセグ木でもつ
"""
N,Q,A,B = map(int,input().split())
t1 = MinSegTree([float('inf')]*N)
t2 = MinSegTree([float('inf')]*N)
A,B = A-1,B-1
a = A
t1[B] = -B
t2[B] = B
for x in map(int, input().split()):
x -= 1
d = abs(x-a)
m = min(t1[:x] + x, t2[x:] - x, (t1[a]+t2[a])//2+d)
t1.add_to_all(d)
t2.add_to_all(d)
t1[a] = m - a
t2[a] = m + a
a = x
print(min(t1[i]+t2[i] for i in range(N))//2)
```
No
| 12,386 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1 through N.
The i-th of the N-1 edges connects the vertices p_i and q_i.
Among the sequences of distinct vertices v_1, v_2, ..., v_M that satisfy the following condition, find the maximum value of M.
* For every 1 \leq i < M, the path connecting the vertices v_i and v_{i+1} do not contain any vertex in v, except for v_i and v_{i+1}.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq p_i, q_i \leq N
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
p_1 q_1
p_2 q_2
:
p_{N-1} q_{N-1}
Output
Print the maximum value of M, the number of elements, among the sequences of vertices that satisfy the condition.
Examples
Input
4
1 2
2 3
2 4
Output
3
Input
10
7 9
1 2
6 4
8 1
3 7
6 5
2 10
9 6
2 6
Output
8
"Correct Solution:
```
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
"""
・次数3以上の点は使わないとしてよい
・次数1の点は全て回収できる。次数2の点を、パスとなる形で回収する。
"""
N = int(readline())
PQ = [tuple(int(x)-1 for x in line.split()) for line in readlines()]
graph = [[] for _ in range(N)]
for p,q in PQ:
graph[p].append(q)
graph[q].append(p)
deg = [len(x) for x in graph]
cnt_deg1 = sum(x==1 for x in deg)
deg2_path = 0
def dfs(x,parent):
global deg2_path
# 部分木で完結する場合、しない場合
arr = [dfs(y,x) for y in graph[x] if y != parent]
if len(arr) == 0:
return 0
if len(arr) == 1:
return arr[0] + (deg[x] == 2)
arr.sort()
deg2_path = max(deg2_path, arr[-1] + arr[-2] + (deg[x]==2))
return arr[-1] + (deg[x] == 2)
dfs(0,-1)
answer = cnt_deg1 + deg2_path
print(answer)
```
| 12,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N.
The i-th of the N-1 edges connects the vertices p_i and q_i.
Among the sequences of distinct vertices v_1, v_2, ..., v_M that satisfy the following condition, find the maximum value of M.
* For every 1 \leq i < M, the path connecting the vertices v_i and v_{i+1} do not contain any vertex in v, except for v_i and v_{i+1}.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq p_i, q_i \leq N
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
p_1 q_1
p_2 q_2
:
p_{N-1} q_{N-1}
Output
Print the maximum value of M, the number of elements, among the sequences of vertices that satisfy the condition.
Examples
Input
4
1 2
2 3
2 4
Output
3
Input
10
7 9
1 2
6 4
8 1
3 7
6 5
2 10
9 6
2 6
Output
8
Submitted Solution:
```
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
n = int(input())
edge = [[] for i in range(n)]
for i in range(n-1):
p, q = [int(item) - 1 for item in input().split()]
edge[p].append(q)
edge[q].append(p)
order1 = 0
for e in edge:
if len(e) == 1:
order1 += 1
max_order = 0
def dfs(v, prev):
global max_order
if len(edge[v]) == 1:
return 0
order2 = 0
od = []
for nv in edge[v]:
if nv == prev:
continue
ret = dfs(nv, v)
od.append(ret)
order2 = max(order2, ret)
od.sort(reverse=True)
if len(edge[v]) == 2:
order2 += 1
if len(od) > 1:
max_order = max(max_order, od[0] + od[1] + 1)
elif len(edge[v]) > 2:
max_order = max(max_order, od[0] + od[1])
return order2
ret = dfs(0, -1)
print(order1 + max_order)
```
No
| 12,388 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1 through N.
The i-th of the N-1 edges connects the vertices p_i and q_i.
Among the sequences of distinct vertices v_1, v_2, ..., v_M that satisfy the following condition, find the maximum value of M.
* For every 1 \leq i < M, the path connecting the vertices v_i and v_{i+1} do not contain any vertex in v, except for v_i and v_{i+1}.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq p_i, q_i \leq N
* The given graph is a tree.
Input
The input is given from Standard Input in the following format:
N
p_1 q_1
p_2 q_2
:
p_{N-1} q_{N-1}
Output
Print the maximum value of M, the number of elements, among the sequences of vertices that satisfy the condition.
Examples
Input
4
1 2
2 3
2 4
Output
3
Input
10
7 9
1 2
6 4
8 1
3 7
6 5
2 10
9 6
2 6
Output
8
Submitted Solution:
```
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
n = int(input())
edge = [[] for i in range(n)]
for i in range(n-1):
p, q = [int(item) - 1 for item in input().split()]
edge[p].append(q)
edge[q].append(p)
order1 = 0
for e in edge:
if len(e) == 1:
order1 += 1
def dfs(v, prev):
if len(edge[v]) == 1:
return 0
order2 = 0
for nv in edge[v]:
if nv == prev:
continue
order2 = max(order2, dfs(nv, v))
if len(edge[v]) == 2:
order2 += 1
return order2
ret = dfs(0, -1)
print(order1 + ret)
```
No
| 12,389 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
import sys
import math
r = sys.stdin.readlines()
n = [[float(i) for i in (j.split())] for j in r]
for l in n:
y = (l[2]*l[3]-l[0]*l[5])/(l[1]*l[3]-l[0]*l[4])+0
x = (l[2]*l[4]-l[5]*l[1])/(l[0]*l[4]-l[3]*l[1])+0
print("%.3f %.3f" %(x, y))
```
| 12,390 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
import sys
inputNum = sys.stdin.readlines()
for i in inputNum:
new = []
n = i[:-1].split(' ', 6)
for s in n:
new.append(float(s))
k = new[0]
q = 0
for a in new[0:3]:
new[q] = a/k
q = q + 1
l = new[3]
for a in new[3:6]:
new[q] = a - l*new[q-3]
q = q + 1
if new[4] == 0:
y = new[5]
else:
y = new[5]/new[4]
x = new[2]-(new[1]*y)
print("{0:.3f}".format(x)+" "+"{0:.3f}".format(y))
```
| 12,391 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
# input
inputs = []
while True:
try:
inputs.append(list(map(float,input().split())))
except EOFError:
break
# calculation
for i in inputs:
x=(i[2]*i[4]-i[1]*i[5])/(i[0]*i[4]-i[1]*i[3])
y=(i[0]*i[5]-i[2]*i[3])/(i[0]*i[4]-i[1]*i[3])
if x == -0.000:x=0
if y == -0.000:y=0
print("{0:.3f} {1:.3f}".format(x,y))
```
| 12,392 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
while True:
try:
a, b, c, d, e, f = map(float, input().split())
x = (c*e - b*f)/(a*e - b*d)
y = (f*a - c*d)/(a*e - d*b)
print( "{0:.3f} {1:.3f}".format(x+0, y+0))
except:
break
```
| 12,393 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
import sys
for line in sys.stdin.readlines():
a, b, c, d, e, f=map(float,line.split())
k=(a*e)-(b*d)
xval=(c*e)-(b*f)
yval=(a*f)-(c*d)
g=xval/k
h=yval/k
if(xval==0):
g=0
if(yval==0):
h=0
print("%.3f %.3f"%(g,h))
```
| 12,394 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
while True:
try:
(a, b, e, c, d, f) = map(float, input().split())
D = a * d - b * c
x = (d * e - b * f) / D
y = (a * f - c * e) / D
if abs(x) < 1e-4:
x = 0.0
if abs(y) < 1e-4:
y = 0.0
print("{0:.3f} {1:.3f}".format(x, y))
except EOFError:
break
```
| 12,395 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
while True:
try:
a, b, c, d, e, f = map(int, input(). split())
D = (a * e) - (b * d)
x = (e * c) - (b * f)
y = (a * f) - (d * c)
x /= D
y /= D
if x / D == 0:
x = 0
if y / D == 0:
y = 0
print("%.3f %.3f" % (round(x, 3), round(y, 3)))
except:
break
```
| 12,396 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
"Correct Solution:
```
while True:
try:
a, b, c, d, e, f = [float(x) for x in input().split()]
except:
exit()
m = [[a,b,c],[d,e,f]]
row = len(m)
col = len(m[0])
for k in range(row):
for j in range(k+1,col):
m[k][j] /=m[k][k]
for i in range(row):
if(i != k):
for j in range(k+1,col):
m[i][j] -= m[i][k] * m[k][j]
print ("%.3f %.3f" % (m[0][2],m[1][2]))
```
| 12,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
Submitted Solution:
```
import math
import sys
while True:
try:
a,b,c,d,e,f = map(float, input().split())
if a*e == b*d:
continue
x = (c*e - b*f)/(a*e - b*d)
y = (c*d - a*f)/(b*d - a*e)
if x == 0:
x = 0
if y == 0:
y = 0
print('{0:.3f} {1:.3f}'.format(x,y))
except EOFError:
break
```
Yes
| 12,398 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Write a program which solve a simultaneous equation:
ax + by = c
dx + ey = f
The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.
Input
The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.
Output
For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.
Examples
Input
1 2 3 4 5 6
2 -1 -2 -1 -1 -5
Output
-1.000 2.000
1.000 4.000
Input
2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27
Output
0.000 3.000
0.000 3.000
Submitted Solution:
```
while(True):
try:
a,b,c,d,e,f = map(float, input().split())
y = (a*f-c*d)/(a*e-b*d)
x = (c-b*y)/a
print("%.3f %.3f"%(x,y))
except:
break
```
Yes
| 12,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.