message stringlengths 2 19.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 322 108k | cluster float64 15 15 | __index_level_0__ int64 644 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pavel loves grid mazes. A grid maze is an n Γ m rectangle maze where each cell is either empty, or is a wall. You can go from one cell to another only if both cells are empty and have a common side.
Pavel drew a grid maze with all empty cells forming a connected area. That is, you can go from any empty cell to any other one. Pavel doesn't like it when his maze has too little walls. He wants to turn exactly k empty cells into walls so that all the remaining cells still formed a connected area. Help him.
Input
The first line contains three integers n, m, k (1 β€ n, m β€ 500, 0 β€ k < s), where n and m are the maze's height and width, correspondingly, k is the number of walls Pavel wants to add and letter s represents the number of empty cells in the original maze.
Each of the next n lines contains m characters. They describe the original maze. If a character on a line equals ".", then the corresponding cell is empty and if the character equals "#", then the cell is a wall.
Output
Print n lines containing m characters each: the new maze that fits Pavel's requirements. Mark the empty cells that you transformed into walls as "X", the other cells must be left without changes (that is, "." and "#").
It is guaranteed that a solution exists. If there are multiple solutions you can output any of them.
Examples
Input
3 4 2
#..#
..#.
#...
Output
#.X#
X.#.
#...
Input
5 4 5
#...
#.#.
.#..
...#
.#.#
Output
#XXX
#X#.
X#..
...#
.#.#
Submitted Solution:
```
n, m, k = map(int, input().split())
maze = [["#"]*(m+2)]+[list("#"+input()+"#") for i in range(n)]+[["#"]*(m+2)]
steps = [[0,1],[0,-1],[1,0],[-1,0]]
empty = -k
x, y = None, None
for i in range(n+2):
empty += maze[i].count(".")
for j in range(m+2):
if maze[i][j] == ".":
x, y = i, j
break
stack = [(x,y)]
while empty:
(x, y) = stack.pop()
for dx, dy in steps:
if maze[x+dx][y+dy] == ".":
stack.append((x+dx, y+dy))
maze[x][y] = "v"
empty -= 1
for row in maze[1:-1]:
print("".join(row[1:-1]).replace(".","X").replace("v","."))
``` | instruction | 0 | 27,797 | 15 | 55,594 |
No | output | 1 | 27,797 | 15 | 55,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pavel loves grid mazes. A grid maze is an n Γ m rectangle maze where each cell is either empty, or is a wall. You can go from one cell to another only if both cells are empty and have a common side.
Pavel drew a grid maze with all empty cells forming a connected area. That is, you can go from any empty cell to any other one. Pavel doesn't like it when his maze has too little walls. He wants to turn exactly k empty cells into walls so that all the remaining cells still formed a connected area. Help him.
Input
The first line contains three integers n, m, k (1 β€ n, m β€ 500, 0 β€ k < s), where n and m are the maze's height and width, correspondingly, k is the number of walls Pavel wants to add and letter s represents the number of empty cells in the original maze.
Each of the next n lines contains m characters. They describe the original maze. If a character on a line equals ".", then the corresponding cell is empty and if the character equals "#", then the cell is a wall.
Output
Print n lines containing m characters each: the new maze that fits Pavel's requirements. Mark the empty cells that you transformed into walls as "X", the other cells must be left without changes (that is, "." and "#").
It is guaranteed that a solution exists. If there are multiple solutions you can output any of them.
Examples
Input
3 4 2
#..#
..#.
#...
Output
#.X#
X.#.
#...
Input
5 4 5
#...
#.#.
.#..
...#
.#.#
Output
#XXX
#X#.
X#..
...#
.#.#
Submitted Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
#from fractions import *
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
def bfs(adj,s,vis):
vis[s]=True
qu=[s]
a=[]
while(len(qu)!=0):
e=qu.pop(0)
a.append(e)
for i in adj[e]:
if(vis[i]!=True):
qu.append(i)
vis[i]=True
return vis
r,c,k=value()
a=[]
for i in range(r):
a.append(list(input()))
adj=defaultdict(list)
for i in range(r):
for j in range(c):
if(a[i][j]=='.'):
if(i+1<r and a[i+1][j]=='.'):
adj[(i,j)].append((i+1,j))
adj[(i+1,j)].append((i,j))
if(j+1<c and a[i][j+1]=='.'):
adj[(i,j)].append((i,j+1))
adj[(i,j+1)].append((i,j))
toBeX=set()
#print(adj)
for i in adj:
vis=defaultdict(bool)
vis[i]=True
t_adj={i:adj[i] for i in adj}
t_adj[i]=[]
c=0
for j in t_adj:
if(vis[j]==False):
if(c==2):
break
c+=1
vis=bfs(t_adj,j,vis)
if(c==1):
toBeX.add(i)
k-=1
else:
vis[i]=False
if(k==0):
break
for i in toBeX:
a[i[0]][i[1]]='X'
for i in a:
print(*i,sep="")
``` | instruction | 0 | 27,798 | 15 | 55,596 |
No | output | 1 | 27,798 | 15 | 55,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pavel loves grid mazes. A grid maze is an n Γ m rectangle maze where each cell is either empty, or is a wall. You can go from one cell to another only if both cells are empty and have a common side.
Pavel drew a grid maze with all empty cells forming a connected area. That is, you can go from any empty cell to any other one. Pavel doesn't like it when his maze has too little walls. He wants to turn exactly k empty cells into walls so that all the remaining cells still formed a connected area. Help him.
Input
The first line contains three integers n, m, k (1 β€ n, m β€ 500, 0 β€ k < s), where n and m are the maze's height and width, correspondingly, k is the number of walls Pavel wants to add and letter s represents the number of empty cells in the original maze.
Each of the next n lines contains m characters. They describe the original maze. If a character on a line equals ".", then the corresponding cell is empty and if the character equals "#", then the cell is a wall.
Output
Print n lines containing m characters each: the new maze that fits Pavel's requirements. Mark the empty cells that you transformed into walls as "X", the other cells must be left without changes (that is, "." and "#").
It is guaranteed that a solution exists. If there are multiple solutions you can output any of them.
Examples
Input
3 4 2
#..#
..#.
#...
Output
#.X#
X.#.
#...
Input
5 4 5
#...
#.#.
.#..
...#
.#.#
Output
#XXX
#X#.
X#..
...#
.#.#
Submitted Solution:
```
import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
n,m,k=I()
l=[];x=y=-1;s=0
for i in range(n):
l.append(list(input().strip().replace('.','X')))
if x==-1 and 'X' in l[-1] :
x=i;y=l[-1].index('X')
s+=l[-1].count("X")
q=[[x,y]];ct=s
while q:
x,y=q.pop()
l[x][y]='.'
ct-=1
if ct==k:
break
if x>0 and l[x-1][y]=='X':
q.append([x-1,y])
if y>0 and l[x][y-1]=='X':
q.append([x,y-1])
if x<n-1 and l[x+1][y]=='X':
q.append([x+1,y])
if y<m-1 and l[x][y+1]=='X':
q.append([x,y+1])
for i in range(n):
print("".join(l[i]))
``` | instruction | 0 | 27,799 | 15 | 55,598 |
No | output | 1 | 27,799 | 15 | 55,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snow Queen told Kay to form a word "eternity" using pieces of ice. Kay is eager to deal with the task, because he will then become free, and Snow Queen will give him all the world and a pair of skates.
Behind the palace of the Snow Queen there is an infinite field consisting of cells. There are n pieces of ice spread over the field, each piece occupying exactly one cell and no two pieces occupying the same cell. To estimate the difficulty of the task Kay looks at some squares of size k Γ k cells, with corners located at the corners of the cells and sides parallel to coordinate axis and counts the number of pieces of the ice inside them.
This method gives an estimation of the difficulty of some part of the field. However, Kay also wants to estimate the total difficulty, so he came up with the following criteria: for each x (1 β€ x β€ n) he wants to count the number of squares of size k Γ k, such that there are exactly x pieces of the ice inside.
Please, help Kay estimate the difficulty of the task given by the Snow Queen.
Input
The first line of the input contains two integers n and k (1 β€ n β€ 100 000, 1 β€ k β€ 300) β the number of pieces of the ice and the value k, respectively. Each of the next n lines contains two integers xi and yi ( - 109 β€ xi, yi β€ 109) β coordinates of the cell containing i-th piece of the ice. It's guaranteed, that no two pieces of the ice occupy the same cell.
Output
Print n integers: the number of squares of size k Γ k containing exactly 1, 2, ..., n pieces of the ice.
Example
Input
5 3
4 5
4 6
5 5
5 6
7 7
Output
10 8 1 4 0
Submitted Solution:
```
def UpperBound(A, key):
left = -1
right = len(A)
count=0
while right > left + 1:
middle = (left + right) // 2
if A[middle]==key:
count=count+1
if A[middle] > key:
right = middle
else:
left = middle
return right
def LowerBound(A, key):
left = -1
right = len(A)
while right > left + 1:
middle = (left + right) // 2
if A[middle] >= key:
right = middle
else:
left = middle
return right
x=input().split()
n=int(x[0])
k=int(x[1])
x=[]
y=[]
for i in range(n):
mas=input().split()
x.append(int(mas[0]))
y.append(int(mas[1]))
xmax=max(x)+k-1
xmin=min(x)-k+1
ymax=max(y)+k-1
ymin=min(y)-k+1
max_numb=[0]*n
for ii in range(abs(ymax)):
for jj in range(abs(xmax)-k+1):
s=0
for i in range(k):
for j in range(k):
nn=UpperBound(x,xmin+j+jj)
n1=LowerBound(x,xmin+j+jj)
for u in range(n1,nn):
if (xmin+j+jj==x[u])and (ymax-i==y[u]):
s=s+1
if s!=0:
max_numb[s-1]=max_numb[s-1]+1
ymax=ymax-1
for i in range(n):
max_numb[i]=str(max_numb[i])
print(" ".join(max_numb))
``` | instruction | 0 | 27,925 | 15 | 55,850 |
No | output | 1 | 27,925 | 15 | 55,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have n Γ n square grid and an integer k. Put an integer in each cell while satisfying the conditions below.
* All numbers in the grid should be between 1 and k inclusive.
* Minimum number of the i-th row is 1 (1 β€ i β€ n).
* Minimum number of the j-th column is 1 (1 β€ j β€ n).
Find the number of ways to put integers in the grid. Since the answer can be very large, find the answer modulo (10^{9} + 7).
<image> These are the examples of valid and invalid grid when n=k=2.
Input
The only line contains two integers n and k (1 β€ n β€ 250, 1 β€ k β€ 10^{9}).
Output
Print the answer modulo (10^{9} + 7).
Examples
Input
2 2
Output
7
Input
123 456789
Output
689974806
Note
In the first example, following 7 cases are possible.
<image>
In the second example, make sure you print the answer modulo (10^{9} + 7). | instruction | 0 | 28,355 | 15 | 56,710 |
Tags: combinatorics, dp, math
Correct Solution:
```
def main():
n, k = map(int, input().split())
MOD = 10**9 + 7
Comb = [None] * (n + 1)
dp = [[None] * (n + 1) for i in range(n+1)]
for i in range(1, n + 1):
Comb[i] = [1] + [(Comb[i-1][j-1] + Comb[i-1][j]) % MOD for j in range(1, i)] + [1]
def powgen(base):
cur = 1
while True:
yield cur
cur = cur * base % MOD
gen, gen_1 = powgen(k), powgen(k - 1)
kpower = [next(gen) for i in range(n + 1)]
k1power = [next(gen_1) for i in range(n + 1)]
dp[1][0] = (kpower[n] - k1power[n] + MOD) % MOD
for i in range(1, n+1): dp[1][i] = kpower[n-i]
for r in range(2, n + 1): # row remaining
# c means col incompleted
dp[r] = [(dp[r-1][c] * k1power[c] * (kpower[n-c]-k1power[n-c]) +
kpower[n-c] * sum([dp[r-1][c-i] * Comb[c][i] * k1power[c-i] for i in range(1, c+1)])) % MOD
for c in range(n+1)]
# input 250 1000000000
return dp[n][n]
print(main())
``` | output | 1 | 28,355 | 15 | 56,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have n Γ n square grid and an integer k. Put an integer in each cell while satisfying the conditions below.
* All numbers in the grid should be between 1 and k inclusive.
* Minimum number of the i-th row is 1 (1 β€ i β€ n).
* Minimum number of the j-th column is 1 (1 β€ j β€ n).
Find the number of ways to put integers in the grid. Since the answer can be very large, find the answer modulo (10^{9} + 7).
<image> These are the examples of valid and invalid grid when n=k=2.
Input
The only line contains two integers n and k (1 β€ n β€ 250, 1 β€ k β€ 10^{9}).
Output
Print the answer modulo (10^{9} + 7).
Examples
Input
2 2
Output
7
Input
123 456789
Output
689974806
Note
In the first example, following 7 cases are possible.
<image>
In the second example, make sure you print the answer modulo (10^{9} + 7). | instruction | 0 | 28,359 | 15 | 56,718 |
Tags: combinatorics, dp, math
Correct Solution:
```
def main():
n, k = map(int, input().split())
MOD = 10**9 + 7
Comb = [None] * (n + 1)
dp = [[None] * (n + 1) for i in range(n+1)]
for i in range(1, n + 1):
Comb[i] = [1] + [(Comb[i-1][j-1] + Comb[i-1][j]) % MOD for j in range(1, i)] + [1]
def powgen(base):
cur = 1
while True:
yield cur
cur = cur * base % MOD
gen, gen_1 = powgen(k), powgen(k - 1)
kpower = [next(gen) for i in range(n + 1)]
k1power = [next(gen_1) for i in range(n + 1)]
dp[1][0] = (kpower[n] - k1power[n] + MOD) % MOD
for i in range(1, n+1): dp[1][i] = kpower[n-i]
for r in range(2, n + 1): # row remaining
# c means col incompleted
for c in range(n+1):
dp[r][c] = (dp[r-1][c] * k1power[c] * (kpower[n-c]-k1power[n-c]) + \
kpower[n-c] * sum([dp[r-1][c-i] * Comb[c][i] * k1power[c-i] for i in range(1, c+1)])) % MOD
# input 250 1000000000
return dp[n][n]
print(main())
``` | output | 1 | 28,359 | 15 | 56,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have n Γ n square grid and an integer k. Put an integer in each cell while satisfying the conditions below.
* All numbers in the grid should be between 1 and k inclusive.
* Minimum number of the i-th row is 1 (1 β€ i β€ n).
* Minimum number of the j-th column is 1 (1 β€ j β€ n).
Find the number of ways to put integers in the grid. Since the answer can be very large, find the answer modulo (10^{9} + 7).
<image> These are the examples of valid and invalid grid when n=k=2.
Input
The only line contains two integers n and k (1 β€ n β€ 250, 1 β€ k β€ 10^{9}).
Output
Print the answer modulo (10^{9} + 7).
Examples
Input
2 2
Output
7
Input
123 456789
Output
689974806
Note
In the first example, following 7 cases are possible.
<image>
In the second example, make sure you print the answer modulo (10^{9} + 7). | instruction | 0 | 28,361 | 15 | 56,722 |
Tags: combinatorics, dp, math
Correct Solution:
```
def main():
n, k = map(int, input().split())
MOD = 10**9 + 7
Comb = [None] * (n + 1)
dp = [[None] * (n + 1) for i in range(n+1)]
for i in range(1, n + 1):
Comb[i] = [1] + [(Comb[i-1][j-1] + Comb[i-1][j]) % MOD for j in range(1, i)] + [1]
def powgen(base):
cur = 1
while True:
yield cur
cur = cur * base % MOD
gen, gen_1 = powgen(k), powgen(k - 1)
kpower = [next(gen) for i in range(n + 1)]
k1power = [next(gen_1) for i in range(n + 1)]
dp[1][0] = (kpower[n] - k1power[n] + MOD) % MOD
for i in range(1, n+1): dp[1][i] = kpower[n-i]
for r in range(2, n + 1): # row remaining
for c in range(n+1): # c means col incompleted
dp[r][c] = (dp[r-1][c] * k1power[c] * (kpower[n-c]-k1power[n-c]) + \
kpower[n-c] * sum([dp[r-1][c-i] * Comb[c][i] * k1power[c-i] for i in range(1, c+1)])) % MOD
# input 250 1000000000
return dp[n][n]
print(main())
``` | output | 1 | 28,361 | 15 | 56,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,385 | 15 | 56,770 |
Tags: data structures, dsu, implementation
Correct Solution:
```
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
blocks={}
lavablocks={}
def newlava():
for _ in range(q):
r,c = [int(x) for x in input().split()]
getlavablocks=blocks.get((r,c),False)
if r==1:
newposx=2
else:
newposx=1
lavprev=blocks.get((newposx,c-1),False)
lavcur=blocks.get((newposx,c),False)
lavnext=blocks.get((newposx,c+1),False)
if getlavablocks:
del blocks[(r,c)]
freq=lavablocks.get((newposx,c-1),0)
if freq:
if freq==1:
del lavablocks[(newposx,c-1)]
else:
lavablocks[(newposx,c-1)]=freq-1
freq=lavablocks.get((r,c),0)
if freq:
if freq==1:
del lavablocks[(r,c)]
else:
lavablocks[(r,c)]=freq-1
freq=lavablocks.get((newposx,c),0)
if freq:
if freq==1:
del lavablocks[(newposx,c)]
else:
lavablocks[(newposx,c)]=freq-1
freq=lavablocks.get((r,c),0)
if freq:
if freq==1:
del lavablocks[(r,c)]
else:
lavablocks[(r,c)]=freq-1
freq=lavablocks.get((newposx,c+1),0)
if freq:
if freq==1:
del lavablocks[(newposx,c+1)]
else:
lavablocks[(newposx,c+1)]=freq-1
freq=lavablocks.get((r,c),0)
if freq:
if freq==1:
del lavablocks[(r,c)]
else:
lavablocks[(r,c)]=freq-1
else:
blocks[(r,c)]=True
if lavprev:
freq=lavablocks.get((newposx,c-1),0)
lavablocks[(newposx,c-1)]=freq+1
freq=lavablocks.get((r,c),0)
lavablocks[(r,c)]=freq+1
if lavcur:
freq=lavablocks.get((newposx,c),0)
lavablocks[(newposx,c)]=freq+1
freq=lavablocks.get((r,c),0)
lavablocks[(r,c)]=freq+1
if lavnext:
freq=lavablocks.get((newposx,c+1),0)
lavablocks[(newposx,c+1)]=freq+1
freq=lavablocks.get((r,c),0)
lavablocks[(r,c)]=freq+1
#print(len(lavablocks))
if lavablocks:
yield 'No'
else:
yield 'Yes'
#print(blocks,lavablocks)
if __name__ == '__main__':
t,q= [int(x) for x in input().split()]
ans = newlava()
print(*ans,sep='\n')
``` | output | 1 | 28,385 | 15 | 56,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,386 | 15 | 56,772 |
Tags: data structures, dsu, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 12 18:05:29 2021
@author: _ForeRunner_
"""
n,q=map(int,input().split())
a=[[0 for j in range(n+2)] for i in range(2)]
x=0
for i in range(q):
n1,m=map(int,input().split())
n1-=1
if a[n1][m]==0:
a[n1][m]=1
if n1==1:
n1=0
else:
n1=1
if a[n1][m+1]==1:
x+=1
if a[n1][m]==1:
x+=1
if a[n1][m-1]==1:
x+=1
else:
a[n1][m]=0
if n1==1:
n1=0
else:
n1=1
if a[n1][m-1]==1:
x-=1
if a[n1][m]==1:
x-=1
if a[n1][m+1]==1:
x-=1
if x==0:
print("Yes")
else:
print("No")
``` | output | 1 | 28,386 | 15 | 56,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,387 | 15 | 56,774 |
Tags: data structures, dsu, implementation
Correct Solution:
```
from sys import stdin
read = stdin.readline
di1, di2 = [-1, -1, -1], [1, 1, 1]
dj1, dj2 = [-1, 0, 1], [-1, 0, 1]
def main():
global di1, di2, dj1, dj2
n, Q = map(int, read().strip().split())
maze = [[False for _ in range(n)], [False for _ in range(n)]]
blocked_cnt = 0
for q in range(Q):
i, j = map(int, read().strip().split())
i-=1;j-=1
have_lava = maze[i][j]
ad_cnt = 0
if i == 1:
for k in range(len(di1)):
d_i = i + di1[k]
d_j = j + dj1[k]
#print(d_i, d_j)
if 0<=d_i<2 and 0<=d_j<n and maze[d_i][d_j]: ad_cnt += 1
else:
for k in range(len(di1)):
d_i = i + di2[k]
d_j = j + dj2[k]
#print(d_i, d_j)
if 0<=d_i<2 and 0<=d_j<n and maze[d_i][d_j]: ad_cnt += 1
if have_lava: blocked_cnt-=ad_cnt
else: blocked_cnt+=ad_cnt
if blocked_cnt == 0: print("Yes")
else: print("No")
maze[i][j] = not maze[i][j]
main()
``` | output | 1 | 28,387 | 15 | 56,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,388 | 15 | 56,776 |
Tags: data structures, dsu, implementation
Correct Solution:
```
n,q= map(int, input().split())
L = [[0 for i in range(n)] for i in range(2)]
blocks=0
for t in range(q):
r,c= map(int, input().split())
r=r-1
c=c-1
if L[r][c]==0:
col=(r+1)%2
for j in range(-1,2):
if c+j<=n-1 and c+j>=0 and L[col][c+j]==1:
blocks+=1
L[r][c]=1
else:
col=(r+1)%2
for j in range(-1,2):
if c+j<=n-1 and c+j>=0 and L[col][c+j]==1:
blocks-=1
L[r][c]=0
if blocks==0:
print("YES")
else:
print("NO")
``` | output | 1 | 28,388 | 15 | 56,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,389 | 15 | 56,778 |
Tags: data structures, dsu, implementation
Correct Solution:
```
import sys
from collections import defaultdict
n,q=map(int,sys.stdin.readline().split())
z,blocks=True,0
dic=defaultdict(int)
for _ in range(q):
a,b=map(int,sys.stdin.readline().split())
if dic[(a,b)]==0:
dic[(a,b)]=1
if dic[(a-1,b-1)]==1:
blocks+=1
z=False
if dic[(a+1,b)]==1:
blocks+=1
z=False
if dic[(a-1,b)]==1:
blocks+=1
z=False
if dic[(a+1,b+1)]==1:
blocks+=1
z=False
if dic[(a-1,b+1)]==1:
blocks+=1
z=False
if dic[(a+1,b-1)]==1:
blocks+=1
z=False
if z:
print("YES")
else:
print("NO")
else:
dic[(a,b)]=0
if dic[(a+1,b-1)]==1:
blocks-=1
if dic[(a-1,b+1)]==1:
blocks-=1
if dic[(a-1,b-1)]==1:
blocks-=1
if dic[(a+1,b)]==1:
blocks-=1
if dic[(a-1,b)]==1:
blocks-=1
if dic[(a+1,b+1)]==1:
blocks-=1
if blocks==0:
z=True
if z:
print("YES")
else:
print("NO")
#print(blocks,'blocks')
``` | output | 1 | 28,389 | 15 | 56,779 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,390 | 15 | 56,780 |
Tags: data structures, dsu, implementation
Correct Solution:
```
def RL(): return list(map(int, input().split()))
from sys import stdin
n, q = RL()
s1 = set()
s2 = set()
block = 0
for i in range(q):
x, y = map( int, stdin.readline().rstrip().split() )
if x==1:
if y in s1:
s1.remove(y)
for ny in range(-1, 2):
if y+ny in s2:
block-=1
else:
for ny in range(-1, 2):
if y+ny in s2:
block+=1
s1.add(y)
else:
if y in s2:
s2.remove(y)
for ny in range(-1, 2):
if y+ny in s1:
block-=1
else:
for ny in range(-1, 2):
if y+ny in s1:
block+=1
s2.add(y)
if block==0:
print("Yes")
else:
print("No")
``` | output | 1 | 28,390 | 15 | 56,781 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,391 | 15 | 56,782 |
Tags: data structures, dsu, implementation
Correct Solution:
```
n, q = map(int, input().split())
lava = [[0 for j in range(n)] for i in range(2)]
blockedPair = 0
while q > 0:
q -= 1
x, y = map(lambda s: int(s)-1, input().split())
delta = +1 if lava[x][y] == 0 else -1
lava[x][y] = 1 - lava[x][y]
for dy in range(-1, 2):
if y + dy >= 0 and y + dy < n and lava[1-x][y+dy] == 1:
blockedPair += delta
if blockedPair == 0:
print('Yes')
else:
print('No')
``` | output | 1 | 28,391 | 15 | 56,783 |
Provide tags and a correct Python 3 solution for this coding contest problem.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again. | instruction | 0 | 28,392 | 15 | 56,784 |
Tags: data structures, dsu, implementation
Correct Solution:
```
N, Q = map(int, input().split())
walls, lavas = 0, set()
for q in range(Q):
r, c = map(lambda s: int(s) - 1, input().split())
nr = (r + 1) % 2
for dc in range(-1, 2):
nc = c + dc
if (nr, nc) in lavas:
# If there wasn't lava in (r, c) before, then now a wall is created
# If there was lava in (r, c), then now a wall is removed
walls += (1 if (r, c) not in lavas else -1)
# Add/remove at the end of the for loop to not trip up the ternary operator
lavas.add((r, c)) if (r, c) not in lavas else lavas.remove((r, c))
print("Yes" if walls == 0 else "No")
``` | output | 1 | 28,392 | 15 | 56,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n,q = [int(x) for x in input().split()]
dp = [[0 for i in range(n)] for j in range(2)]
state = [[0 for i in range(n)] for j in range(2)]
cnt = 0
for _ in range(q):
r,c = [int(x) for x in input().split()]
r-=1
c-=1
state[r][c] = (state[r][c]+1)%2
if (state[r][c]==0):
dp[(r+1)%2][c]-=1
if c!=0:
dp[(r+1)%2][c-1]-=1
if c!=n-1:
dp[(r+1)%2][c+1]-=1
cnt-=dp[r][c]
# f = 0
# dp[(r+1)%2][c].remove('U')
# if dp[(r+1)%2][c]==[]:
# f = 1
# if c!=0:
# dp[(r+1)%2][c-1].remove('R')
# if (dp[(r+1)%2][c-1]==[]):
# f = 1
# if c!=n-1:
# dp[(r+1)%2][c+1].remove('L')
# if dp[(r+1)%2][c+1]==[]:
# f = 1
# if f==1:
# cnt-=1
else:
dp[(r+1)%2][c]+=1
if c!=0:
dp[(r+1)%2][c-1]+=1
if c!=n-1:
dp[(r+1)%2][c+1]+=1
cnt+=dp[r][c]
# f= 0
# dp[(r+1)%2][c].append('U')
# if dp[(r+1)%2][c]!=[]:
# f = 1
# if c!=0:
# dp[(r+1)%2][c-1].append('R')
# if dp[(r+1)%2][c-1]!=[]:
# f = 1
# if c!=n-1:
# dp[(r+1)%2][c+1].append('L')
# if dp[(r+1)%2][c+1]!=[]:
# f = 1
# if len(dp[r][c])!=0:
# f = 1
# if f==1:
# cnt+=1
if cnt==0:
print("YES")
else:
print("NO")
``` | instruction | 0 | 28,393 | 15 | 56,786 |
Yes | output | 1 | 28,393 | 15 | 56,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n,q = map(int,input().split())
A = [0 for i in range(n)]
B = [0 for i in range(n)]
x = 0
for _ in range(q):
r,c = map(int,input().split())
if(r==1):
if(A[c-1]==0):
A[c-1] = 1
x+=B[c-1]
if(c-1>0):
x+=B[c-2]
if(c-1<n-1):
x+=B[c]
else:
A[c-1] = 0
x-=B[c-1]
if(c-1>0):
x-=B[c-2]
if(c-1<n-1):
x-=B[c]
else:
if(B[c-1]==0):
B[c-1] = 1
x+=A[c-1]
if(c-1>0):
x+=A[c-2]
if(c-1<n-1):
x+=A[c]
else:
B[c-1] = 0
x-=A[c-1]
if(c-1>0):
x-=A[c-2]
if(c-1<n-1):
x-=A[c]
if(x==0):
print("Yes")
else:
print("No")
``` | instruction | 0 | 28,394 | 15 | 56,788 |
Yes | output | 1 | 28,394 | 15 | 56,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n, q = map(int, input().split())
last = 10**6
lava = set()
def paas(r, c, lava):
dr = 1 if r == 2 else 2
s = 0
for dc in [-1, 0, 1]:
if (dr, c+dc) in lava:
s += 1
return s
points = 0
for _ in range(q):
r,c = map(int, input().split())
if (r, c) in lava:
lava.remove((r, c))
points -= paas(r, c, lava)
else:
lava.add((r, c))
points += paas(r, c, lava)
if points == 0:
print('yes')
else:
print('no')
``` | instruction | 0 | 28,395 | 15 | 56,790 |
Yes | output | 1 | 28,395 | 15 | 56,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
import math
class Read:
@staticmethod
def string():
return input()
@staticmethod
def int():
return int(input())
@staticmethod
def list(sep=' '):
return input().split(sep)
@staticmethod
def list_int(sep=' '):
return list(map(int, input().split(sep)))
def solve():
n, q = Read.list_int()
l = {
1: {},
2: {}
}
for i in range(n):
l[1][i + 1] = False
l[2][i + 1] = False
count = 0
for i in range(q):
r, c = Read.list_int()
l[r][c] = not l[r][c]
d = 1 if l[r][c] else -1
t = 1 if r == 2 else 2
if c > 1 and l[t][c - 1]:
count += d
if c < n and l[t][c + 1]:
count += d
if l[t][c]:
count += d
print('NO' if count else 'YES')
query_count = 1
# query_count = Read.int()
while query_count:
query_count -= 1
solve()
``` | instruction | 0 | 28,396 | 15 | 56,792 |
Yes | output | 1 | 28,396 | 15 | 56,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n, q = map(int, input().split())
last = 10**6
lava = set()
def paas(r, c, lava):
dr = 1 if r == 2 else 2
for dc in [-1, 0, 1]:
if (dr, c+dc) in lava:
return True
return False
points = 0
for _ in range(q):
r,c = map(int, input().split())
if (r, c) in lava:
lava.remove((r, c))
if paas(r, c, lava):
points -= 1
else:
lava.add((r, c))
if paas(r, c, lava):
points += 1
if points == 0:
print('yes')
else:
print('no')
``` | instruction | 0 | 28,397 | 15 | 56,794 |
No | output | 1 | 28,397 | 15 | 56,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n, q = map(int, input().split())
r1 = [0]*(n+2)
r2 = [0]*(n+2)
f = ""
t = "Yes"
for i in range(q):
r, c = map(int, input().split())
if r==1:
if r1[c]==0:
r1[c]=1
if r2[c-1]==1 or r2[c+1]==1 or r2[c]==1:
t = "No"
else:
t = "Yes"
else:
r1[c]=0
if (r2[c-1]==1 and r1[c-1]==1) or (r2[c]==1 and r1[c-1]==1) or (r2[c+1]==1 and r1[c+1]==1) or (r2[c]==1 and r1[c+1]==1):
t = "No"
else:
t = "Yes"
else:
if r2[c]==0:
r2[c]=1
if r1[c-1]==1 or r1[c+1]==1 or r1[c]==1:
t = "No"
else:
t = "Yes"
else:
r2[c]=0
if (r1[c-1]==1 and r2[c-1]==1) or (r1[c]==1 and r2[c-1]==1) or (r1[c+1]==1 and r2[c+1]==1) or (r1[c]==1 and r2[c+1]==1):
t = "No"
else:
t = "Yes"
f += t +"\n"
print(f)
``` | instruction | 0 | 28,398 | 15 | 56,796 |
No | output | 1 | 28,398 | 15 | 56,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
n,q=map(int,input().split())
queue=[]
for i in range(q):
queue.append(list(map(int,input().split())))
arr=[[False]*n for i in range(2)]
count=0
for i in range(q):
#print(queue[i])
x,y=queue[i][0]-1,queue[i][1]-1
#print(x,y)
#print(arr)
if not arr[x][y]:
arr[x][y]=True
if (x==0 and y==0) or (x==1 and y==n-1):
count+=1
elif y==0:
if arr[0][1]:
count+=1
elif y==n-1:
if n>1 and arr[1][n-2]:
count+=1
else:
if arr[(x+1)%2][y]:
count+=1
if x==0:
if arr[1][y+1] or arr[1][y-1]:
count+=1
else:
if arr[0][y+1] or arr[0][y-1]:
count+=1
else:
arr[x][y]=False
if (x==0 and y==0) or (x==1 and y==n-1):
count-=1
elif y==0:
if arr[0][1]:
count-=1
elif y==n-1:
if n>1 and arr[1][n-2]:
count-=1
else:
if arr[(x+1)%2][y]:
count-=1
if x==0:
if arr[1][y+1] or arr[1][y-1]:
count-=1
else:
if arr[0][y+1] or arr[0][y-1]:
count-=1
if count==0:
print('Yes')
else:
print('No')
``` | instruction | 0 | 28,399 | 15 | 56,798 |
No | output | 1 | 28,399 | 15 | 56,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
[3R2 as DJ Mashiro - Happiness Breeze](https://open.spotify.com/track/2qGqK8GRS65Wlf20qUBEak)
[Ice - DJ Mashiro is dead or alive](https://soundcloud.com/iceloki/dj-mashiro-is-dead-or-alive)
NEKO#Ξ¦ΟΞ¦ has just got a new maze game on her PC!
The game's main puzzle is a maze, in the forms of a 2 Γ n rectangle grid. NEKO's task is to lead a Nekomimi girl from cell (1, 1) to the gate at (2, n) and escape the maze. The girl can only move between cells sharing a common side.
However, at some moments during the game, some cells may change their state: either from normal ground to lava (which forbids movement into that cell), or vice versa (which makes that cell passable again). Initially all cells are of the ground type.
After hours of streaming, NEKO finally figured out there are only q such moments: the i-th moment toggles the state of cell (r_i, c_i) (either from ground to lava or vice versa).
Knowing this, NEKO wonders, after each of the q moments, whether it is still possible to move from cell (1, 1) to cell (2, n) without going through any lava cells.
Although NEKO is a great streamer and gamer, she still can't get through quizzes and problems requiring large amount of Brain Power. Can you help her?
Input
The first line contains integers n, q (2 β€ n β€ 10^5, 1 β€ q β€ 10^5).
The i-th of q following lines contains two integers r_i, c_i (1 β€ r_i β€ 2, 1 β€ c_i β€ n), denoting the coordinates of the cell to be flipped at the i-th moment.
It is guaranteed that cells (1, 1) and (2, n) never appear in the query list.
Output
For each moment, if it is possible to travel from cell (1, 1) to cell (2, n), print "Yes", otherwise print "No". There should be exactly q answers, one after every update.
You can print the words in any case (either lowercase, uppercase or mixed).
Example
Input
5 5
2 3
1 4
2 4
2 3
1 4
Output
Yes
No
No
No
Yes
Note
We'll crack down the example test here:
* After the first query, the girl still able to reach the goal. One of the shortest path ways should be: (1,1) β (1,2) β (1,3) β (1,4) β (1,5) β (2,5).
* After the second query, it's impossible to move to the goal, since the farthest cell she could reach is (1, 3).
* After the fourth query, the (2, 3) is not blocked, but now all the 4-th column is blocked, so she still can't reach the goal.
* After the fifth query, the column barrier has been lifted, thus she can go to the final goal again.
Submitted Solution:
```
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def tinput():
return input().split()
def rinput():
return map(int, tinput())
def rlinput():
return list(rinput())
mod = int(1e9)+7
def solve(adj,colors,n):
pass
if __name__ == "__main__":
n,q=rinput()
block=0
d=dict()
for i in range(2):
for j in range(n):
d[(i+1,j+1)]=True
print(d)
for i in range(q):
a,b=rinput()
d[(a,b)]=not d[(a,b)]
if b==1:
if d[(a,b)]==False and d[((a%2)+1,b+1)]==False:
block+=1
elif d[(a,b)]==True and d[((a%2)+1,b+1)]==False:
block-=1
elif b==n:
if d[(a,b)]==False and d[((a%2)+1,b-1)]==False:
block+=1
elif d[(a,b)]==True and d[((a%2)+1,b-1)]==False:
block-=1
else:
if d[(a,b)]==False and d[((a%2)+1,b-1)]==False:
block+=1
elif d[(a,b)]==True and d[((a%2)+1,b-1)]==False:
block-=1
if d[(a,b)]==False and d[((a%2)+1,b+1)]==False:
block+=1
elif d[(a,b)]==True and d[((a%2)+1,b+1)]==False:
block-=1
if d[((a%2)+1,b)]==False:
block+=-1 if d[(a,b)] else 1
print('Yes' if block==0 else 'No')
``` | instruction | 0 | 28,400 | 15 | 56,800 |
No | output | 1 | 28,400 | 15 | 56,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,417 | 15 | 56,834 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import deque
def dfs(alpha, id):
"""Depth First Search on a graph!"""
stack = [alpha]
cycle = None
while stack:
v = stack[-1]
if not visited[v]:
visited[v] = True
u = graph[v]
if 1:
if not visited[u]:
stack.append(u)
elif visited[u] and ids[u] != -1:
id = ids[u]
cycleid = u
else:
cycle = (u, v)
else:
break
if not cycle:
#print(cycleid, result)
result = stack
for i in range(len(result)):
ids[result[i]] = id
cyclelength[result[i]] = cyclelength[cycleid]
cycledistance[result[i]] = (cycledistance[cycleid] - (len(result)-i)) \
% cyclelength[result[i]]
else:
#print(cycle, result, stack)
index = []
result = stack
for i in range(len(result)):
ids[result[i]] = id
if result[i] == cycle[0] or result[i] == cycle[1]:
index += [i]
for i in range(len(result)):
if i < index[0]:
cycledistance[result[i]] = (i - index[0]) % (index[1] - index[0] + 1)
else:
cycledistance[result[i]] = (i - index[0]) % (index[1] - index[0] + 1)
cyclelength[result[i]] = index[1] - index[0] + 1
for _ in range(int(input())):
n, m = map(int, input().split())
colors = [-1]
for i in range(n):
colors += [int(k) for k in input()]
graph = [0]*(n*m + 1)
for i in range(n):
line = input()
for j in range(m):
if line[j] == 'R':
graph[i*m + j + 1] = i*m + j + 2
elif line[j] == 'L':
graph[i*m + j + 1] = i*m + j
elif line[j] == 'U':
graph[i*m + j + 1] = (i-1)*m + j + 1
else:
graph[i*m + j + 1] = (i+1)*m + j + 1
visited = [False] * len(graph)
ids = [-1] * len(graph)
cycledistance = [0] * len(graph)
cyclelength = [0] * len(graph)
id = 0
oo = []
for i in range(1, len(graph)):
if not visited[i]:
dfs(i, id)
if ids[i] == id:
id += 1
oo += [[0]*cyclelength[i]]
#print(cycledistance)
#print(cyclelength)
#print(ids)
#print(graph)
black = 0
white = 0
for i in range(1, len(graph)):
if colors[i] == 0:
if not oo[ids[i]][cycledistance[i]]:
black += 1
oo[ids[i]][cycledistance[i]] = 1
for i in range(1, len(graph)):
if colors[i] == 1:
if not oo[ids[i]][cycledistance[i]]:
white += 1
oo[ids[i]][cycledistance[i]] = 1
print(white+black, black)
``` | output | 1 | 28,417 | 15 | 56,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,418 | 15 | 56,836 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
import sys
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():
for _ in range(II()):
h,w=MI()
cc=[list(map(int,list(SI()))) for _ in range(h)]
ss=[SI() for _ in range(h)]
aa=[[0]*w for _ in range(h)]
mm=[[0]*w for _ in range(h)]
cyc=[0]
ci=1
dir="UDLR"
dij=[(-1,0),(1,0),(0,-1),(0,1)]
for si in range(h):
for sj in range(w):
if aa[si][sj]!=0:continue
i,j=si,sj
d=-1
stack=[]
while aa[i][j]==0:
aa[i][j]=d
stack.append((i,j))
d-=1
di,dj=dij[dir.index(ss[i][j])]
i,j=i+di,j+dj
if aa[i][j]>0:
a=aa[i][j]
dist=cyc[a]
m=(mm[i][j]+1)%dist
for i,j in stack[::-1]:
aa[i][j]=a
mm[i][j]=m
m=(m+1)%dist
else:
dist=aa[i][j]-d
cyc.append(dist)
m=0
for i, j in stack[::-1]:
aa[i][j] = ci
mm[i][j]=m
m=(m+1)%dist
ci+=1
one=[set() for _ in range(ci)]
for i in range(h):
for j in range(w):
if cc[i][j]==0:
one[aa[i][j]].add(mm[i][j])
ans1=sum(cyc)
ans2=sum(min(ck,len(ok)) for ck,ok in zip(cyc,one))
print(ans1,ans2)
main()
``` | output | 1 | 28,418 | 15 | 56,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,419 | 15 | 56,838 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
def findCycle(source, getNbr):
q = deque([source])
parent = {source: None}
while q:
node = q.popleft()
for nbr in getNbr(node):
if nbr not in parent:
q.append(nbr)
parent[nbr] = node
else:
cycle = [node]
while parent[node] != nbr:
node = parent[node]
cycle.append(node)
cycle.append(nbr)
return cycle
def markTime(cycle, getNbr):
cycleLen = len(cycle)
q = deque(cycle)
dist = {x: i for i, x in enumerate(cycle)}
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = (d + 1) % cycleLen
return dist
def solve(R, C, grid, directions):
BLACK = 0
WHITE = 1
drdc = {
"U": [-1, 0],
"R": [0, 1],
"D": [1, 0],
"L": [0, -1],
}
"""
graph = [[] for i in range(R * C)]
graphT = [[] for i in range(R * C)]
for r in range(R):
for c in range(C):
i = r * C + c
dr, dc = drdc[directions[r][c]]
j = (r + dr) * C + (c + dc)
graph[i].append(j)
graphT[j].append(i)
"""
def getNbr(i):
r, c = divmod(i, C)
dr, dc = drdc[directions[r][c]]
return [(r + dr) * C + (c + dc)]
def getNbrT(i):
r, c = divmod(i, C)
ret = []
for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nr = r + dr
nc = c + dc
if 0 <= nr < R and 0 <= nc < C:
if [-dr, -dc] == drdc[directions[nr][nc]]:
ret.append(nr * C + nc)
return ret
ans1 = 0
ans2 = 0
seen = set()
for i in range(R * C):
if i not in seen:
# BFS until found cycle
cycle = findCycle(i, getNbr)
uniqueTimes = len(cycle)
# Find all nodes going to cycle
# Each starting node going into cycle will have a collision timestamp mod cycle len
dist = markTime(cycle, getNbrT)
uniqueBlackTimes = set()
for j, t in dist.items():
r, c = divmod(j, C)
if grid[r][c] == BLACK:
uniqueBlackTimes.add(t)
seen.add(j)
ans1 += uniqueTimes
ans2 += len(uniqueBlackTimes)
del cycle
del dist
del uniqueBlackTimes
return str(ans1) + " " + str(ans2)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
R, C = [int(x) for x in input().split()]
grid = [list(map(int, input().decode().rstrip())) for r in range(R)]
directions = [list(input().decode().rstrip()) for r in range(R)]
ans = solve(R, C, grid, directions)
print(ans)
``` | output | 1 | 28,419 | 15 | 56,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,420 | 15 | 56,840 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
from sys import stdin, gettrace
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def main():
def solve():
n,m = map(int, input().split())
colour = []
for _ in range(n):
colour.append(input())
dir = []
for _ in range(n):
dir.append(input())
eqgrid = [[None]*m for _ in range(n)]
next_path = 0
pathsizes = []
eclass_has_black = []
totls = 0
for ni in range (n):
for nj in range(m):
if eqgrid[ni][nj]:
continue
i = ni
j = nj
path = []
count = 1
while not eqgrid[i][j]:
path.append((i,j))
eqgrid[i][j] = (count, next_path)
count += 1
if dir[i][j] == 'L':
j -=1
elif dir[i][j] == 'R':
j +=1
elif dir[i][j] == 'U':
i -=1
else:
i+=1
ppos, found_path = eqgrid[i][j]
if found_path == next_path:
ls = count - ppos
eclass_has_black.append([False]*ls)
for ix, (k, l) in enumerate(path[::-1]):
eq = ix%ls
eqgrid[k][l] = (eq, next_path)
if colour[k][l] == '0':
eclass_has_black[next_path][eq] = True
pathsizes.append(ls)
totls += ls
next_path += 1
else:
ls = pathsizes[found_path]
for ix, (k, l) in enumerate(path[::-1], 1):
eq = (ix + ppos) % ls
eqgrid[k][l] = (eq, found_path)
if colour[k][l] == '0':
eclass_has_black[found_path][eq] = True
blacks = len([b for p in eclass_has_black for b in p if b])
print(totls, blacks)
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 28,420 | 15 | 56,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,421 | 15 | 56,842 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
from collections import defaultdict
import sys
from itertools import chain
input = sys.stdin.readline
def solve(n, adj, rev):
visited, order = [0]*n, []
for i in range(n):
if visited[i]:
continue
stack = [i]
while stack:
v = stack.pop()
visited[v] = 1
if visited[adj[v]] == 0:
visited[adj[v]] = 1
stack.extend((v, adj[v]))
else:
order.append(v)
groups = [0]*n
g = 1
while order:
stack = [order.pop()]
groups[stack[0]] = g
while stack:
v = stack.pop()
for dest in rev[v]:
if groups[dest]:
continue
groups[dest] = g
stack.append(dest)
g += 1
while order and groups[order[-1]]:
order.pop()
return groups
for _ in range(int(input())):
h, w = map(int, input().split())
V = h*w
adj = [0]*V
rev = [[] for _ in range(V)]
colors = list(chain.from_iterable(
map(lambda x: int(x) ^ 1, input().rstrip()) for _ in range(h)))
dirs = list(chain.from_iterable(input().rstrip() for _ in range(h)))
delta = {'R': 1, 'L': -1, 'D': w, 'U': -w}
for i, d in enumerate(dirs):
adj[i] = i + delta[d]
rev[i + delta[d]].append(i)
dd = defaultdict(list)
for i, g in enumerate(solve(V, adj, rev)):
dd[g].append(i)
ans_robot, ans_black = 0, 0
group = [-1]*V
for cycle in dd.values():
size = len(cycle)
if size == 1:
continue
black = [0]*size
cur = cycle[0]
for i in range(size):
group[cur] = i
black[i] = colors[cur]
cur = adj[cur]
for s in cycle:
stack = [s]
while stack:
v = stack.pop()
black[group[v]] |= colors[v]
for dest in rev[v]:
if group[dest] != -1:
continue
group[dest] = (group[v]-1) % size
stack.append(dest)
ans_robot += size
ans_black += sum(black)
sys.stdout.write(str(ans_robot)+' '+str(ans_black)+'\n')
``` | output | 1 | 28,421 | 15 | 56,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,422 | 15 | 56,844 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
import sys
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():
for _ in range(II()):
h,w=MI()
cc=[list(map(int,list(SI()))) for _ in range(h)]
ss=[SI() for _ in range(h)]
aa=[[0]*w for _ in range(h)]
mm=[[0]*w for _ in range(h)]
cyc=[0]
ci=1
dir="UDLR"
dij=[(-1,0),(1,0),(0,-1),(0,1)]
for si in range(h):
for sj in range(w):
if aa[si][sj]!=0:continue
i,j=si,sj
d=-1
stack=[]
while aa[i][j]==0:
aa[i][j]=d
stack.append((i,j))
d-=1
di,dj=dij[dir.index(ss[i][j])]
i,j=i+di,j+dj
if aa[i][j]>0:
a=aa[i][j]
dist=cyc[a]
m=(mm[i][j]+1)%dist
for i,j in stack[::-1]:
aa[i][j]=a
mm[i][j]=m
m=(m+1)%dist
else:
dist=aa[i][j]-d
cyc.append(dist)
m=0
for i, j in stack[::-1]:
aa[i][j] = ci
mm[i][j]=m
m=(m+1)%dist
ci+=1
#print(cyc)
#p2D(aa)
one=[set() for _ in range(ci)]
for i in range(h):
for j in range(w):
if cc[i][j]==0:
one[aa[i][j]].add(mm[i][j])
#print(one)
ans1=sum(cyc)
ans2=sum(min(ck,len(ok)) for ck,ok in zip(cyc,one))
print(ans1,ans2)
main()
``` | output | 1 | 28,422 | 15 | 56,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,423 | 15 | 56,846 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
from sys import stdin, gettrace
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def main():
def solve():
n,m = map(int, input().split())
colour = []
for _ in range(n):
colour.append(input())
dir = []
for _ in range(n):
dir.append(input())
lc = [[None]*m for _ in range(n)]
next_trail = 0
trails = []
traills = []
maxels = 0
for ni in range (n):
for nj in range(m):
if not lc[ni][nj]:
i = ni
j = nj
trail = []
count = 1
while not lc[i][j]:
trail.append((i,j))
lc[i][j] = (count, next_trail)
count += 1
if dir[i][j] == 'L':
j -=1
elif dir[i][j] == 'R':
j +=1
elif dir[i][j] == 'U':
i -=1
else:
i+=1
trpos = lc[i][j][0]
found_trail = lc[i][j][1]
if found_trail == next_trail:
ls = count - trpos
for ix, (k, l) in enumerate(trail[::-1]):
lc[k][l] = (ix%ls, next_trail)
traills.append(ls)
trails.append(trail)
maxels += ls
next_trail += 1
else:
ls = traills[found_trail]
for ix, (k, l) in enumerate(trail[::-1], 1):
lc[k][l] = ((ix + trpos) % ls, found_trail)
trails[found_trail] += trail
blacks = 0
for i in range(len(trails)):
found = [False] * traills[i]
for k,l in trails[i]:
if colour[k][l] == '0' and not found[lc[k][l][0]]:
blacks += 1
found[lc[k][l][0]] = True
print(maxels, blacks)
q = int(input())
for _ in range(q):
solve()
if __name__ == "__main__":
main()
``` | output | 1 | 28,423 | 15 | 56,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2 | instruction | 0 | 28,424 | 15 | 56,848 |
Tags: data structures, dfs and similar, dsu, graphs, greedy, matrices
Correct Solution:
```
import sys
from collections import deque
import gc
def findCycle(source, getNbr):
q = deque([source])
parent = {source: None}
while q:
node = q.popleft()
for nbr in getNbr(node):
if nbr not in parent:
q.append(nbr)
parent[nbr] = node
else:
cycle = [node]
while parent[node] != nbr:
node = parent[node]
cycle.append(node)
cycle.append(nbr)
return cycle[::-1]
def markTime(cycle, getNbr):
cycleLen = len(cycle)
q = deque(cycle)
dist = {x: cycleLen - 1 - i for i, x in enumerate(cycle)} # distance to reach cycle[-1]
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = (d + 1) % cycleLen
return dist
def solve(R, C, grid, directions):
BLACK = 0
drdc = {
"U": [-1, 0],
"R": [0, 1],
"D": [1, 0],
"L": [0, -1],
}
def getNbr(i):
r, c = divmod(i, C)
dr, dc = drdc[directions[r][c]]
return [(r + dr) * C + (c + dc)]
def getNbrT(i):
r, c = divmod(i, C)
ret = []
for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nr = r + dr
nc = c + dc
if 0 <= nr < R and 0 <= nc < C:
if [-dr, -dc] == drdc[directions[nr][nc]]:
ret.append(nr * C + nc)
return ret
ans1 = 0
ans2 = 0
seen = set()
for i in range(R * C):
if i not in seen:
# BFS until found cycle
cycle = findCycle(i, getNbr)
uniqueTimes = len(cycle)
# Find all nodes going to cycle
# Each starting node going into cycle will have a collision timestamp mod cycle len
dist = markTime(cycle, getNbrT)
uniqueBlackTimes = set()
for j, t in dist.items():
r, c = divmod(j, C)
if grid[r][c] == BLACK:
uniqueBlackTimes.add(t)
seen.add(j)
ans1 += uniqueTimes
ans2 += len(uniqueBlackTimes)
del cycle
del dist
del uniqueBlackTimes
return str(ans1) + " " + str(ans2)
if __name__ == "__main__":
input = sys.stdin.readline
T = int(input())
for t in range(T):
R, C = [int(x) for x in input().split()]
grid = [list(map(int, input().rstrip())) for r in range(R)]
directions = [list(input().rstrip()) for r in range(R)]
ans = solve(R, C, grid, directions)
print(ans)
``` | output | 1 | 28,424 | 15 | 56,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
from collections import deque
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
s = [input() for i in range(n)]
grid = [input() for i in range(n)]
robot_cnt = 0
black_cnt = 0
graph = [-1] * (n * m)
rev_graph = [[] for i in range(n * m)]
for i in range(n):
for j in range(m):
if grid[i][j] == "U":
graph[i * m + j] = (i - 1) * m + j
rev_graph[(i - 1) * m + j].append(i * m + j)
elif grid[i][j] == "R":
graph[i * m + j] = i * m + (j + 1)
rev_graph[i * m + (j + 1)].append(i * m + j)
elif grid[i][j] == "D":
graph[i * m + j] = (i + 1) * m + j
rev_graph[(i + 1) * m + j].append(i * m + j)
elif grid[i][j] == "L":
graph[i * m + j] = i * m + (j - 1)
rev_graph[i * m + (j - 1)].append(i * m + j)
is_start = [True] * (n * m)
for i in graph:
is_start[i] = False
is_cycle = [False] * (n * m)
period = [0] * (n * m)
for i in range(n * m):
if not is_start[i]:
continue
st = i
period[i] = 1
while True:
nxt_i = graph[i]
if period[nxt_i] < 0:
tmp = period[nxt_i]
break
if period[nxt_i] > 0:
tmp = -(period[i] - period[nxt_i] + 1)
is_cycle[nxt_i] = True
break
period[graph[i]] = period[i] + 1
i = graph[i]
i = st
period[i] = tmp
while True:
nxt_i = graph[i]
if period[nxt_i] < 0:
break
period[graph[i]] = tmp
i = graph[i]
# cycle without side road
for i in range(n * m):
if period[i] == 0:
robot_cnt += 1
if s[i // m][i % m] == "0":
black_cnt += 1
# cycle with road
for i in range(n * m):
if not is_cycle[i]:
continue
MOD = - period[i]
period[i] = 0
is_black = [False] * MOD
if s[i // m][i % m] == "0":
is_black[0] = True
q = deque([i])
while q:
v = q.pop()
for nxt_v in rev_graph[v]:
if period[nxt_v] >= 0:
continue
period[nxt_v] = (period[v] + 1) % MOD
if s[nxt_v // m][nxt_v % m] == "0":
is_black[period[nxt_v]] = True
q.append(nxt_v)
robot_cnt += MOD
black_cnt += sum(is_black)
print(robot_cnt, black_cnt)
``` | instruction | 0 | 28,425 | 15 | 56,850 |
Yes | output | 1 | 28,425 | 15 | 56,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
from collections import deque
def bfs(source, getNbr):
q = deque([source])
dist = {source: 0}
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = d + 1
return dist
def solve(R, C, grid, directions):
BLACK = 0
drdc = {
"U": [-1, 0],
"R": [0, 1],
"D": [1, 0],
"L": [0, -1],
}
def getNbr(i):
# Where this cell can go (just one neighbor, determined by the input directions grid)
r, c = divmod(i, C)
dr, dc = drdc[directions[r][c]]
return [(r + dr) * C + (c + dc)]
def getNbrT(i):
# What can reach this cell (up to 4 possible neighbors)
r, c = divmod(i, C)
ret = []
for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nr = r + dr
nc = c + dc
if 0 <= nr < R and 0 <= nc < C:
if [-dr, -dc] == drdc[directions[nr][nc]]:
ret.append(nr * C + nc)
return ret
ans1 = 0
ans2 = 0
seen = set()
for i in range(R * C):
if i not in seen:
# Find sink cycle
cycleIndices = {i: 0}
cycle = [i]
while True:
(nbr,) = getNbr(cycle[-1])
if nbr in cycleIndices:
cycle = cycle[cycleIndices[nbr] :]
break
cycleIndices[nbr] = len(cycle)
cycle.append(nbr)
uniqueTimes = len(cycle)
ans1 += uniqueTimes
# Find all nodes going to cycle
# Each starting node going into cycle will have a collision timestamp mod cycle len
dist = bfs(cycle[-1], getNbrT)
uniqueBlackTimes = set()
for j, time in dist.items():
r, c = divmod(j, C)
if grid[r][c] == BLACK:
uniqueBlackTimes.add(time % uniqueTimes)
seen.add(j) # Mark everything reaching this sink cycle as seen
ans2 += len(uniqueBlackTimes)
del cycle
del dist
del uniqueBlackTimes
return str(ans1) + " " + str(ans2)
if __name__ == "__main__":
input = sys.stdin.readline
T = int(input())
for t in range(T):
R, C = [int(x) for x in input().split()]
grid = [list(map(int, input().rstrip())) for r in range(R)]
directions = [list(input().rstrip()) for r in range(R)]
ans = solve(R, C, grid, directions)
print(ans)
``` | instruction | 0 | 28,426 | 15 | 56,852 |
Yes | output | 1 | 28,426 | 15 | 56,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
def go():
# n = int(input())
n,m = map(int, input().split())
c=''.join(input() for _ in range(n))
s=''.join(input() for _ in range(n))
nm = n * m
done = [False] * nm
groups = [None] * nm
phase = [-1]*nm
def step(pos,direct=None):
if direct is None:
direct=s[pos]
if direct=='U':
return pos-m
if direct=='D':
return pos+m
if direct=='L':
return pos-1
if direct=='R':
return pos+1
cyc_len={}
for i in range(nm):
if not done[i]:
same = {}
pos=0
cur=i
group=-1
pcur=None
while cur not in same:
if groups[cur] is not None:
group=groups[cur]
pcur=pos+phase[cur]
break
same[cur]=pos
done[cur]=True
cur=step(cur)
pos+=1
else:
group=cur
cyc_len[group]=len(same)-same[cur]
pcur=pos
for ss,pos in same.items():
groups[ss]=group
phase[ss]=(pcur-pos)%cyc_len[group]
blacks = len(set((pp,gg)for cc,pp,gg in zip(c,phase,groups) if cc=='0'))
# print('ppp',phase)
# print(groups)
# print('--',cyc_len)
return f'{sum(cyc_len.values())} {blacks}'
# x,s = map(int,input().split())
t = int(input())
# t = 1
ans = []
for _ in range(t):
# print(go())
ans.append(str(go()))
#
print('\n'.join(ans))
``` | instruction | 0 | 28,427 | 15 | 56,854 |
Yes | output | 1 | 28,427 | 15 | 56,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def build_scc(V: int, adj: list) -> list:
state, low, order = [0] * V, [0] * V, [0] * V
group_id, time = 1, 1
groups = []
for i in range(V):
if order[i]:
continue
stack, rec = [i], [i]
while rec:
v = rec[-1]
if not order[v]:
low[v] = order[v] = time
time, state[v] = time + 1, -1
elif low[v] > low[adj[v]]:
low[v] = low[adj[v]]
for edge_i in range(state[v], 0):
dest = adj[v]
if not order[dest]:
state[v] = edge_i + 1
stack.append(dest)
rec.append(dest)
break
elif state[dest] <= 0 and low[v] > order[dest]:
low[v] = order[dest]
else:
if low[v] == order[v]:
g = []
while state[v] <= 0:
g.append(stack[-1])
state[stack.pop()] = group_id
group_id += 1
if len(g) > 1:
groups.append(g)
rec.pop()
return groups
t = int(input())
ans = [''] * t
for ti in range(t):
n, m = map(int, input().split())
N = n * m
dir_dict = {'L': -1, 'R': 1, 'U': -m, 'D': m}
adj, rev = [-1] * N, [[] for _ in range(N)]
color = array('b', [0]) * N
for i in range(n):
for v, c in enumerate(map(int, input().rstrip()), start=i * m):
color[v] = c
for i in range(n):
for v, c in enumerate(input().rstrip(), start=i * m):
adj[v] = v + dir_dict[c]
rev[v + dir_dict[c]].append(v)
sccs = build_scc(N, adj)
ans_sum, ans_black = 0, 0
visited = array('b', [0]) * N
for scc in sccs:
size = len(scc)
black = [0] * size
stack = []
v = scc[0]
for i in range(size):
visited[v] = 1
stack.append((v, i))
v = adj[v]
while stack:
v, mod = stack.pop()
if color[v] == 0:
black[mod] = 1
for dest in rev[v]:
if visited[dest]:
continue
visited[dest] = 1
stack.append((dest, mod - 1 if mod > 0 else size - 1))
ans_sum += size
ans_black += sum(black)
ans[ti] = f'{ans_sum} {ans_black}'
sys.stdout.buffer.write('\n'.join(ans).encode('utf-8'))
``` | instruction | 0 | 28,428 | 15 | 56,856 |
Yes | output | 1 | 28,428 | 15 | 56,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
# from functools import lru_cache
# from random import shuffle
# from sys import setrecursionlimit
# setrecursionlimit(100000000)
# from collections import Counter, deque
# from bisect import bisect
# from fractions import Fraction
# from itertools import combinations
class Problem:
def __init__(self, prod=True, expected_out=''):
self.prod = prod
self.expected_out = expected_out
self.data = self.get_data()
def int(self):
return int(next(self.data))
def ints(self):
return list(map(int, next(self.data).split()))
def str(self):
return next(self.data)
def get_data(self):
from sys import stdin
f = stdin
if not self.prod:
f = open('in.txt')
data = (line for line in f.read().splitlines())
return data
def get_g(self, DIRS):
g = [[None]*len(DIRS[0]) for _ in range(len(DIRS))]
for i in range(len(DIRS)):
for j in range(len(DIRS[0])):
ni, nj = i, j
d = DIRS[i][j]
if d == "U":
ni -= 1
elif d == "D":
ni += 1
elif d == "L":
nj -= 1
elif d == "R":
nj += 1
g[i][j] = (ni, nj)
g2 = [[(0,0)]*len(DIRS[0]) for _ in range(len(DIRS))]
C = len(DIRS[0])
count = 0
for ii in range(21):
if 2**ii > len(DIRS) * len(DIRS[0]):
break
count += len(DIRS) * C
if count > 3*10**6:
break
for i in range(len(DIRS)):
for j in range(C):
ni, nj = g[i][j]
g2[i][j] = g[ni][nj]
g, g2 = g2, g
return g
def solve(self, BW, DIRS):
g = self.get_g(DIRS)
in_cycle = set()
black_in_cycle = set()
for i in range(len(g)):
for j in range(len(g[0])):
in_cycle.add(g[i][j])
if BW[i][j] == '0':
black_in_cycle.add(g[i][j])
return '{} {}'.format(len(in_cycle), len(black_in_cycle))
def test_case(self):
R, C = self.ints()
BW = [self.str() for _ in range(R)]
DIRS = [self.str() for _ in range(R)]
return self.solve(BW, DIRS)
def test(self):
N = 10**6//2
BW = ['11'*N] * 2
DIRS = ['RL'*N] * 2
print('testing')
print(self.solve(BW, DIRS))
BW = ['11']*N
DIRS = ['RL']*N
print('testing')
print(self.solve(BW, DIRS))
def run(self):
cases = int(next(self.data))
results = []
for case_num in range(1, cases+1):
if not self.prod:
print('----- case {} ------'.format(case_num))
results.append('{}'.format(self.test_case()))
out = '\n'.join(results)
if not self.prod and expected_out:
self.test()
from difflib import ndiff
print('-- start diff --')
print(''.join(ndiff(expected_out.splitlines(keepends=True), out.splitlines(keepends=True))))
print('-- end diff --')
else:
print(out)
#python3 codejam_template.py < in.txt
expected_out = '''2 1
4 3
2 2'''
Problem(prod=True, expected_out=expected_out).run()
``` | instruction | 0 | 28,429 | 15 | 56,858 |
No | output | 1 | 28,429 | 15 | 56,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
from collections import deque
def findCycle(source, getNbr):
q = deque([source])
parent = {source: None}
while q:
node = q.popleft()
for nbr in getNbr(node):
if nbr not in parent:
q.append(nbr)
parent[nbr] = node
else:
cycle = [node]
while parent[node] != nbr:
node = parent[node]
cycle.append(node)
cycle.append(nbr)
return cycle[::-1]
def markTime(cycle, getNbr):
cycleLen = len(cycle)
q = deque(cycle)
dist = {x: i for i, x in enumerate(cycle)}
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = (d + 1) % cycleLen
return dist
def solve(R, C, grid, directions):
BLACK = 0
drdc = {
"U": [-1, 0],
"R": [0, 1],
"D": [1, 0],
"L": [0, -1],
}
def getNbr(i):
r, c = divmod(i, C)
dr, dc = drdc[directions[r][c]]
return [(r + dr) * C + (c + dc)]
def getNbrT(i):
r, c = divmod(i, C)
ret = []
for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
nr = r + dr
nc = c + dc
if 0 <= nr < R and 0 <= nc < C:
if [-dr, -dc] == drdc[directions[nr][nc]]:
ret.append(nr * C + nc)
return ret
ans1 = 0
ans2 = 0
seen = set()
for i in range(R * C):
if i not in seen:
# BFS until found cycle
cycle = findCycle(i, getNbr)
uniqueTimes = len(cycle)
# Find all nodes going to cycle
# Each starting node going into cycle will have a collision timestamp mod cycle len
dist = markTime(cycle, getNbrT)
uniqueBlackTimes = set()
for j, t in dist.items():
r, c = divmod(j, C)
if grid[r][c] == BLACK:
uniqueBlackTimes.add(t)
seen.add(j)
ans1 += uniqueTimes
ans2 += len(uniqueBlackTimes)
return str(ans1) + " " + str(ans2)
if __name__ == "__main__":
input = sys.stdin.readline
T = int(input())
for t in range(T):
R, C = [int(x) for x in input().split()]
grid = [list(map(int, input().rstrip())) for r in range(R)]
directions = [list(input().rstrip()) for r in range(R)]
ans = solve(R, C, grid, directions)
print(ans)
``` | instruction | 0 | 28,430 | 15 | 56,860 |
No | output | 1 | 28,430 | 15 | 56,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
print("hello world")
``` | instruction | 0 | 28,431 | 15 | 56,862 |
No | output | 1 | 28,431 | 15 | 56,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of size n Γ m. Each cell of the grid is colored black ('0') or white ('1'). The color of the cell (i, j) is c_{i, j}. You are also given a map of directions: for each cell, there is a direction s_{i, j} which is one of the four characters 'U', 'R', 'D' and 'L'.
* If s_{i, j} is 'U' then there is a transition from the cell (i, j) to the cell (i - 1, j);
* if s_{i, j} is 'R' then there is a transition from the cell (i, j) to the cell (i, j + 1);
* if s_{i, j} is 'D' then there is a transition from the cell (i, j) to the cell (i + 1, j);
* if s_{i, j} is 'L' then there is a transition from the cell (i, j) to the cell (i, j - 1).
It is guaranteed that the top row doesn't contain characters 'U', the bottom row doesn't contain characters 'D', the leftmost column doesn't contain characters 'L' and the rightmost column doesn't contain characters 'R'.
You want to place some robots in this field (at most one robot in a cell). The following conditions should be satisfied.
* Firstly, each robot should move every time (i.e. it cannot skip the move). During one move each robot goes to the adjacent cell depending on the current direction.
* Secondly, you have to place robots in such a way that there is no move before which two different robots occupy the same cell (it also means that you cannot place two robots in the same cell). I.e. if the grid is "RL" (one row, two columns, colors does not matter there) then you can place two robots in cells (1, 1) and (1, 2), but if the grid is "RLL" then you cannot place robots in cells (1, 1) and (1, 3) because during the first second both robots will occupy the cell (1, 2).
The robots make an infinite number of moves.
Your task is to place the maximum number of robots to satisfy all the conditions described above and among all such ways, you have to choose one where the number of black cells occupied by robots before all movements is the maximum possible. Note that you can place robots only before all movements.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 5 β
10^4) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 < nm β€ 10^6) β the number of rows and the number of columns correspondingly.
The next n lines contain m characters each, where the j-th character of the i-th line is c_{i, j} (c_{i, j} is either '0' if the cell (i, j) is black or '1' if the cell (i, j) is white).
The next n lines also contain m characters each, where the j-th character of the i-th line is s_{i, j} (s_{i, j} is 'U', 'R', 'D' or 'L' and describes the direction of the cell (i, j)).
It is guaranteed that the sum of the sizes of fields does not exceed 10^6 (β nm β€ 10^6).
Output
For each test case, print two integers β the maximum number of robots you can place to satisfy all the conditions described in the problem statement and the maximum number of black cells occupied by robots before all movements if the number of robots placed is maximized. Note that you can place robots only before all movements.
Example
Input
3
1 2
01
RL
3 3
001
101
110
RLL
DLD
ULL
3 3
000
000
000
RRD
RLD
ULL
Output
2 1
4 3
2 2
Submitted Solution:
```
import sys
from itertools import islice, chain
def convdir(d):
return {
'U': (-1, 0),
'D': (+1, 0),
'R': (0, +1),
'L': (0, -1),
}[d]
def build_field(n, colors, directions):
def succ(x):
a, b = field[x][1]
i, j = x // n, x % n
return (a+i)*n + b + j
field = [
[int(c), convdir(d), None]
for row in zip(colors, directions)
for c, d in zip(*row)
]
for x in range(len(field)):
y = succ(x)
if field[y][2] is None:
field[y][2] = [x]
else:
field[y][2].append(x)
#from pprint import pprint
#pprint({i: xs[2] for i, xs in enumerate(field) if xs[2]})
return field, succ, lambda x: field[x][2] or ()
def pull_cycle(succ, seed, unseen):
# print('='*80)
xs = []
while True:
# print(seed, unseen, xs)
if seed not in unseen:
k = next(i for i, x in enumerate(xs) if x == seed)
return k, xs
unseen.remove(seed)
xs.append(seed)
seed = succ(seed)
def est_comp(k, xs, bsucc, field, unseen):
cl = len(xs) - k
foobar = [0] * cl
seed = [xs[k]]
d = 0
while seed:
for x in seed:
unseen.discard(x)
foobar[d] |= field[x][0]
d = (d + 1) % len(foobar)
seed = [x for x in chain.from_iterable(map(bsucc, seed)) if x != xs[k]]
# print('est_comp:', seed)
return cl, sum(foobar)
def extract_components(succ, bsucc, field):
total = 0
nigga = 0
unseen = set(range(len(field)))
while unseen:
seed = next(iter(unseen))
k, xs = pull_cycle(succ, seed, unseen)
# print('cycle:', k, xs)
tt, tn = est_comp(k, xs, bsucc, field, unseen)
# print(tt, tn)
total += tt
nigga += tn
return total, nigga
def main(f):
lines = map(str.strip, f)
n = int(next(lines))
for _ in range(n):
m, n = map(int, next(lines).split())
field, succ, bsucc = build_field(n, list(map(list, islice(lines, m))), list(map(list, islice(lines, m))))
total, nigga = extract_components(succ, bsucc, field)
print(total, nigga)
if __name__ == '__main__':
if len(sys.argv) == 1:
main(sys.stdin)
else:
with open(sys.argv[1]) as f:
main(f)
``` | instruction | 0 | 28,432 | 15 | 56,864 |
No | output | 1 | 28,432 | 15 | 56,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,433 | 15 | 56,866 |
Tags: math
Correct Solution:
```
import sys
input=sys.stdin.readline
x=int(input())
for i in range(x):
a,b,c,d=map(int,input().split())
rig=c-a
dow=d-b
total=rig*dow
print(total+1)
``` | output | 1 | 28,433 | 15 | 56,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,434 | 15 | 56,868 |
Tags: math
Correct Solution:
```
#Bismillahir Rahmanir Rahim
#cf-1358C
t = int(input())
for i in range(t):
x1,y1,x2,y2 = map(int,input().split())
ans = 1+(y2-y1)*(x2-x1)
print(ans)
``` | output | 1 | 28,434 | 15 | 56,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,435 | 15 | 56,870 |
Tags: math
Correct Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from functools import reduce,cmp_to_key,lru_cache
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# import sys
# input = sys.stdin.readline
M = mod = 10**9 + 7
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip().split()]
def st():return str(input().rstrip())[2:-1]
def val():return int(input().rstrip())
def li2():return [str(i)[2:-1] for i in input().rstrip().split()]
def li3():return [int(i) for i in st()]
for _ in range(val()):
a,b,c,d = li()
c -= a
d -= b
print(1 + c*d)
``` | output | 1 | 28,435 | 15 | 56,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,436 | 15 | 56,872 |
Tags: math
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
def iinp() -> int: return int(input())
def linp() -> list: return [int(p) for p in input().split()]
def sinp() : return input().decode('unicode-escape')[0:-2]
# M = int(1e9 + 7)
t = iinp()
for _ in range(t):
a, b, m, n = linp()
print((a - m) * (b - n) + 1)
``` | output | 1 | 28,436 | 15 | 56,873 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,437 | 15 | 56,874 |
Tags: math
Correct Solution:
```
for _ in range(int(input())):
x,y,xx,yy=map(int,input().split())
print((xx-x)*(yy-y)+1)
``` | output | 1 | 28,437 | 15 | 56,875 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,438 | 15 | 56,876 |
Tags: math
Correct Solution:
```
# def f(x,y):
# start_dig_num = x + y
# start_dig_val = ((start_dig_num -1) *(start_dig_num -2) )//2
# return start_dig_val + y
# for i in range (1,8):
# print( *[f(j,i) for j in range(1,8)])
T = int(input().strip())
for t in range(T):
x0,y0,x1,y1 = list(map(int, input().split()))
# lowersum = 0
# for col in range(x0, x1 + 1):
# lowersum += f(col, y0)
# # print('passed ',y0,col)
# for row in range(y0 + 1, y1 + 1):
# lowersum += f(x1,row)
# # print('passed ', x1, row)
# uppersum = 0
# for row in range(y0, y1 + 1):
# uppersum += f(x0, row)
# for col in range(x0 +1, x1 + 1):
# uppersum += f(col, y1)
#
# print(uppersum - lowersum + 1)
print((x1-x0)*(y1-y0)+1)
``` | output | 1 | 28,438 | 15 | 56,877 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,439 | 15 | 56,878 |
Tags: math
Correct Solution:
```
t = int(input())
for it in range(t):
x1, y1, x2, y2 = [int(i) for i in input().split()]
dx = x2 - x1
dy = y2 - y1
s = dx * (dx + 1) // 2
s_ = (dy + 2) * (dy + 1) // 2 - 1
ans = - (s + s + dy * dx) * (dy + 1) // 2
ans += (s_ + s_ + dy * dx) * (dx + 1) // 2
print(ans + 1 - (s_ - s))
``` | output | 1 | 28,439 | 15 | 56,879 |
Provide tags and a correct Python 3 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,440 | 15 | 56,880 |
Tags: math
Correct Solution:
```
import sys
from math import sqrt
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
#TLE
'''
def getVal(x,y):
num = 1
for i in range(y):
num+=i
for i in range(y+1,x+y):
num+=i
return num
def solve(hash,curX,curY,endX,endY,val):
val += getVal(curX,curY)
print('{} {} {} {}'.format(curX,curY,endX,endY))
if curX == endX and curY == endY:
hash[val] = 0
return
elif curX > endX or curY > endY:
return
solve(hash,curX+1,curY,endX,endY,val)
solve(hash,curX,curY+1,endX,endY,val)
'''
t = inp()
for i in range(t):
x1,y1,x2,y2 = invr()
no_D = x2-x1
no_R = y2-y1
res = no_D*no_R+1
print(res)
``` | output | 1 | 28,440 | 15 | 56,881 |
Provide tags and a correct Python 2 solution for this coding contest problem.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image> | instruction | 0 | 28,441 | 15 | 56,882 |
Tags: math
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
mod=10**9+7
def ni():
return int(raw_input())
def li():
return map(int,raw_input().split())
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
for t in range(ni()):
x1,y1,x2,y2=li()
m=x2-x1
n=y2-y1
pn((n*m)+1)
``` | output | 1 | 28,441 | 15 | 56,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image>
Submitted Solution:
```
t = int(input())
for _ in range(t):
x1,y1,x2,y2 = map(int,input().split())
if x2>=x1 and y2>=y1:
ans = (x2-x1)*(y2-y1)+1
else:
ans = 0
print(ans)
``` | instruction | 0 | 28,442 | 15 | 56,884 |
Yes | output | 1 | 28,442 | 15 | 56,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows:
<image> The cell with coordinates (x, y) is at the intersection of x-th row and y-th column. Upper left cell (1,1) contains an integer 1.
The developers of the SUM function don't sleep either. Because of the boredom, they teamed up with the developers of the RAND function, so they added the ability to calculate the sum on an arbitrary path from one cell to another, moving down or right. Formally, from the cell (x,y) in one step you can move to the cell (x+1, y) or (x, y+1).
After another Dinwows update, Levian started to study "Celex-2021" (because he wants to be an accountant!). After filling in the table with the GAZ-GIZ function, he asked you to calculate the quantity of possible different amounts on the path from a given cell (x_1, y_1) to another given cell (x_2, y_2), if you can only move one cell down or right.
Formally, consider all the paths from the cell (x_1, y_1) to cell (x_2, y_2) such that each next cell in the path is located either to the down or to the right of the previous one. Calculate the number of different sums of elements for all such paths.
Input
The first line contains one integer t (1 β€ t β€ 57179) β the number of test cases.
Each of the following t lines contains four natural numbers x_1, y_1, x_2, y_2 (1 β€ x_1 β€ x_2 β€ 10^9, 1 β€ y_1 β€ y_2 β€ 10^9) β coordinates of the start and the end cells.
Output
For each test case, in a separate line, print the number of possible different sums on the way from the start cell to the end cell.
Example
Input
4
1 1 2 2
1 2 2 4
179 1 179 100000
5 7 5 7
Output
2
3
1
1
Note
In the first test case there are two possible sums: 1+2+5=8 and 1+3+5=9. <image>
Submitted Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
##############################################################
arr = []
s = set()
mp = {}
a, b, c, d = 0, 0, 0, 0
def call(i, j, sum):
global arr
if i > c or j > d:
return
if i == c and j == d:
tot = sum + arr[i][j]
s.add(tot)
if tot not in mp:
mp[tot] = 0
mp[tot] += 1
return
call(i+1, j, sum + arr[i][j])
call(i, j+1, sum + arr[i][j])
def generate():
global arr
SZ = 100
arr = [[0 for _ in range(SZ)] for _ in range(SZ)]
cnt = 1
for i in range(SZ):
r, c = 0, i
for j in range(c, -1, -1):
arr[r][j] = cnt
r += 1
cnt += 1
# print(arr)
def main():
generate()
t = input1()
for ci in range(t):
global a, b, c, d, s, mp
[a, b, c, d] = input_array()
print((c-a) * (d-b) + 1)
pass
if __name__ == '__main__':
# READ('in.txt')
main()
``` | instruction | 0 | 28,443 | 15 | 56,886 |
Yes | output | 1 | 28,443 | 15 | 56,887 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.