text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Tags: bitmasks, constructive algorithms
Correct Solution:
```
from sys import stdin
BITCOUNT = 10
xONES = (1 << 10) - 1
xZEROS = 0
n = int(stdin.readline())
for i in range(n):
op, num = stdin.readline().split()
num = int(num)
if op == '&':
xONES &= num
xZEROS &= num
elif op == '|':
xONES |= num
xZEROS |= num
else:
xONES ^= num
xZEROS ^= num
andmask = 0
xormask = 0
mask = 1
for i in range(BITCOUNT):
ONESbit = (xONES >> i) & 1
ZEROSbit = (xZEROS >> i) & 1
if (ONESbit == 1) and (ZEROSbit == 0):
andmask += mask
elif (ONESbit == 0) and (ZEROSbit == 1):
andmask += mask
xormask += mask
elif (ONESbit == 1) and (ZEROSbit == 1):
xormask += mask
mask *= 2
print(2)
print('& {}'.format(andmask))
print('^ {}'.format(xormask))
```
| 93,200 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Tags: bitmasks, constructive algorithms
Correct Solution:
```
import sys
input=sys.stdin.readline
import copy
from math import *
n=int(input())
a=[-1 for i in range(10)]
for i in range(n):
p,q=input().split()
qq=(bin(int(q))[2:])
q=list((10-len(qq))*"0"+qq)
if p=='|':
for i in range(9,-1,-1):
if q[i]=='1':
a[i]=1
if p=='&':
for i in range(9,-1,-1):
if q[i]=='0':
a[i]=0
if p=='^':
for i in range(9,-1,-1):
if q[i]=='1' and (a[i]==0 or a[i]==1):
a[i]^=1
elif q[i]=='1' :
if a[i]==-1:
a[i]=-2
else:
a[i]=-1
#print(a)
c=0
for i in range(10):
if a[i]==-2:
c+=(2**(10-i-1))
print(3)
print("^",c)
v=list("0"*10)
for i in range(10):
if a[i]==1:
v[i]='1'
print("|",int("".join(v),2))
u=list("1"*10)
for i in range(10):
if a[i]==0:
u[i]='0'
print("&",int("".join(u),2))
```
| 93,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n = int(input())
queries = list(input().split() for _ in range(n))
a, b = 0, (1<<10) - 1
for c, x in queries:
x = int(x)
if c == '|':
a, b = a | x, b | x
elif c == '&':
a, b = a & x, b & x
elif c == '^':
a, b = a ^ x, b ^ x
x, y, z = 0, (1<<10) - 1, 0
for i in range(10):
a_i = (a >> i) & 1
b_i = (b >> i) & 1
if a_i and b_i:
x |= (1 << i)
if not a_i and not b_i:
y ^= (1 << i)
if a_i and not b_i:
z ^= (1 << i)
print(3)
print('|', x)
print('&', y)
print('^', z)
```
| 93,202 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Tags: bitmasks, constructive algorithms
Correct Solution:
```
from sys import *
d = {'|': lambda t: t | k, '&': lambda t: t & k, '^': lambda t: t ^ k}
a, b = 1023, 0
for i in range(int(input())):
s, q = stdin.readline().split()
k = int(q)
a = d[s](a)
b = d[s](b)
t = [2]
for u in range(1024):
for v in range(1024):
if 1023 ^ v == a and u ^ v == b:
print('2\n|', u, '\n^', v)
exit()
```
| 93,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Tags: bitmasks, constructive algorithms
Correct Solution:
```
n = int(input())
a, b = 1023, 0
for _ in range(n):
c, d = input().split()
d = int(d)
if c == '|':
a, b = a | d, b | d
elif c == '&':
a, b = a & d, b & d
elif c == '^':
a, b = a ^ d, b ^ d
print('2\n| {}\n^ {}'.format(a ^ b ^ 1023, a ^ 1023))
```
| 93,204 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
a=1023
b=0
for _ in range(n):
s,num=input().rstrip().split()
num=int(num)
if s=="|":
a,b=a|num,b|num
elif s=="&":
a,b=a&num,b&num
else:
a,b=a^num,b^num
print("2\n| {}\n^ {}".format(a^b^1023,a^1023))
```
Yes
| 93,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
import queue
def readTuple():
return input().split()
def readInts():
return tuple(map(int, readTuple()))
def to_int(x):
x=x[::-1]
res = 0
for i in x:
res <<= 1
res |= i
return res
def solve():
res = ['X']*10
n, = readInts()
a,b = 0, 1023
for _ in range(n):
char, num = readTuple()
num = int(num)
if char == '|':
a |= num
b |= num
if char == '&':
a &= num
b &= num
if char == '^':
a ^= num
b ^= num
XOR, OR = [],[]
for i in range(10):
b1 = a&(1<<i)
b2 = b&(1<<i)
if b1 and b2:
OR.append(1)
XOR.append(0)
if not b1 and not b2:
OR.append(1)
XOR.append(1)
if b1 and not b2:
OR.append(0)
XOR.append(1)
if not b1 and b2:
OR.append(0)
XOR.append(0)
print(2)
print(f"| {to_int(OR)}")
print(f"^ {to_int(XOR)}")
if __name__ == '__main__':
solve()
```
Yes
| 93,206 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
com = []
for _ in range(n):
l = input().split()
com.append((l[0], int(l[1])))
AND, OR, XOR = [], [], []
for i in range(10):
res1 = 0
res2 = 1
for s, n in com:
b = (n>>i)&1
if s=='&':
res1 &= b
res2 &= b
elif s=='|':
res1 |= b
res2 |= b
elif s=='^':
res1 ^= b
res2 ^= b
if (res1, res2)==(0, 0):
AND.append(i)
elif (res1, res2)==(1, 1):
OR.append(i)
elif (res1, res2)==(1, 0):
XOR.append(i)
AND_n = 0
for i in range(10):
if i not in AND:
AND_n += 2**i
OR_n = 0
for i in OR:
OR_n += 2**i
XOR_n = 0
for i in XOR:
XOR_n += 2**i
print(3)
print('&', AND_n)
print('|', OR_n)
print('^', XOR_n)
"""
for i in range(1024):
res1 = i
for s, n in com:
if s=='&':
res1 &= n
elif s=='|':
res1 |= n
elif s=='^':
res1 ^= n
res2 = i
res2 &= AND_n
res2 |= OR_n
res2 ^= XOR_n
if res1!=res2:
1/0
"""
```
Yes
| 93,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
a, b = 0, 1023
# commands = []
for i in range(int(input())):
cmd = input()
# commands.append(cmd)
c, x = cmd.split()
x = int(x)
if c == "|":
a, b = a | x, b | x
elif c == "&":
a, b = a & x, b & x
else:
a, b = a ^ x, b ^ x
# a, b = eval("a " + cmd), eval("b " + cmd)
x = 0
y = 1023
z = 0
for i in range(10):
a_i = (a >> i) & 1
b_i = (b >> i) & 1
if a_i and b_i:
x |= 1 << i
if (not a_i) and (not b_i):
y ^= 1 << i
if a_i and (not b_i):
z ^= 1 << i
print("3\n| {}\n& {}\n^ {}".format(x, y, z))
# for i in range(1024):
# t1 = i
# for cmd in commands:
# t1 = eval("t1 " + cmd)
# t2 = eval("(((i | x) & y) ^ z)")
# if t1 != t2:
# print("Neq on ", i)
```
Yes
| 93,208 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
n = int(input())
for i in range(n):
x, y = input().split()
y = int(y)
if i == 0:
b = x
m = y
else:
if x == '^':
m = m ^ y
elif x == '|':
m = m | y
else:
m = m & y
if m == 0:
if b == '&':
print(1)
print(b, 0)
else:
print(0)
else:
print(1)
print(b, m)
```
No
| 93,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
n = int(input())
action = [0, 1, 2, 3] # reverse, don't do anything, set to zero, set to one
byte = [action[1], action[1], action[1], action[1], action[1], action[1], action[1], action[1], action[1], action[1]]
for i in range(n):
operator, operand = input().split(' ')
operand = int(operand)
binary = []
while operand:
binary.append(operand % 2)
operand //= 2
binary.reverse()
if operator == '^':
for i in range(len(binary)):
if binary[-i - 1] == 0:
continue
if binary[-i - 1] == 1:
if byte[-i - 1] == action[0]:
byte[-i - 1] = action[1]
elif byte[-i - 1] == action[1]:
byte[-i - 1] = action[0]
elif byte[-i - 1] == action[2]:
byte[-i - 1] = action[3]
elif byte[-i - 1] == action[3]:
byte[-i - 1] = action[2]
elif operator == '&':
for i in range(len(binary)):
if binary[-i - 1] == 0:
byte[-i - 1] = action[2]
elif binary[-i - 1] == 1:
continue
elif operator == '|':
for i in range(len(binary)):
if binary[-i - 1] == 0:
continue
elif binary[-i - 1] == 1:
byte[-i - 1] = action[3]
toSwap = 0
for i in range(len(byte)):
if byte[i] == action[0]:
toSwap += 2 ** (9 - i)
toZero = 1023
for i in range(len(byte)):
if byte[i] == action[2]:
toZero -= 2 ** (9 - i)
toOne = 0
for i in range(len(byte)):
if byte[i] == action[3]:
toOne += 2 ** (9 - i)
print(3)
print(*['^', toSwap])
print(*['&', toZero])
print(*['|', toOne])
```
No
| 93,210 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
ii=lambda:int(input())
kk=lambda:map(int, input().split())
ll=lambda:list(kk())
# xor + 0 --> unchanged(2)
# xor + 1 --> flip(3)
# or + 0 --> unchanged(2)
# or + 1 --> 1(1)
# and + 0 --> 0(0)
# and + 1 --> unchanged(2)
arr = [2]*10
for _ in range(ii()):
s,v=input().split()
v = int(v)
if s == b"|":
for i in range(10):
if v&(2**i):
arr[i]= 1
elif s == b"^":
for i in range(10):
if v&(2**i):
arr[i]^=1
elif s == b"|":
for i in range(10):
if not (v&(2**i)):
arr[i]=0
else:
print(s)
print(3)
x=o=a= 0
for i in range(10):
if arr[i]==3: x += 2**i
elif arr[i]==0: a+=2**i
elif arr[i]==1:o+=2**i
print('|',o)
print('^',x)
print('&',2**10 - a - 1)
```
No
| 93,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petya learned a new programming language CALPAS. A program in this language always takes one non-negative integer and returns one non-negative integer as well.
In the language, there are only three commands: apply a bitwise operation AND, OR or XOR with a given constant to the current integer. A program can contain an arbitrary sequence of these operations with arbitrary constants from 0 to 1023. When the program is run, all operations are applied (in the given order) to the argument and in the end the result integer is returned.
Petya wrote a program in this language, but it turned out to be too long. Write a program in CALPAS that does the same thing as the Petya's program, and consists of no more than 5 lines. Your program should return the same integer as Petya's program for all arguments from 0 to 1023.
Input
The first line contains an integer n (1 ≤ n ≤ 5·105) — the number of lines.
Next n lines contain commands. A command consists of a character that represents the operation ("&", "|" or "^" for AND, OR or XOR respectively), and the constant xi 0 ≤ xi ≤ 1023.
Output
Output an integer k (0 ≤ k ≤ 5) — the length of your program.
Next k lines must contain commands in the same format as in the input.
Examples
Input
3
| 3
^ 2
| 1
Output
2
| 3
^ 2
Input
3
& 1
& 3
& 5
Output
1
& 1
Input
3
^ 1
^ 2
^ 3
Output
0
Note
You can read about bitwise operations in <https://en.wikipedia.org/wiki/Bitwise_operation>.
Second sample:
Let x be an input of the Petya's program. It's output is ((x&1)&3)&5 = x&(1&3&5) = x&1. So these two programs always give the same outputs.
Submitted Solution:
```
n = int( input() )
first = True
A1, A2 = 0, 1023
O1, O2 = 0, 1023
X1, X2 = 0, 1023
for i in range( n ):
s, d = input().split()
d = int( d )
if s == '|':
O1 |= d
elif s == '&':
if first == True:
A1 = d
first = False
else:
A1 &= d
A2 &= d
elif s == '^':
X1 ^= d
X2 ^= d
#print( s, d )
ans = []
O = O1 & O2
A = A1 & A2
X = X1 & (1023^X2)
if O:
ans.append( ('|', O) )
if X:
ans.append( ('^', X) )
if A:
ans.append( ('&', A) )
#print( A, O, X )
print( len(ans) )
for i in range( len(ans) ):
print( ans[i][0] + " " + str(ans[i][1]) )
```
No
| 93,212 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an undirected graph with n vertices. There are no edge-simple cycles with the even length in it. In other words, there are no cycles of even length that pass each edge at most once. Let's enumerate vertices from 1 to n.
You have to answer q queries. Each query is described by a segment of vertices [l; r], and you have to count the number of its subsegments [x; y] (l ≤ x ≤ y ≤ r), such that if we delete all vertices except the segment of vertices [x; y] (including x and y) and edges between them, the resulting graph is bipartite.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3·105, 1 ≤ m ≤ 3·105) — the number of vertices and the number of edges in the graph.
The next m lines describe edges in the graph. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting an edge between vertices ai and bi. It is guaranteed that this graph does not contain edge-simple cycles of even length.
The next line contains a single integer q (1 ≤ q ≤ 3·105) — the number of queries.
The next q lines contain queries. The i-th of these lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the query parameters.
Output
Print q numbers, each in new line: the i-th of them should be the number of subsegments [x; y] (li ≤ x ≤ y ≤ ri), such that the graph that only includes vertices from segment [x; y] and edges between them is bipartite.
Examples
Input
6 6
1 2
2 3
3 1
4 5
5 6
6 4
3
1 3
4 6
1 6
Output
5
5
14
Input
8 9
1 2
2 3
3 1
4 5
5 6
6 7
7 8
8 4
7 2
3
1 8
1 4
3 8
Output
27
8
19
Note
The first example is shown on the picture below:
<image>
For the first query, all subsegments of [1; 3], except this segment itself, are suitable.
For the first query, all subsegments of [4; 6], except this segment itself, are suitable.
For the third query, all subsegments of [1; 6] are suitable, except [1; 3], [1; 4], [1; 5], [1; 6], [2; 6], [3; 6], [4; 6].
The second example is shown on the picture below:
<image>
Tags: binary search, data structures, dfs and similar, dsu, graphs, two pointers
Correct Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
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 += self.num
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):
if r==self.size:
r = self.num
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
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
edge = [[] for i in range(n)]
for _ in range(m):
u,v = mi()
edge[u-1].append(v-1)
edge[v-1].append(u-1)
parent = [-1 for i in range(n)]
depth = [0 for i in range(n)]
cnt = [0 for i in range(n)]
res = [n for i in range(n)]
for root in range(n):
if parent[root]==-1:
stack = [root]
while stack:
v = stack[-1]
if len(edge[v])==cnt[v]:
stack.pop()
else:
nv = edge[v][cnt[v]]
cnt[v] += 1
if nv==root or parent[nv]!=-1:
if depth[nv] < depth[v]-1:
m,M = nv,nv
pos = v
while pos!=nv:
m = min(pos,m)
M = max(pos,M)
pos = parent[pos]
res[m] = min(res[m],M)
else:
depth[nv] = depth[v] + 1
parent[nv] = v
stack.append(nv)
cnt = [0 for i in range(n)]
cnt[n-1] = res[n-1] - (n-1)
for i in range(n-2,-1,-1):
res[i] = min(res[i],res[i+1])
cnt[i] = res[i] - i
for i in range(1,n):
cnt[i] += cnt[i-1]
query = [[] for i in range(n+1)]
q = int(input())
for i in range(q):
l,r = mi()
query[r].append((i,l-1))
pos = -1
ans = [0 for i in range(q)]
for r in range(1,n+1):
while pos+1<n and res[pos+1]<=r:
pos += 1
for idx,l in query[r]:
if r<=pos:
tmp = cnt[r-1]
if l:
tmp -= cnt[l-1]
elif l<=pos:
tmp = cnt[pos]
if l:
tmp -= cnt[l-1]
tmp += (r-pos-1) * r - ((r+pos)*(r-pos-1)//2)
else:
tmp = (r-l) * r - ((r-1+l)*(r-l)//2)
ans[idx] = tmp
print(*ans,sep="\n")
```
| 93,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with n vertices. There are no edge-simple cycles with the even length in it. In other words, there are no cycles of even length that pass each edge at most once. Let's enumerate vertices from 1 to n.
You have to answer q queries. Each query is described by a segment of vertices [l; r], and you have to count the number of its subsegments [x; y] (l ≤ x ≤ y ≤ r), such that if we delete all vertices except the segment of vertices [x; y] (including x and y) and edges between them, the resulting graph is bipartite.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3·105, 1 ≤ m ≤ 3·105) — the number of vertices and the number of edges in the graph.
The next m lines describe edges in the graph. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting an edge between vertices ai and bi. It is guaranteed that this graph does not contain edge-simple cycles of even length.
The next line contains a single integer q (1 ≤ q ≤ 3·105) — the number of queries.
The next q lines contain queries. The i-th of these lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the query parameters.
Output
Print q numbers, each in new line: the i-th of them should be the number of subsegments [x; y] (li ≤ x ≤ y ≤ ri), such that the graph that only includes vertices from segment [x; y] and edges between them is bipartite.
Examples
Input
6 6
1 2
2 3
3 1
4 5
5 6
6 4
3
1 3
4 6
1 6
Output
5
5
14
Input
8 9
1 2
2 3
3 1
4 5
5 6
6 7
7 8
8 4
7 2
3
1 8
1 4
3 8
Output
27
8
19
Note
The first example is shown on the picture below:
<image>
For the first query, all subsegments of [1; 3], except this segment itself, are suitable.
For the first query, all subsegments of [4; 6], except this segment itself, are suitable.
For the third query, all subsegments of [1; 6] are suitable, except [1; 3], [1; 4], [1; 5], [1; 6], [2; 6], [3; 6], [4; 6].
The second example is shown on the picture below:
<image>
Submitted Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
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 += self.num
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):
if r==self.size:
r = self.num
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
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
edge = [[] for i in range(n)]
for _ in range(m):
u,v = mi()
edge[u-1].append(v-1)
edge[v-1].append(u-1)
if n<=100:
mini = SegmentTree([10**8 for i in range(n)],min,10**8)
maxi = SegmentTree([-1 for i in range(n)],max,-1)
parent = [-1 for i in range(n)]
depth = [0 for i in range(n)]
cnt = [0 for i in range(n)]
res = [n for i in range(n)]
for root in range(n):
if parent[root]==-1:
stack = [root]
mini.update(0,root)
maxi.update(0,root)
while stack:
v = stack[-1]
if len(edge[v])==cnt[v]:
mini.update(depth[v],10**8)
maxi.update(depth[v],-1)
stack.pop()
else:
nv = edge[v][cnt[v]]
cnt[v] += 1
if nv==root or parent[nv]!=-1:
if depth[nv] < depth[v]-1:
L,R = depth[nv],depth[v]
m,M = mini.query(L,R+1),maxi.query(L,R+1)
res[m] = M
else:
depth[nv] = depth[v] + 1
parent[nv] = v
mini.update(depth[nv],nv)
maxi.update(depth[nv],nv)
stack.append(nv)
cnt = [0 for i in range(n)]
cnt[n-1] = res[n-1] - (n-1)
for i in range(n-2,-1,-1):
res[i] = min(res[i],res[i+1])
cnt[i] = res[i] - i
for i in range(1,n):
cnt[i] += cnt[i-1]
query = [[] for i in range(n+1)]
q = int(input())
for i in range(q):
l,r = mi()
query[r].append((i,l-1))
if n<=100:
pos = -1
ans = [0 for i in range(q)]
for r in range(1,n+1):
while pos+1<n and res[pos+1]<=r:
pos += 1
for idx,l in query[r]:
if r<=pos:
tmp = cnt[r-1]
if l:
tmp -= cnt[l-1]
else:
tmp = cnt[pos]
if l:
tmp -= cnt[l-1]
tmp += (r-pos-1) * r - ((r+pos)*(r-pos-1)//2)
ans[idx] = tmp
print(*ans,sep="\n")
```
No
| 93,214 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with n vertices. There are no edge-simple cycles with the even length in it. In other words, there are no cycles of even length that pass each edge at most once. Let's enumerate vertices from 1 to n.
You have to answer q queries. Each query is described by a segment of vertices [l; r], and you have to count the number of its subsegments [x; y] (l ≤ x ≤ y ≤ r), such that if we delete all vertices except the segment of vertices [x; y] (including x and y) and edges between them, the resulting graph is bipartite.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3·105, 1 ≤ m ≤ 3·105) — the number of vertices and the number of edges in the graph.
The next m lines describe edges in the graph. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), denoting an edge between vertices ai and bi. It is guaranteed that this graph does not contain edge-simple cycles of even length.
The next line contains a single integer q (1 ≤ q ≤ 3·105) — the number of queries.
The next q lines contain queries. The i-th of these lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the query parameters.
Output
Print q numbers, each in new line: the i-th of them should be the number of subsegments [x; y] (li ≤ x ≤ y ≤ ri), such that the graph that only includes vertices from segment [x; y] and edges between them is bipartite.
Examples
Input
6 6
1 2
2 3
3 1
4 5
5 6
6 4
3
1 3
4 6
1 6
Output
5
5
14
Input
8 9
1 2
2 3
3 1
4 5
5 6
6 7
7 8
8 4
7 2
3
1 8
1 4
3 8
Output
27
8
19
Note
The first example is shown on the picture below:
<image>
For the first query, all subsegments of [1; 3], except this segment itself, are suitable.
For the first query, all subsegments of [4; 6], except this segment itself, are suitable.
For the third query, all subsegments of [1; 6] are suitable, except [1; 3], [1; 4], [1; 5], [1; 6], [2; 6], [3; 6], [4; 6].
The second example is shown on the picture below:
<image>
Submitted Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
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 += self.num
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):
if r==self.size:
r = self.num
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
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
import io,os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
edge = [[] for i in range(n)]
for _ in range(m):
u,v = mi()
edge[u-1].append(v-1)
edge[v-1].append(u-1)
parent = [-1 for i in range(n)]
depth = [0 for i in range(n)]
cnt = [0 for i in range(n)]
res = [n for i in range(n)]
for root in range(n):
if parent[root]==-1:
stack = [root]
while stack:
v = stack[-1]
if len(edge[v])==cnt[v]:
stack.pop()
else:
nv = edge[v][cnt[v]]
cnt[v] += 1
if nv==root or parent[nv]!=-1:
if depth[nv] < depth[v]-1:
m,M = nv,nv
pos = v
while pos!=nv:
m = min(pos,m)
M = max(pos,M)
pos = parent[pos]
res[m] = min(res[m],M)
else:
depth[nv] = depth[v] + 1
parent[nv] = v
stack.append(nv)
cnt = [0 for i in range(n)]
cnt[n-1] = res[n-1] - (n-1)
for i in range(n-2,-1,-1):
res[i] = min(res[i],res[i+1])
cnt[i] = res[i] - i
for i in range(1,n):
cnt[i] += cnt[i-1]
query = [[] for i in range(n+1)]
q = int(input())
for i in range(q):
l,r = mi()
query[r].append((i,l-1))
pos = -1
ans = [0 for i in range(q)]
for r in range(1,n+1):
while pos+1<n and res[pos+1]<=r:
pos += 1
for idx,l in query[r]:
if r<=pos:
tmp = cnt[r-1]
if l:
tmp -= cnt[l-1]
else:
tmp = cnt[pos]
if l:
tmp -= cnt[l-1]
tmp += (r-pos-1) * r - ((r+pos)*(r-pos-1)//2)
ans[idx] = tmp
print(*ans,sep="\n")
```
No
| 93,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
G = {"no.":3, "eve":1, "are":1, "wor":1, "ter":1, "god":1, "now":2}
N = {"no.":5, "gre":1, "coo":1, "thi":1, "not":1, "tou":1}
from collections import defaultdict as dd, deque
C = dd(int)
S = set()
for i in range(10):
print(i)
s = input()+'........'
s = s.replace(' ','').replace("don't", "")
s = s[:3]
C[s] += 1
if s not in G or C[s]>G[s]:
print('normal')
break
if s not in N or C[s]>N[s]:
print('grumpy')
break
```
| 93,216 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
import sys
for i in range(10):
print(i)
sys.stdout.flush()
a = sys.stdin.readline().strip().lower()
if "cool" in a or "great" in a or "not bad" in a or "think" in a:
print("normal")
sys.exit(0)
if "die" in a or "serious" in a or "way" in a or "worse" in a or "terrible" in a or "even" in a:
print("grumpy")
sys.exit(0)
```
| 93,217 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
print('grumpy' if input('9\n')in['go die in a hole','are you serious?','terrible','worse','no way',"don't even"] else 'normal')
# Made By Mostafa_Khaled
```
| 93,218 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
for i in range(10):
print(i)
t = input().strip()
if t == "no": continue
if t in {"don't even", "are you serious", "worse", "terrible", "go die in a hole", "no way"}:
print("grumpy")
else:
print("normal")
break
```
| 93,219 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
no = 0
for i in range (10):
print(i)
inp = input()
if inp == "no":
no += 1
if no == 4:
exit(print("normal"))
continue
if inp == "cool" or inp == "don't think so" or inp == "not bad" or inp == "don't touch me" or inp == "great":
exit(print("normal"))
exit(print("grumpy"))
```
| 93,220 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
print(9)
s = input()
sk = ["go die in a hole", "are you serious?", "terrible", "worse", "no way", "don't even"]
print("grumpy" if s in sk else "normal")
```
| 93,221 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
#print('grumpy')
from sys import exit
import sys
a = ['no', 'no', 'no', 'no', 'no', "don'",'grea',"don'",'not ','cool']
b = ['no','no','no', 'no w', 'no w','go d','wors','terr', "don'", 'are ']
for i in range(9):
sys.stdout.write(str(i))
sys.stdout.write('\n')
sys.stdout.flush()
inp = input()
if (inp.__len__()>4):
inp = inp[:4]
if inp in a:
a.remove(inp)
else :
print('grumpy')
exit()
if inp in b:
b.remove(inp)
else:
print('normal')
exit()
sys.stdout.write('normal')
#sys.stdout.write('\n')
sys.stdout.flush()
exit()
for i in range(10):
print(i)
a = input()
if (a.__len__() > 2):
if a[-2:] == 'en':
print('grumpy')
exit()
print('normal')
```
| 93,222 |
Provide tags and a correct Python 3 solution for this coding contest problem.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Tags: brute force, interactive
Correct Solution:
```
normal = ["no"] * 5 + ["cool", "not bad", "great!", "don't touch me!", "don't think so"]
grumpy = ["no"] * 3 + ["no way"] * 2 + ["terrible", "worse", "go die in a hole", "don't even", "are you serious?"]
import sys
import re
sys.stdout.flush()
normal = [re.sub("('|!|\?| )", "", x).lower() for x in normal]
grumpy = [re.sub("('|!|\?| )", "", x).lower() for x in grumpy]
cat = None
counter = 0
while cat is None:
print(counter)
sys.stdout.flush()
text = re.sub("('|!|\?| )", "", input()).lower()
if text in normal:
normal.remove(text)
else:
cat = "grumpy"
if text in grumpy:
grumpy.remove(text)
else:
cat = "normal"
counter += 1
print(cat)
```
| 93,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
#print('grumpy')
from sys import exit
import sys
a = ['no', 'no', 'no', 'no', 'no', "don't t",'grea',"don't t",'not ','cool']
b = ['no','no','no', 'no w', 'no w','go d','wors','terr', "don't e", 'are ']
for i in range(10):
sys.stdout.write(str(i))
sys.stdout.write('\n')
sys.stdout.flush()
inp = input()
if (inp.__len__()>4):
if (inp[:4] == "don'"):
inp = inp[:7]
else:
inp = inp[:4]
if inp in a:
a.remove(inp)
else :
print('grumpy')
exit()
if inp in b:
b.remove(inp)
else:
print('normal')
exit()
sys.stdout.write('normal')
#sys.stdout.write('\n')
sys.stdout.flush()
exit()
for i in range(10):
print(i)
a = input()
if (a.__len__() > 2):
if a[-2:] == 'en':
print('grumpy')
exit()
print('normal')
```
Yes
| 93,224 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
# python3
for i in range(10):
print(i)
reaction = input()
if reaction != "no":
for part in ("no way", "die", "worse", "terrible", "even", "are"):
if part in reaction:
print("grumpy")
break
else:
print("normal")
break
```
Yes
| 93,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
import re
import math
import decimal
import bisect
def read():
return input().strip()
# code goes here
grumpy = ["don't even", "are you serious?", "go die in a hole", "worse", "terrible", "no way"]
print(9, flush=True)
resp = read()
if resp in grumpy:
print("grumpy", flush=True)
else:
print("normal", flush=True)
```
Yes
| 93,226 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
normal = ["great", "don't think so", "don't touch me", "not bad", "cool"]
response = "no"
x = 0
while response == "no":
print(x, flush = True)
response = input()
x += 1
print("normal") if response in normal else print("grumpy")
```
Yes
| 93,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
for i in range(10):
print(i)
s = input()
if (s=='great!') or (s=="don't think so") or (s=='not bad') or (s=='cool') or (s=="don't touch me!"):
print ('normal')
break
if (s=="DON'T EVEN") or (s=='Are you serious?') or (s=='Worse') or (s=='Terrible') or (s=='no way') or (s=='Go die in a hole'):
print('grumpy')
break
```
No
| 93,228 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
import sys
grumpy = False
for i in range(7):
print(i)
sys.stdout.flush()
response = input()
if "way" in response: grumpy = True
if grumpy: print("grumpy")
else: print("normal")
```
No
| 93,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
print(2, 2)
```
No
| 93,230 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
If you have ever interacted with a cat, you have probably noticed that they are quite particular about how to pet them. Here is an approximate map of a normal cat.
<image>
However, some cats won't tolerate this nonsense from the humans. Here is a map of a grumpy cat.
<image>
You have met a cat. Can you figure out whether it's normal or grumpy?
Interaction
This is an interactive problem. Initially you're not given any information about the cat. Instead, the cat is divided into ten areas, indexed from 0 to 9.
In one query you can choose which area you'll pet and print the corresponding index to standard out. You will get the cat's response, as depicted on the corresponding map, via standard in. For simplicity all responses are written in lowercase.
Once you're certain what type of cat you're dealing with, output "normal" or "grumpy" to standard out.
Note
Please make sure to use the stream flushing operation after each query in order not to leave part of your output in some buffer.
Submitted Solution:
```
"""
Codeforces April Fools 2018 Problem B
Author : chaotic_iak
Language: Python 3.5.2
"""
################################################### SOLUTION
def initialize_solution():
pass
def main():
for i in range(10):
write(i)
resp = input().lower()
if resp in ["no way", "are you serious?", "don't even", "go die in a hole", "terrible", "worse", "don't think so", "don't touch me!"]:
return "grumpy"
elif resp in ["great!", "not bad", "cool"]:
return "normal"
########################################## PROBLEM CONSTANTS
READ_FROM_FILE = None
OUTPUT_PREFIX = None
INTERACTIVE = True
#################################################### HELPERS
import sys
def read(callback=int, split=True):
if READ_FROM_FILE:
ipt = sfile.readline().strip()
else:
ipt = input().strip()
if INTERACTIVE and ipt == "WRONG_ANSWER":
sys.exit()
if split:
return list(map(callback, ipt.split()))
else:
return callback(ipt)
def write(value, end="\n"):
if value is None: return
try:
if not isinstance(value, str):
value = " ".join(map(str, value))
except:
pass
if READ_FROM_FILE:
tfile.write(str(value, end=end))
else:
print(value, end=end)
if INTERACTIVE:
sys.stdout.flush()
sfile = None
tfile = None
if READ_FROM_FILE:
sfile = open(READ_FROM_FILE + ".in", "r")
sfile.seek(0)
tfile = open(READ_FROM_FILE + ".out", "w")
if OUTPUT_PREFIX is None:
result = main()
if result is not None:
write(result)
else:
initialize_solution()
TOTAL_CASES, = read()
for CASE_NUMBER in range(1, TOTAL_CASES+1):
write(OUTPUT_PREFIX.replace("%d", str(CASE_NUMBER)), end="")
result = main()
if result is not None:
write(result)
if sfile is not None: sfile.close()
if tfile is not None: tfile.close()
```
No
| 93,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuro is currently playing an educational game about numbers. The game focuses on the greatest common divisor (GCD), the XOR value, and the sum of two numbers. Kuro loves the game so much that he solves levels by levels day by day.
Sadly, he's going on a vacation for a day, and he isn't able to continue his solving streak on his own. As Katie is a reliable person, Kuro kindly asked her to come to his house on this day to play the game for him.
Initally, there is an empty array a. The game consists of q tasks of two types. The first type asks Katie to add a number u_i to a. The second type asks Katie to find a number v existing in a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), GCD(c, d) denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers c and d, and y ∣ x means x is divisible by y, or report -1 if no such numbers are found.
Since you are a programmer, Katie needs you to automatically and accurately perform the tasks in the game to satisfy her dear friend Kuro. Let's help her!
Input
The first line contains one integer q (2 ≤ q ≤ 10^{5}) — the number of tasks the game wants you to perform.
q lines follow, each line begins with an integer t_i — the type of the task:
* If t_i = 1, an integer u_i follow (1 ≤ u_i ≤ 10^{5}) — you have to add u_i to the array a.
* If t_i = 2, three integers x_i, k_i, and s_i follow (1 ≤ x_i, k_i, s_i ≤ 10^{5}) — you must find a number v existing in the array a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the XOR operation, or report -1 if no such numbers are found.
It is guaranteed that the type of the first task is type 1, and there exists at least one task of type 2.
Output
For each task of type 2, output on one line the desired number v, or -1 if no such numbers are found.
Examples
Input
5
1 1
1 2
2 1 1 3
2 1 1 2
2 1 1 1
Output
2
1
-1
Input
10
1 9
2 9 9 22
2 3 3 18
1 25
2 9 9 20
2 25 25 14
1 20
2 26 26 3
1 14
2 20 20 9
Output
9
9
9
-1
-1
-1
Note
In the first example, there are 5 tasks:
* The first task requires you to add 1 into a. a is now \left\{1\right\}.
* The second task requires you to add 2 into a. a is now \left\{1, 2\right\}.
* The third task asks you a question with x = 1, k = 1 and s = 3. Taking both 1 and 2 as v satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 3. Because 2 ⊕ 1 = 3 > 1 ⊕ 1 = 0, 2 is the answer to this task.
* The fourth task asks you a question with x = 1, k = 1 and s = 2. Only v = 1 satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 2, so 1 is the answer to this task.
* The fifth task asks you a question with x = 1, k = 1 and s = 1. There are no elements in a that satisfy the conditions, so we report -1 as the answer to this task.
Submitted Solution:
```
def Nod(a, b):
while a != 0 and b != 0:
if a > b:
a = a % b
else:
b = b % a
return a + b
q = int(input())
a = set()
for i in range(q):
t = tuple(map(int, input().split()))
if t[0] == 1:
a.add(t[1])
else:
t, x, k, s = t
r = -1
mx = -1
for u in a:
if x + u <= s:
if k % Nod(x, u) == 0:
xu = x ^ u
if xu > mx:
mx = xu
r = u
print(r)
```
No
| 93,232 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuro is currently playing an educational game about numbers. The game focuses on the greatest common divisor (GCD), the XOR value, and the sum of two numbers. Kuro loves the game so much that he solves levels by levels day by day.
Sadly, he's going on a vacation for a day, and he isn't able to continue his solving streak on his own. As Katie is a reliable person, Kuro kindly asked her to come to his house on this day to play the game for him.
Initally, there is an empty array a. The game consists of q tasks of two types. The first type asks Katie to add a number u_i to a. The second type asks Katie to find a number v existing in a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), GCD(c, d) denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers c and d, and y ∣ x means x is divisible by y, or report -1 if no such numbers are found.
Since you are a programmer, Katie needs you to automatically and accurately perform the tasks in the game to satisfy her dear friend Kuro. Let's help her!
Input
The first line contains one integer q (2 ≤ q ≤ 10^{5}) — the number of tasks the game wants you to perform.
q lines follow, each line begins with an integer t_i — the type of the task:
* If t_i = 1, an integer u_i follow (1 ≤ u_i ≤ 10^{5}) — you have to add u_i to the array a.
* If t_i = 2, three integers x_i, k_i, and s_i follow (1 ≤ x_i, k_i, s_i ≤ 10^{5}) — you must find a number v existing in the array a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the XOR operation, or report -1 if no such numbers are found.
It is guaranteed that the type of the first task is type 1, and there exists at least one task of type 2.
Output
For each task of type 2, output on one line the desired number v, or -1 if no such numbers are found.
Examples
Input
5
1 1
1 2
2 1 1 3
2 1 1 2
2 1 1 1
Output
2
1
-1
Input
10
1 9
2 9 9 22
2 3 3 18
1 25
2 9 9 20
2 25 25 14
1 20
2 26 26 3
1 14
2 20 20 9
Output
9
9
9
-1
-1
-1
Note
In the first example, there are 5 tasks:
* The first task requires you to add 1 into a. a is now \left\{1\right\}.
* The second task requires you to add 2 into a. a is now \left\{1, 2\right\}.
* The third task asks you a question with x = 1, k = 1 and s = 3. Taking both 1 and 2 as v satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 3. Because 2 ⊕ 1 = 3 > 1 ⊕ 1 = 0, 2 is the answer to this task.
* The fourth task asks you a question with x = 1, k = 1 and s = 2. Only v = 1 satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 2, so 1 is the answer to this task.
* The fifth task asks you a question with x = 1, k = 1 and s = 1. There are no elements in a that satisfy the conditions, so we report -1 as the answer to this task.
Submitted Solution:
```
def Nod(a, b):
while a != 0 and b != 0:
if a > b:
a = a % b
else:
b = b % a
return a + b
q = int(input())
a = set()
for i in range(q):
t = tuple(map(int, input().split()))
if t[0] == 1:
a.add(t[1])
else:
t, x, k, s = t
r = -1
mx = -1
for u in a:
if x + u <= s:
if k % Nod(x, u) == 0:
xu = x | u
if xu > mx:
mx = xu
r = u
print(r)
```
No
| 93,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kuro is currently playing an educational game about numbers. The game focuses on the greatest common divisor (GCD), the XOR value, and the sum of two numbers. Kuro loves the game so much that he solves levels by levels day by day.
Sadly, he's going on a vacation for a day, and he isn't able to continue his solving streak on his own. As Katie is a reliable person, Kuro kindly asked her to come to his house on this day to play the game for him.
Initally, there is an empty array a. The game consists of q tasks of two types. The first type asks Katie to add a number u_i to a. The second type asks Katie to find a number v existing in a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR), GCD(c, d) denotes the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers c and d, and y ∣ x means x is divisible by y, or report -1 if no such numbers are found.
Since you are a programmer, Katie needs you to automatically and accurately perform the tasks in the game to satisfy her dear friend Kuro. Let's help her!
Input
The first line contains one integer q (2 ≤ q ≤ 10^{5}) — the number of tasks the game wants you to perform.
q lines follow, each line begins with an integer t_i — the type of the task:
* If t_i = 1, an integer u_i follow (1 ≤ u_i ≤ 10^{5}) — you have to add u_i to the array a.
* If t_i = 2, three integers x_i, k_i, and s_i follow (1 ≤ x_i, k_i, s_i ≤ 10^{5}) — you must find a number v existing in the array a such that k_i ∣ GCD(x_i, v), x_i + v ≤ s_i, and x_i ⊕ v is maximized, where ⊕ denotes the XOR operation, or report -1 if no such numbers are found.
It is guaranteed that the type of the first task is type 1, and there exists at least one task of type 2.
Output
For each task of type 2, output on one line the desired number v, or -1 if no such numbers are found.
Examples
Input
5
1 1
1 2
2 1 1 3
2 1 1 2
2 1 1 1
Output
2
1
-1
Input
10
1 9
2 9 9 22
2 3 3 18
1 25
2 9 9 20
2 25 25 14
1 20
2 26 26 3
1 14
2 20 20 9
Output
9
9
9
-1
-1
-1
Note
In the first example, there are 5 tasks:
* The first task requires you to add 1 into a. a is now \left\{1\right\}.
* The second task requires you to add 2 into a. a is now \left\{1, 2\right\}.
* The third task asks you a question with x = 1, k = 1 and s = 3. Taking both 1 and 2 as v satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 3. Because 2 ⊕ 1 = 3 > 1 ⊕ 1 = 0, 2 is the answer to this task.
* The fourth task asks you a question with x = 1, k = 1 and s = 2. Only v = 1 satisfies 1 ∣ GCD(1, v) and 1 + v ≤ 2, so 1 is the answer to this task.
* The fifth task asks you a question with x = 1, k = 1 and s = 1. There are no elements in a that satisfy the conditions, so we report -1 as the answer to this task.
Submitted Solution:
```
from heapq import heappush as push, heappop as pop, heapify
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b != 0:
a, b = a % b, a
return b
def main():
q = int(input())
a = []
for i in range(q):
task = [int(_) for _ in input().split()]
# print(task)
if task[0] == 1:
a.append(task[1])
else:
x, k, s = task[1:]
max_xor = -1
# print(a)
for v in a:
# print(k, gcd(x, v), s, x + v, x ^ v, max_xor)
if k % gcd(x, v) == 0 and x + v <= s:
xor = x ^ v
if xor > max_xor:
max_xor = xor
v_ = v
if max_xor == -1:
print(-1)
else:
print(v_)
if __name__ == '__main__':
main()
```
No
| 93,234 |
Provide tags and a correct Python 2 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
for i in arr:
stdout.write(str(i)+' ')
stdout.write('\n')
range = xrange # not for python 3.0+
n,m,s=in_arr()
d=[[] for i in range(n+1)]
for i in range(m):
u,v=in_arr()
d[u].append(v)
good=[False]*(n+1)
q=[s]
good[s]=True
while q:
x=q.pop()
for i in d[x]:
if not good[i]:
good[i]=True
q.append(i)
arr=[]
for i in range(1,n+1):
if not good[i]:
vis=list(good)
q=[i]
c=1
vis[i]=1
while q:
x=q.pop()
for j in d[x]:
if not vis[j]:
vis[j]=True
q.append(j)
c+=1
arr.append((c,i))
arr.sort(reverse=True)
ans=0
for _,i in arr:
if not good[i]:
good[i]=True
q=[i]
ans+=1
while q:
x=q.pop()
for j in d[x]:
if not good[j]:
good[j]=1
q.append(j)
pr_num(ans)
```
| 93,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
from collections import defaultdict
import sys
sys.setrecursionlimit(1000000)
n, m, s = map(int, input().split())
s = s - 1
def read_graph():
g = defaultdict(list)
for _ in range(m):
(u, v) = map(lambda x: int(x) - 1, input().split())
if v != s:
g[u].append(v)
return g
G = read_graph()
vis = defaultdict(lambda: False)
topo = []
def dfs(u):
# print(u)
for v in G[u]:
if not vis[v]:
vis[v] = True
dfs(v)
topo.append(u)
for i in range(n):
if not vis[i]:
vis[i] = True
dfs(i)
vis.clear()
vis[s] = True
dfs(s)
ans = 0
for i in topo[::-1]:
if not vis[i]:
vis[i] = True
ans += 1
dfs(i)
print(ans)
```
| 93,236 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
import sys
n, m, s = map(int, input().split())
adj = [[] for _ in range(500005)]
ar = []
vis = [0] * 500005
sys.setrecursionlimit(6000)
def dfs(s):
vis[s] = 1
for i in range(len(adj[s])):
if(vis[adj[s][i]] == 0):
dfs(adj[s][i])
ar.append(s)
for i in range(m):
u, v = map(int, input().split())
adj[u].append(v)
dfs(s)
for i in range(n):
if(vis[i + 1] == 0):
dfs(i + 1)
res = 0
vis = [0] * 500005
for i in range(n - 1, -1, -1):
if(vis[ar[i]] == 0):
if(s != ar[i]):
res += 1
dfs(ar[i])
print(res)
```
| 93,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
from __future__ import print_function
from queue import Queue
from random import shuffle
import sys
import math
import os.path
sys.setrecursionlimit(100000)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def toMapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
# SORT
def sortId(arr):
return sorted(range(len(arr)), key=lambda k: arr[k])
# MAIN
n,m,s = ni()
s -= 1
adj = [[] for _ in range(n)]
for i in range(m):
u,v = nio(-1)
if (v != s):
adj[u].append(v)
stack = []
visited= [False]*n
def dfs(x):
global visited
global stack
visited[x] = True
for y in adj[x]:
if not visited[y]:
dfs(y)
stack.append(x)
for i in range(n):
if not visited[i]:
dfs(i)
# log(adj)
# log(visited)
# log(stack)
count = -1
def loang(x):
global visited
visited[x] = False
for y in adj[x]:
if visited[y]:
loang(y)
for x in stack[::-1]:
if visited[x]:
count += 1
loang(x)
print(count)
```
| 93,238 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
import sys
sys.setrecursionlimit(10**4)
from collections import deque
n, m, s = map(int, input().split())
s -= 1
graph = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
graph[u-1].append(v-1)
seen = [False]*n
li = deque()
def visit(node, t=True):
if not seen[node]:
seen[node] = True
for c_node in graph[node]:
visit(c_node)
if t:
li.appendleft(node)
for i in range(n):
visit(i)
seen = [False]*n
cnt = 0
visit(s, False)
for i in list(li):
if seen[i]:
continue
visit(i, False)
cnt += 1
print(cnt)
```
| 93,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
from collections import defaultdict
import sys
def dfs(u):
avail[u] = False
for v in g[u]:
if avail[v]:
dfs(v)
topo.append(u)
sys.setrecursionlimit(6000)
n, m, s = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
g[u - 1].append(v - 1)
avail, topo = [True] * n, []
for i,a in enumerate(avail):
if a:
dfs(i)
avail, res = [True] * n, 0
dfs(s - 1)
for i in reversed(topo):
if avail[i]:
res += 1
dfs(i)
print(res)
```
| 93,240 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
def main():
import sys
sys.setrecursionlimit(10**5)
from collections import deque
n, m, s = map(int, input().split())
s -= 1
graph = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
graph[u-1].append(v-1)
seen = [False]*n
li = deque()
def visit(node):
if not seen[node]:
seen[node] = True
for c_node in graph[node]:
visit(c_node)
li.appendleft(node)
def visit2(node):
if not seen[node]:
seen[node] = True
for c_node in graph[node]:
visit2(c_node)
for i in range(n):
visit(i)
seen = [False]*n
cnt = 0
visit2(s)
for i in li:
if seen[i]:
continue
visit2(i)
cnt += 1
print(cnt)
if __name__ == "__main__":
try:
main()
except:
print('error!')
exit(0)
```
| 93,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m, s = map(int, input().split())
s -= 1
adj = [[] for _ in range(n)]
rev = [[] for _ in range(n)]
for u, v in (map(int, input().split()) for _ in range(m)):
adj[u-1].append(v-1)
rev[v-1].append(u-1)
group = [-1]*n
g = 0
group[s] = g
stack = [s]
while stack:
v = stack.pop()
for dest in adj[v]:
if group[dest] != -1:
continue
group[dest] = g
stack.append(dest)
for i in range(n):
if group[i] != -1:
continue
g += 1
group[i] = g
stack = [i]
while stack:
v = stack.pop()
for dest in adj[v]:
if group[dest] == 0 or group[dest] == g:
continue
group[dest] = g
stack.append(dest)
print(len(set(group)) - 1)
```
| 93,242 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Tags: dfs and similar, graphs, greedy
Correct Solution:
```
import sys
sys.setrecursionlimit(100001)
from collections import *
d=deque()
def dfs2(start):
vis[start]=1
for child in adj[start]:
if vis[child]==0:
dfs2(child)
def dfs(start):
vis[start]=1
for child in adj[start]:
if vis[child]==0:
dfs(child)
d.appendleft(start)
n,m,k=map(int,input().split())
adj=[]
for i in range(n):
adj.append([])
for i in range(m):
a,b=map(int,input().split())
adj[a-1].append(b-1)
vis=[0]*n
for i in range(n):
if vis[i]==0:
dfs(i)
vis=[0]*n
dfs2(k-1)
cnt=0
for i in d:
if vis[i]==0:
dfs2(i)
cnt+=1
print(cnt)
```
| 93,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
import sys
def d(u):
rt[u] = False
for v in q[u]:
if rt[v]:
d(v)
topo.append(u)
sys.setrecursionlimit(6000)
n, m, s = map(int, input().split())
q = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
q[u - 1].append(v - 1)
rt, topo = [True] * n, []
for i,a in enumerate(rt):
if a:
d(i)
rt, res = [True] * n, 0
d(s - 1)
for i in reversed(topo):
if rt[i]:
res += 1
d(i)
print(res)
```
Yes
| 93,244 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
import sys
n, m, s = map(int, input().split())
adj = [[] for i in range(500005)]
ar = []
vis = [0 for i in range(500005)]
sys.setrecursionlimit(6000)
def dfs(s):
vis[s] = 1
for i in range(len(adj[s])):
if(vis[adj[s][i]] == 0):
dfs(adj[s][i])
ar.append(s)
for i in range(m):
u, v = map(int, input().split())
adj[u].append(v)
dfs(s)
for i in range(n):
if(vis[i + 1] == 0):
dfs(i + 1)
res = 0
vis = [0 for i in range(500005)]
for i in range(n - 1, -1, -1):
if(vis[ar[i]] == 0):
if(s != ar[i]):
res += 1
dfs(ar[i])
print(res)
```
Yes
| 93,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
from collections import deque
import heapq
import sys
input = sys.stdin.readline
def bfs1(s):
q = deque()
q.append(s)
visit = [0] * (n + 1)
visit[s] = 1
while q:
i = q.popleft()
for j in G[i]:
if not visit[j]:
visit[j] = 1
q.append(j)
return visit
def bfs2(t):
q = deque()
q.append(t)
visit0 = [0] * (n + 1)
visit0[t] = 1
c = 0
while q:
i = q.popleft()
c += 1
for j in G[i]:
if not visit0[j] and not visit[j]:
visit0[j] = 1
q.append(j)
return c
def bfs3(t):
q = deque()
q.append(t)
visit[t] = 1
while q:
i = q.popleft()
for j in G[i]:
if not visit[j]:
visit[j] = 1
q.append(j)
return
n, m, s = map(int, input().split())
G = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = map(int, input().split())
G[u].append(v)
visit = bfs1(s)
h = []
for i in range(1, n + 1):
if not visit[i]:
c = bfs2(i)
heapq.heappush(h, (-c, i))
ans = 0
while h:
c, i = heapq.heappop(h)
if not visit[i]:
ans += 1
bfs3(i)
print(ans)
```
Yes
| 93,246 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
import sys
N = 5000 + 5
adj = [[] for i in range(N)]
mark = [0 for i in range(N)]
topo = []
sys.setrecursionlimit(6000)
#fin = open("999E.inp", "r")
#fou = open("999E.out", "w")
#n, m, s = map(int, fin.readline().split())
n, m, s = map(int, input().split())
for i in range(m):
#u, v = map(int, fin.readline().split())
u, v = map(int, input().split())
adj[u].append(v)
def topoSort(u):
mark[u] = 1
for j in range(len(adj[u])):
v = adj[u][j]
if (mark[v] == 0): topoSort(v)
topo.append(u)
def dfs(u):
mark[u] = 1
for j in range(len(adj[u])):
v = adj[u][j]
if (mark[v] == 0): dfs(v)
for i in range(1, n+1):
if (mark[i] == 0):
topoSort(i)
topo.reverse()
for i in range(1, n+1):
mark[i] = 0
dfs(s)
res = 0
for i in range(n):
v = topo[i]
if (mark[v] == 0):
res += 1
dfs(v)
#fou.write(str(res))
print(res)
```
Yes
| 93,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
def parent(i,par,ind):
pp=i
if(par[i]==ind):
return 1
i=par[i]
while(1):
if(par[i]==ind):
return 1
if(par[i]==i):
par[i]=ind
break
i=par[i]
if(i==pp):
break
return 0
n,m,ind=[int(x) for x in input().split()]
par={}
for i in range(1,n+1):
par[i]=i
for i in range(m):
p,q=[int(x) for x in input().split()]
par[q]=p
c=0
for i in range(1,n+1):
#print(c,par)
if(i==ind):
continue
if(parent(i,par,ind)):
par[i]=ind
else:
c+=1
par[i]=ind
print(c)
```
No
| 93,248 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
from collections import deque
import sys
input = sys.stdin.readline
def bfs1(s):
q = deque()
q.append(s)
group[s] = s
while q:
i = q.popleft()
for j in G[i]:
if not group[j]:
unite(s, j)
group[j] = s
q.append(j)
return
def bfs2(t):
q = deque()
q.append(t)
group[t] = t
while q:
i = q.popleft()
for j in G[i]:
if not group[j]:
unite(t, j)
group[j] = t
q.append(j)
elif not group[j] == s:
unite(i, j)
return
def get_root(s):
v = []
while not s == root[s]:
v.append(s)
s = root[s]
for i in v:
root[i] = s
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
if rank[s] == rank[t]:
rank[rs] += 1
if rank[s] >= rank[t]:
root[rt] = rs
size[rs] += size[rt]
else:
root[rs] = rt
size[rt] += size[rs]
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
n, m, s = map(int, input().split())
G = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = map(int, input().split())
G[u].append(v)
group = [0] * (n + 1)
root = [i for i in range(n + 1)]
rank = [1 for _ in range(n + 1)]
size = [1 for _ in range(n + 1)]
bfs1(s)
for i in range(2, n + 1):
if not group[i]:
bfs2(i)
ans = len(set([get_root(i) for i in range(1, n + 1)])) - 1
print(ans)
```
No
| 93,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
n,m,s=map(int,input().split())
s-=1
edge=[[]for _ in range(n)]
to=[0]*n
for _ in range(m):
a,b=map(int,input().split())
a-=1
b-=1
to[b]+=1
edge[a].append(b)
to=[(to[i],i)for i in range(n)]
to.sort()
visited=[False]*n
visited[s]=True
queue=[s]
for node in queue:
for mode in edge[node]:
if visited[mode]:continue
visited[mode]=True
queue.append(mode)
ans=0
for _,node in to:
if visited[node]:continue
visited[node]=True
ans+=1
queue=[node]
for node in queue:
for mode in edge[node]:
if visited[mode]:continue
visited[mode]=True
queue.append(mode)
print(ans)
```
No
| 93,250 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n cities and m roads in Berland. Each road connects a pair of cities. The roads in Berland are one-way.
What is the minimum number of new roads that need to be built to make all the cities reachable from the capital?
New roads will also be one-way.
Input
The first line of input consists of three integers n, m and s (1 ≤ n ≤ 5000, 0 ≤ m ≤ 5000, 1 ≤ s ≤ n) — the number of cities, the number of roads and the index of the capital. Cities are indexed from 1 to n.
The following m lines contain roads: road i is given as a pair of cities u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). For each pair of cities (u, v), there can be at most one road from u to v. Roads in opposite directions between a pair of cities are allowed (i.e. from u to v and from v to u).
Output
Print one integer — the minimum number of extra roads needed to make all the cities reachable from city s. If all the cities are already reachable from s, print 0.
Examples
Input
9 9 1
1 2
1 3
2 3
1 5
5 6
6 1
1 8
9 8
7 1
Output
3
Input
5 4 5
1 2
2 3
3 4
4 1
Output
1
Note
The first example is illustrated by the following:
<image>
For example, you can add roads (6, 4), (7, 9), (1, 7) to make all the cities reachable from s = 1.
The second example is illustrated by the following:
<image>
In this example, you can add any one of the roads (5, 1), (5, 2), (5, 3), (5, 4) to make all the cities reachable from s = 5.
Submitted Solution:
```
import sys
input = sys.stdin.readline
def kosaraju(g):
# 1. For each vertex u of the graph, mark u as unvisited. Let l be empty.
size = len(g)
vis = [False]*size # vertexes that have been visited
l = [0]*size
T = size
t = [[] for _ in range(size)] # transpose graph
def visit(u):
nonlocal T, vis
stk = []
if not vis[u]: stk.append(u)
while stk:
x = stk[-1]
if not vis[x]:
vis[x] = True
for y in g[x]:
if not vis[y]:
stk.append(y)
t[y].append(x)
else:
stk.pop()
T -= 1
l[T] = x
# 2. For each vertex u of the graph do visit(u)
for u in range(len(g)):
visit(u)
c = [0]*size
def assign(u, root):
nonlocal vis
stk = [u]
while stk:
x = stk.pop()
if vis[x]:
vis[x] = False
c[x] = root
for y in t[x]:
stk.append(y)
# 3: For each element u of l in order, do assign(u, u)
for u in l:
assign(u, u)
return c
def condensed(g,s):
c = kosaraju(g)
size = len(g)
label = 0
new_c = [-1]*(size)
ref = dict()
for i in range(size):
if c[i] in ref:
new_c[i] = ref[c[i]]
else:
ref[c[i]] = label
new_c[i] = label
label += 1
new_g = [set() for _ in range(label)]
for i in range(size):
new_i = new_c[i]
for j in g[i]:
new_j = new_c[j]
if new_i != new_j:
new_g[new_i].add(new_j)
return new_g, new_c[s]
n,m,s = map(int,input().split())
G = [[] for _ in range(n)]
for _ in range(m):
x,y = map(int,input().split())
G[x-1].append(y-1)
G,s = condensed(G,s-1)
indeg = [0]*len(G)
for i in range(len(G)):
for j in G[i]:
indeg[j] += 1
ans = 0
for i in range(len(G)):
if indeg[i] == 0:
ans += 1
if indeg[s] == 0:
ans -= 1
print(ans)
```
No
| 93,251 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
class UnionFind:
def __init__(self, n):
self.g = [i for i in range(n)]
self.n = n
def whichclass(self, x):
if self.g[x]==x:
return x
else:
self.g[x] = self.whichclass(self.g[x])
return self.g[x]
def union(self, x, y):
cx = self.whichclass(x)
cy = self.whichclass(y)
if cx==cy:
return
minc = min(cx, cy)
maxc = max(cx, cy)
self.g[maxc] = minc
def __getitem__(self, x):
return self.whichclass(x)
N, M = map(int, input().split())
UF = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
a, b = a-1, b-1
UF.union(a, b)
count = [0 for i in range(N)]
for i in range(N):
count[UF[i]] = 1
print(sum(count)-1)
```
| 93,252 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
N, M = map(int, input().split())
F = [[] for _ in range(N)]
P = [0] * N
for i in range(M):
A, B = map(int, input().split())
F[A-1].append(B-1)
F[B-1].append(A-1)
c=0
l = []
for i in range(N):
if P[i] == 0:
c+=1
l.append(i)
while len(l)>0:
p=l.pop()
P[p] = c
for j in F[p]:
if P[j] == 0:
l.append(j)
print(c-1)
```
| 93,253 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
N,M=map(int,input().split())
road=[[] for _ in range(N)]
for i in range(M):
a,b=map(int,input().split())
road[a-1].append(b-1)
road[b-1].append(a-1)
ischecked=[0]*(N)
ans=0
for i in range(N):
if ischecked[i]==1:
continue
ischecked[i]=1
q=[i]
while q:
now=q.pop()
nex=road[now]
for j in nex:
if ischecked[j]!=0:
continue
q.append(j)
ischecked[j]=1
ans+=1
print(ans-1)
```
| 93,254 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
N, M = map(int, input().split())
cla = [i for i in range(N)]
count = set()
def root(a):
change = []
while cla[a] != a:
change.append(a)
a = cla[a]
for i in change:
cla[i] = a
return a
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
if root(a) != root(b):
cla[root(b)] = root(a)
for i in range(N):
count |= {root(i)}
print(len(count) - 1)
```
| 93,255 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
N, M = map(int, input().split())
P = [-1 for i in range(N)]
def par(a):
L = []
while P[a] >= 0:
L.append(a)
a = P[a]
for l in L:
P[l] = a
return a
def unite(a, b):
if par(a) != par(b):
if P[par(b)] >= P[par(a)]:
if P[par(b)] == P[par(a)]: P[par(a)] -= 1
P[par(b)] = par(a)
else:
P[par(a)] = par(b)
ans = N - 1
for _ in range(M):
a, b = map(int, input().split())
a, b = a-1, b-1
if par(a) == par(b): continue
unite(a, b)
ans -= 1
print(ans)
```
| 93,256 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
N,M = map(int,input().split())
par = [0]+[-1 for i in range(N)]
def find(x):
if par[x] == -1:
return x
else:
par[x] = find(par[x]) #経路圧縮
return par[x]
def same(x,y):
return find(x) == find(y)
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
for i in range(M):
a,b = map(int,input().split())
unite(a,b)
print(len([i for i in par if i == -1])-1)
```
| 93,257 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
import sys
input=sys.stdin.readline
n,m=map(int,input().split())
def unite(x,y):
if same(x,y)==False:
rx=root(x);ry=root(y)
if rank[rx]>rank[ry]:
parent[ry]=rx
size[rx]+=size[ry]
else:
parent[rx]=ry
size[ry]+=size[rx]
if rank[rx]==rank[ry]:
rank[ry]+=1
def root(x):
if x!=parent[x]:
return root(parent[x])
return x
def same(x,y):
return root(x)==root(y)
parent=list(range(n))
rank=[0]*n
size=[1]*n
for i in range(m):
a,b=map(int,input().split())
unite(a-1,b-1)
kind=set()
for i in range(n):
r=parent[root(i)]
kind.add(r)
print(len(kind)-1)
```
| 93,258 |
Provide a correct Python 3 solution for this coding contest problem.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
"Correct Solution:
```
import sys
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
N, M = map(int, input().split())
uf = UnionFind(N)
for _ in range(M):
a, b = map(lambda x: int(x) - 1, sys.stdin.readline().split())
uf.union(a, b)
print(sum(p < 0 for p in uf.parents) - 1)
```
| 93,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
from collections import deque
N, M = map(int, input().split())
AB = [[] for _ in range(N)]
for _ in range(M):
a,b = map(lambda x: int(x)-1, input().split())
AB[a].append(b)
AB[b].append(a)
visited = [0] * N
ans = []
for i in range(N):
if visited[i]:
continue
group = [i]
d = deque(AB[i])
while d:
s = d.popleft()
if visited[s]:
continue
visited[s] = 1
group.append(s)
for k in AB[s]:
d.append(k)
ans.append(len(group))
print(len(ans)-1)
```
Yes
| 93,260 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def same(x, y):
return find(x) == find(y)
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return
if par[x] > par[y]:
x, y = y, x
par[x] += par[y]
par[y] = x
N, M = map(int, input().split())
par = [-1 for i in range(N)]
for i in range(M):
a, b = map(int, input().split())
unite(a - 1, b - 1)
cnt = -1
num = {0}
for i in par:
if i <= -1:
cnt += 1
print(cnt)
```
Yes
| 93,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
#Union Find
#xの根を求める
def find(x):
if par[x] < 0:
return x
else:
tank = []
while par[x] >= 0:
tank.append(x)
x = par[x]
for elt in tank:
par[elt] = x
return x
#xとyの属する集合の併合
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
#sizeの大きいほうがx
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
n,m = map(int, input().split())
par = [-1] * n
for i in range(m):
a,b = map(int,input().split())
unite(a-1,b-1)
ans = set([])
for i in range(n):
ans.add(find(i))
print(len(ans)-1)
```
Yes
| 93,262 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
n,m=map(int,input().split())
par=[i for i in range(n)]
size=[1]*n
def find(x):
if par[x]==x:
return x
else:
par[x]=find(par[x])
return par[x]
def union(a,b):
x=find(a)
y=find(b)
if x!=y:
if size[x]<size[y]:
par[x]=par[y]
size[y]+=size[x]
else:
par[y]=par[x]
size[x]+=size[y]
else:
return
for i in range(m):
a,b=map(int,input().split())
union(a-1,b-1)
ans={find(i) for i in range(n)}
print(len(ans)-1)
```
Yes
| 93,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
N, M = (int(i) for i in input().split())
AB = [input().split() for i in range(M)]
route = set()
for ab in AB:
route.add(ab[0])
route.add(ab[1])
if(len(route) == N):
break
print(N - len(route))
```
No
| 93,264 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
from typing import List, Dict
MAX_N = 10 ** 5
visited = [False] * MAX_N
cluster = [0] * MAX_N
edges: Dict[int, List[int]] = {}
def dfs(node: int, cluster_num: int) -> None:
cluster[node] = cluster_num
visited[node] = True
if node not in edges:
return
for v in edges[node]:
if visited[v]:
continue
dfs(v, cluster_num)
def connect_cities(node_num: int, edge_num: int) -> int:
i = 0
for s in range(node_num):
if visited[s]:
continue
dfs(s, i)
i += 1
return i - 1
if __name__ == "__main__":
N, M = map(int, input().split())
for _ in range(M):
a, b = map(int, input().split())
a, b = a - 1, b - 1
edges.setdefault(a, [])
edges[a].append(b)
edges.setdefault(b, [])
edges[b].append(a)
ans = connect_cities(N, M)
print(ans)
```
No
| 93,265 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
def s(way):
global w
global wc
for i in way:
c[i] = 1
if wc[i] == 0:
wc[i] =1
for j in w[i]:
c[j]=1
s(w[j])
n,m = map(int,input().split())
a = [0 for i in range(m)]
b = [0 for i in range(m)]
w = [[] for i in range(n)]
wc = [0 for i in range(n)]
c = [0 for i in range(n)]
for i in range(m):
a[i],b[i] = map(int,input().split())
w[a[i]-1].append(b[i]-1)
w[b[i]-1].append(a[i]-1)
ans =-1
for i in range(n):
if c[i] == 0:
c[i] = 1
wc[i] = 1
ans += 1
s(w[i])
print(ans)
```
No
| 93,266 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N cities numbered 1 through N, and M bidirectional roads numbered 1 through M. Road i connects City A_i and City B_i.
Snuke can perform the following operation zero or more times:
* Choose two distinct cities that are not directly connected by a road, and build a new road between the two cities.
After he finishes the operations, it must be possible to travel from any city to any other cities by following roads (possibly multiple times).
What is the minimum number of roads he must build to achieve the goal?
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M \leq 100,000
* 1 \leq A_i < B_i \leq N
* No two roads connect the same pair of cities.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1
:
A_M B_M
Output
Print the answer.
Example
Input
3 1
1 2
Output
1
Submitted Solution:
```
n,m=map(int,input().split())
if n>m:
print(n-1-m)
else:
print(0)
```
No
| 93,267 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
s=SI()
n=len(s)
n2=n//2
ans=n2*(n2+1)+n%2*(n2+1)
#print(ans)
rem=0
for i,c in enumerate(s):
if c=="1":continue
ans-=(rem+1)//2
if rem%2==0 and i%2==0:ans-=1
if (i-rem)%2==0:rem+=1
print(ans)
main()
```
| 93,268 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
"""
なるべく各操作における奇数文字目に1をいれる
最後にたす数は確定
左端が1の時、最初に入れない理由はない
最初に必要な1を全部入れない理由、あるか？
なさそう
あとはどう0を入れていくか
1のうち、いくつが空数番目・いくつが奇数番目にいあるかを考える
0を入れると、それ以降の1の偶奇がひっくり返る
差は高々1
右端は毎回ひっくり返されるので考えなくていい
2番目は、右端で1回だけ延長できる
3番目は、2回延長できる
"""
T = input()
ans = 0
onum = 0
for i in T:
if i == "1":
onum += 1
ans += (onum+1)//2
odd = []
eve = []
nodd = 0
neve = 0
#print (ans)
for i in range(len(T)-1,-1,-1):
if T[i] == "0":
odd.append(nodd)
eve.append(neve)
nodd = 0
neve = 0
else:
if i % 2 == 0:
nodd += 1
else:
neve += 1
#print (odd,eve)
ans += nodd * ( len(T) - onum )
#print (ans)
for i in range(len(odd)):
now = 0
if i == 0:
now += len(odd)//2 * eve[i]
now += (len(odd) - len(odd)//2) * odd[i]
else:
now += (len(odd)-i)//2 * eve[i]
now += ((len(odd)-i) - (len(odd)-i)//2 ) * odd[i]
rem = len(odd) - ( (len(odd)-i)//2 +(len(odd)-i) - (len(odd)-i)//2)
now += rem * max(eve[i],odd[i])
#print (now)
ans += now
print (ans)
```
| 93,269 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
T=input()
n=len(T)
i=r=a=0
for c in T:k=i-r;r+=(~k&1)*(c=='0');a+=(i//2-k//2+(~k&1)*(n-i))*(c=="1");i+=1
print(a)
```
| 93,270 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
T = read().rstrip().decode()
T
def f(n, r, l, z):
# 長さnの1が座標 r から l へと移動する。
# z回立ち止まることが許されている。
# 獲得スコアの最大値は？
if n % 2 == 0:
move = r - l + z
return (move + 1) * (n // 2)
if r == l and r % 2 == 0:
# ev, od, ev, od, evで固定
k = (n - 1) // 2
move = r - l + z
return (move + 1) * k
# 各地点に1回ずつ立ち寄りつつ、奇数のところでz回足踏みできる
ev = (r // 2) - ((l - 1) // 2)
od = (r - l + 1) - ev
od += z
k = (n - 1) // 2
return ev * k + od * (k + 1)
Z = T.count('0')
one = 0
to = 0
answer = 0
for i, x in enumerate(T, 1):
if x == '0':
if one:
answer += f(one, i - 1, to, Z)
one = 0
Z -= 1
continue
to += 1
one += 1
if one:
answer += f(one, i, to, Z)
def f(n):
# '1' * n から減らしたときのスコア
# ただし、最初は除く
ret = 0
for i in range(0, n, 2):
ret += (n - i)
ret -= (n + 1) // 2
return ret
n = T.count('1')
answer += f(n)
print(answer)
```
| 93,271 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
t = input()
before_is_zero = True
keeped_ones = 0
n0 = 0
ones = [0] * int(1e5+1) # (number of zeros before 1, is_odd)
ones_index = 0
for i, x in enumerate(t):
if x == '0':
n0 += 1
before_is_zero = True
elif x == '1':
if before_is_zero:
ones[ones_index] = (n0, (i+1)%2)
ones_index += 1
before_is_zero = False
else:
keeped_ones += 1
ones_index -= 1
before_is_zero = True
if before_is_zero:
if len(ones) > 0:
ones = ones[:-1]
ans = keeped_ones * n0
for i in range(ones_index):
n0_before, is_odd = ones[i]
ans += (n0_before + is_odd)//2 + (n0 - n0_before)
ans += (keeped_ones + (ones_index+1)//2) * (keeped_ones + ones_index//2 + 1)
print(ans)
```
| 93,272 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
t = input()
s = t.replace("0", "")
q = len(s) # 1の数
n = len(t)
ps = [None]*(q+1)
c = 0
j = 0
for tmp in t:
if tmp=="1":
ps[j] = c
j += 1
c = 0
else:
c += 1
ps[-1] = c
dp = [0] * q # インデックスqの1までのベストな配置のときの奇数の個数
pp = [0] * (q+1) # 上を実現するために使うpsの個数
if not dp:
print(0)
else:
dp[0] = 1
j = 1 # j : トータルのインデックス(1はじまり)
for i in range(1,q):
j += 1
p = ps[i]
if j%2:
pp[i] = 0
dp[i] = dp[i-1] + 1
elif p:
pp[i] = 1
j += 1
dp[i] = dp[i-1] + 1
else:
pp[i] = 0
dp[i] = dp[i-1]
if q%2==0:
ans = q//2 * (q//2 + 1)
else:
ans = q//2 * (q//2 + 1) + q//2 + 1
# 1をすべて入れたあとに得られる利得
# ppを前から順にいれていく
j = 0
for i in range(q+1):
j += 1
if not pp[i]:
continue
# 0を１個いれる
j += 1
ans += dp[i]
if j%2:
ans += (q-i-1) // 2
else:
ans += (q-i-1) // 2 + (q-i-1)%2
# 残りのpsを後ろから順にいれていく
o = 0 # 現時点より後ろの(jを0としたときの)奇数番目の1の個数
e = 0 # 現時点より後ろの(jを0としたときの)偶数番目の1の個数
j = q + sum(pp) # 現在地のインデックス(1はじまり)
for i in range(q, 0, -1):
num = ps[i] - pp[i]
if num>0:
ans += dp[i-1] * num
if num%2==0:
ans += (num//2)*o + (num//2)*e
else:
ans += (num//2)*o + (num//2)*e + (e if j%2==0 else o)
e,o = o,e
j -= 1
if pp[i-1]:
j -= pp[i-1]
e += 1
else:
o, e = 1 + e, o
# 最初の0を入れる
num = ps[0] - pp[0]
if num%2==0:
ans += (num//2)*o + (num//2)*e
else:
ans += (num//2)*o + (num//2)*e + e if j%2==0 else o
print(ans)
```
| 93,273 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
t = input()
before_is_zero = True
n0 = 0
n1 = 0
seq1 = 0
ans = 0
for i, x in enumerate(t):
if x == '0':
n0 += 1
before_is_zero = True
elif before_is_zero:
tmp_add = -(n0 - (i+1)%2)//2
ans += tmp_add
n1 += 1
before_is_zero = False
else:
ans -= tmp_add
n1 += 1
seq1 += 1
before_is_zero = True
ans += (n1 - seq1) * n0 + ((n1+1)//2) * (n1//2 + 1)
print(ans)
```
| 93,274 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
"Correct Solution:
```
def solve(t):
res = 0
length = 0
n = len(t)
used = [0] * n
# insert 1 greedy
for i in range(n):
if t[i] == "1":
length += 1
res += (length + 1) // 2
used[i] = 1
# insert 0 greedy
cnt_temp = 0
for i in range(n):
if used[i]:
cnt_temp += 1
elif cnt_temp % 2 == 1:
# add 0 if it is 2, 4, 6 th
cnt_temp += 1
length += 1
res += (length + 1) // 2
used[i] = 1
cnt_unused = n - sum(used)
switch_count = 0
# split by other 0
st = 0
cnt_1_even = 0
cnt_1_odd = 0
for i in range(n):
if used[i] == 0:
switched = (switch_count + 1) // 2
non_switched = cnt_unused - switched
res += cnt_1_even * non_switched + cnt_1_odd * switched
st = i + 1
switch_count += 1
cnt_1_even = 0
cnt_1_odd = 0
if t[i] == "1":
if (i - st) % 2 == 0:
cnt_1_even += 1
else:
cnt_1_odd += 1
# add last
switched = (switch_count + 1) // 2
non_switched = cnt_unused - switched
res += cnt_1_even * non_switched + cnt_1_odd * switched
return res
def main():
t = input()
res = solve(t)
print(res)
def test():
assert solve("1101") == 5
assert solve("0111101101") == 26
if __name__ == "__main__":
test()
main()
```
| 93,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
import math
import re
T=input()
x=0
Td=T
d = len(re.sub(r'0', '', Td))
x += math.ceil((d/2+1)*d/2)
spT = T.split('0')
lenT = list(map(len, spT))
tmpX = math.ceil(d/2)
bT = 0
aT = d
tmp = ''
for i in range(len(spT) - 1):
tmp += spT[i]
bT += lenT[i]
aT -= lenT[i]
if bT % 2==1:
bT += 1
if aT % 2 ==1:
tmpX += 1
x += tmpX
tmp += '0'
else:
tmp +='+'
tmp += spT[-1]
spT = tmp.split('+')
vT =[]
aT = bT
bT = 0
odT = 0
tmpOd = True
for i in range(len(spT)):
od = len(re.sub(r'0', '', spT[i][0 if tmpOd else 1::2]))
ev = len(re.sub(r'0', '', spT[i][1 if tmpOd else 0::2]))
odT += od
vT.append(od - ev)
if len(spT[i]) %2 == 1:
tmpOd = not tmpOd
for i in reversed(range(1, len(spT))):
odT = odT - vT[i]
x += odT
vT[i-1] -= vT[i]
print(x)
```
Yes
| 93,276 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
T=input()
i=r=a=k=0
for c in T:a+=(i//2-k//2+(~k&1)*(len(T)-i))*(c=="1");i+=1;k-=(~k&1)*(c=='0')-1
print(a)
```
Yes
| 93,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
T=input()
i=r=a=k=0
for c in T:a+=(i//2-k//2+(~k&1)*(len(T)-i))*(c=="1");i+=1;k-=(~k&1)*(c=='0')-1;
print(a)
```
Yes
| 93,278 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
from itertools import groupby, accumulate
def solve(t):
grp = [(c, len(list(itr))) for c, itr in groupby(t)]
even_ones = 0
zeros_splitting_odd_ones = [0]
for c, cnt in grp:
if c == '1':
if cnt % 2 == 0:
even_ones += cnt
else:
even_ones += cnt - 1
zeros_splitting_odd_ones.append(0)
else:
zeros_splitting_odd_ones[-1] += cnt
# 初期状態で加算されるか
ad = int(zeros_splitting_odd_ones[0] % 2 == 0)
is_added_init = [ad]
for cnt in zeros_splitting_odd_ones[1:]:
ad ^= (cnt % 2) ^ 1
is_added_init.append(ad)
is_added_init.pop()
acc_added_init = list(accumulate(reversed(is_added_init))) # 自分より右で、初期状態で足される1の数
acc_added_init.reverse()
odd_ones = len(is_added_init)
ans = 0
if odd_ones > 0:
# 先頭の0を全て除くまでのスコア
zso = zeros_splitting_odd_ones[0]
zso1 = zso // 2
zso0 = zso - zso1
ans += acc_added_init[0] * zso0
ans += (odd_ones - acc_added_init[0]) * zso1
# 1に挟まれた0を1箇所1つずつ残して全て除くまでのスコア
ad = int(zeros_splitting_odd_ones[0] % 2 == 0)
for i in range(1, odd_ones):
zso = zeros_splitting_odd_ones[i] - 1
zso1 = zso // 2
zso0 = zso - zso1
fixed_ones = i
right_ones = odd_ones - fixed_ones
ans += fixed_ones * zso
if ad:
# 除外中の0区間の次の"1"が初期状態で足されるなら、区間を操作する直前にも足される
ans += acc_added_init[i] * zso0
ans += (right_ones - acc_added_init[i]) * zso1
else:
# 除外中の0区間の次の"1"が初期状態で足されないなら、区間を操作する直前には足される
ans += (right_ones - acc_added_init[i]) * zso0
ans += acc_added_init[i] * zso1
ad ^= zso % 2
# 末尾の0を全て除くまでのスコア
ans += zeros_splitting_odd_ones[-1] * odd_ones
# 1に挟まれた0を右から除いていくまでのスコア
for i in range(1, odd_ones):
left_ones = odd_ones - i
right_ones = i
ans += left_ones + (right_ones + 1) // 2
# 1だけの列を1つずつ除いていくスコア
all_ones = odd_ones + even_ones
ao1 = all_ones // 2
ao0 = all_ones - ao1
ans += (ao0 * (ao0 + 1) + ao1 * (ao1 + 1)) // 2
# 0を除いている間の、偶数個の1によるスコア
all_zeros = len(t) - all_ones
ans += all_zeros * (even_ones // 2)
return ans
t = input()
print(solve(t))
```
Yes
| 93,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
s = input()
T = [int(s[i]) for i in range(len(s))]
x = 0
count_0 = s.count('0')
for i in range(count_0):
for j in range(0,len(T),2):
x += T[j]
T.remove(0)
count_1 = len(s)-count_0
if count_1 % 2 == 0:
m = count_1 // 2
x += m**2 + m
else:
m = (count_1+1) //2
x += m**2
print(x)
```
No
| 93,280 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
n = input()
zero_list = []
z_count = 0
ans = 0
for i in range(len(n)):
if n[i] == "0":
z_count += 1
else:
zero_list.append(z_count)
z_count = 0
zero_list.append(z_count)
ones = n.count("1")
for i in range(1,ones+1):
if i % 2 == 0:
ans += i//2
else:
ans += i//2 + 1
test_string = ""
if ones % 2 == 0:
test_string = "10"*(ones//2)
else:
test_string = "10"*(ones//2)+"1"
test_length = len(test_string)
test_string = int(test_string,base=2)
#flip 0 to 1
for i in range(test_length):
if bin(test_string)[test_length-i+1] == "0" and zero_list[i] > 0:
print("xor")
print(int("1" * (test_length-i), base=2))
test_string = test_string ^ int("1" * (test_length-i), base=2)
zero_list[i] -= 1
ans += bin(test_string).count("1")
#remove more than 1 zeros
for i in range(test_length):
while zero_list[i] > 1:
zero_list[i] -= 2
ans += bin(test_string)[0:i].count("1") * 2 + test_length - i
#remove last zero from back
for i in range(test_length-1,-1,-1):
if zero_list[i] == 1:
test_string = test_string ^ int("1" * (test_length-i), base=2)
zero_list[i] -= 1
ans += bin(test_string).count("1")
print(ans)
```
No
| 93,281 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
t = input()
one = t.count("1")
zero = t.count("0")
if one % 2 == 0:
tmp = one // 2
ans = tmp * (tmp + 1)
else:
tmp = one // 2
ans = (tmp + 1) ** 2
even_one = 0
before_zero = []
zero_cnt = 0
for i, num in enumerate(t):
if i % 2 == 0 and num == "1":
even_one += 1
before_zero.append(zero_cnt)
if num == "0":
zero_cnt += 1
for i, num in enumerate(t):
if num == "0":
continue
if (i + before_zero[i]) % 2 == 0:
ans += (zero - before_zero[i]) + (before_zero[i]) // 2
else:
ans += (before_zero[i] + 1) // 2
print(ans)
```
No
| 93,282 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi has an empty string S and a variable x whose initial value is 0.
Also, we have a string T consisting of `0` and `1`.
Now, Takahashi will do the operation with the following two steps |T| times.
* Insert a `0` or a `1` at any position of S of his choice.
* Then, increment x by the sum of the digits in the odd positions (first, third, fifth, ...) of S. For example, if S is `01101`, the digits in the odd positions are `0`, `1`, `1` from left to right, so x is incremented by 2.
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `0` and `1`.
Input
Input is given from Standard Input in the following format:
T
Output
Print the maximum possible final value of x in a sequence of operations such that S equals T in the end.
Examples
Input
1101
Output
5
Input
0111101101
Output
26
Submitted Solution:
```
n =input()
while True:
for i in range(len(n)):
if i>n:
break
if i<n:
v=n[0::2]
b=sum(v)
b=b+1
print(b)
```
No
| 93,283 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
n = int(input())
xl = []
for i in range(n):
x,l = map(int,input().split())
xl.append([x+l,x-l])
xl.sort()
ans = -10**10
count = 0
for j in range(n):
if xl[j][1] >= ans:
count +=1
ans = xl[j][0]
print(count)
```
| 93,284 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
n=int(input())
xls=[list(map(int,input().split())) for _ in range(n)]
lrs=sorted((x-l,x+l) for x,l in xls)
res=0
most_r=lrs[0][0]
for l,r in lrs:
if l>=most_r:
res+=1
most_r=r
elif most_r>r:
most_r=r
print(res)
```
| 93,285 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
n = int(input())
count = 0
X = []
for i in range(n):
x,l = map(int, input().split())
X.append((x+l,x-l))
X.sort()
coord = -float('inf')
for i in X:
if i[1] >= coord:
count += 1
coord = i[0]
print(count)
```
| 93,286 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
n=int(input())
XL=[]
for i in range(n):
x,l=map(int,input().split())
XL.append([x-l,x,x+l])
ans=0
cur=-float("inf")
XL.sort(key=lambda x:x[2])
for x1,x2,x3 in XL:
if x1>=cur:
cur=x3
ans+=1
else:
continue
print(ans)
```
| 93,287 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
N = int(input())
arms = []
for i in range(0, N):
X, L = map(int, input().split(" "))
arms.append((X + L, X - L))
arms.sort()
ans = 0
coord = -float('inf')
for arm in arms:
if arm[1] >= coord:
ans += 1
coord = arm[0]
print(ans)
```
| 93,288 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
N = int(input())
P = []
for _ in range(N):
x,l = list(map(int, input().split()))
P.append((x+l, x-l))
P.sort()
rw = P[0][0]
ans = 1
for i in range(1,N):
r,l = P[i]
if l < rw:
continue
else:
rw = r
ans += 1
print(ans)
```
| 93,289 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
N = int(input())
q = []
for i in range(N):
x,l = map(int, input().split())
q.append((x+l, x-l))
q.sort()
cnt = 0
INF = float("inf")
b = -INF
for r,l in q:
if l >= b:
b = r
else:
cnt += 1
print(N-cnt)
```
| 93,290 |
Provide a correct Python 3 solution for this coding contest problem.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
"Correct Solution:
```
n=int(input())
d=[]
for i in range(n):
x,l=map(int,input().split())
d.append((x-l,x+l))
d.sort()
ans=1
chk=d[0][1]
for i in d:
if i[0]>=chk:
ans+=1
chk=i[1]
else:
chk=min(chk,i[1])
print(ans)
```
| 93,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
n=int(input())
XL=[list(map(int,input().split())) for i in range(n)]
Range=[[x-l,x+l] for x,l in XL]
ans,end=0,-1*(10**9+1)
Range.sort(key=lambda X: X[1])
for R in Range:
if end > R[0]:
continue
ans += 1
end=R[1]
print(ans)
```
Yes
| 93,292 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
N, *XL = map(int, open(0).read().split())
XL = sorted((x + l, x - l) for x, l in zip(*[iter(XL)] * 2))
curr = -float("inf")
ans = 0
for right, left in XL:
if left >= curr:
curr = right
ans += 1
print(ans)
```
Yes
| 93,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
n=int(input())
L=[]
for i in range(n):
x,l=map(int,input().split())
L.append([x-l,x+l])
L.sort(key=lambda x:x[1])
ans=1
bef=L[0][1]
for i in range(1,n):
if bef<=L[i][0]:
bef=L[i][1]
ans+=1
print(ans)
```
Yes
| 93,294 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
n=int(input())
l=[]
for i in range(n):
x,y=map(int,input().split())
l.append([x-y,x+y])
count=0
l=sorted(l)
l=l[::-1]
count+=1
now=l[0][0]
for i in range(1,n):
if now>=l[i][1]:
now=l[i][0]
count+=1
else:
pass
print(count)
```
Yes
| 93,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
N=int(input())
X=[]
L=[]
XA=[]
XB=[]
Q=[0]*N
for i in range(N):
x,l=map(int,input().split())
X.append(x)
L.append(l)
for i in range(N):
XA.append(X[i]-L[i])
XB.append(X[i]+L[i])
S=sorted(list(zip(XA,XB)))
cnt=0
#print(S)
i=0
while i<N-1:
if i==0:
if S[i][1]>S[i+1][0]:
cnt=cnt+1
if S[i][1]<=S[i+1][1]:
S.pop(i+1)
else:
S.pop(i)
i=i+1
else:
i=i+1
else:
if S[i-1][1]>S[i][0]:
cnt=cnt+1
S.pop(i)
i=i+1
else:
i=i+1
#print(cnt)
#print(S)
print(N-cnt)
```
No
| 93,296 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
n = int(input())
xl = [list(map(int, input().split())) for _ in range(n)]
xx = []
count = 0
for x in xl:
xx.append([x[0] - x[1], x[0] + x[1]])
if n != 2:
for i in range(1, n-1):
if xx[i][0] < xx[i-1][1] and xx[i][1] > xx[i+1][0]:
count += 1
print(n-count)
else:
if xx[1][0] < xx[0][1]:
print(1)
else:
print(2)
```
No
| 93,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
import sys
from pprint import pprint
def solve(n, x, l):
r = []
for i in range(n):
r.append((x[i], l[i]))
x_pre = -1
l_pre = 0
remove = 0
for x_i, l_i in sorted(r):
if x_pre == -1:
x_pre = x_i
l_pre = l_i
continue
# print("pre", x_pre, l_pre)
# print(x_i, l_i)
if x_i - l_i < x_pre + l_pre:
# 先まで届かない方を残す
if x_pre + l_pre > x_i + l_i:
x_pre = x_i
l_pre = x_i
remove += 1
print(n - remove)
if __name__ == '__main__':
n = int(sys.stdin.readline().strip())
x = [0] * n
l = [0] * n
for i in range(n):
x[i], l[i] = map(int, sys.stdin.readline().strip().split(" "))
solve(n, x, l)
```
No
| 93,298 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a factory, there are N robots placed on a number line. Robot i is placed at coordinate X_i and can extend its arms of length L_i in both directions, positive and negative.
We want to remove zero or more robots so that the movable ranges of arms of no two remaining robots intersect. Here, for each i (1 \leq i \leq N), the movable range of arms of Robot i is the part of the number line between the coordinates X_i - L_i and X_i + L_i, excluding the endpoints.
Find the maximum number of robots that we can keep.
Constraints
* 1 \leq N \leq 100,000
* 0 \leq X_i \leq 10^9 (1 \leq i \leq N)
* 1 \leq L_i \leq 10^9 (1 \leq i \leq N)
* If i \neq j, X_i \neq X_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 L_1
X_2 L_2
\vdots
X_N L_N
Output
Print the maximum number of robots that we can keep.
Examples
Input
4
2 4
4 3
9 3
100 5
Output
3
Input
2
8 20
1 10
Output
1
Input
5
10 1
2 1
4 1
6 1
8 1
Output
5
Submitted Solution:
```
n = int(input())
x = []
for i in range(n):
x1, y1=[int(i) for i in input().split()]
x.append([x1, y1])
x.sort()
remove = 0
stocks = 0
for k in range(n - 1):
if k+1+stocks < n:
if (x[k + 1 + stocks][0] - x[k][0]) < x[k][1] + x[k + 1][1]:
remove += 1
x[k + 1][0] = -1
if n - 2 > k:
stocks += 1
k -=1
else:
stocks=0
print (n -remove)
```
No
| 93,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.