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.
There is a rectangular grid of size n Γ m. Each cell has a number written on it; the number on the cell (i, j) is a_{i, j}. Your task is to calculate the number of paths from the upper-left cell (1, 1) to the bottom-right cell (n, m) meeting the following constraints:
* You can move to the right or to the bottom only. Formally, from the cell (i, j) you may move to the cell (i, j + 1) or to the cell (i + 1, j). The target cell can't be outside of the grid.
* The xor of all the numbers on the path from the cell (1, 1) to the cell (n, m) must be equal to k (xor operation is the bitwise exclusive OR, it is represented as '^' in Java or C++ and "xor" in Pascal).
Find the number of such paths in the given grid.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 20, 0 β€ k β€ 10^{18}) β the height and the width of the grid, and the number k.
The next n lines contain m integers each, the j-th element in the i-th line is a_{i, j} (0 β€ a_{i, j} β€ 10^{18}).
Output
Print one integer β the number of paths from (1, 1) to (n, m) with xor sum equal to k.
Examples
Input
3 3 11
2 1 5
7 10 0
12 6 4
Output
3
Input
3 4 2
1 3 3 3
0 3 3 2
3 0 1 1
Output
5
Input
3 4 1000000000000000000
1 3 3 3
0 3 3 2
3 0 1 1
Output
0
Note
All the paths from the first example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (3, 3);
* (1, 1) β (1, 2) β (2, 2) β (3, 2) β (3, 3).
All the paths from the second example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (2, 4) β (3, 4);
* (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4);
* (1, 1) β (1, 2) β (1, 3) β (2, 3) β (3, 3) β (3, 4).
Submitted Solution:
```
n, m, k = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int, input().split())))
if n == 1 or m == 1:
d = []
for v in a:
d += v
r = 0
for i in d:
r ^= i
if r == k:
print(1)
else:
b = []
for i in range(n):
temp = []
for j in range(m):
temp.append([])
b.append(temp)
for i in range((n + m) // 2):
for j in range(min(i + 1, m, n)):
if i == 0:
b[j][i - j].append(a[j][i - j])
elif j == 0:
b[j][i - j].append(b[j][i - j - 1][0] ^ a[j][i - j])
elif j == i:
b[j][i - j].append(b[j - 1][i - j][0] ^ a[j][i - j])
else:
for x in b[j][i - j - 1] + b[j - 1][i - j]:
b[j][i - j].append(x ^ a[j][i - j])
c = []
for i in range(n):
temp = []
for j in range(m):
temp.append([])
c.append(temp)
for i in range((n + m + 1) // 2):
for j in range(min(i + 1, m, n)):
if i == 0:
c[(n - 1) - j][(m - 1) - (i - j)].append(k)
elif j == 0:
c[(n - 1) - j][(m - 1) - (i - j)].append(c[(n - 1) - j][(m - 1) - (i - j - 1)][0] ^ a[(n - 1) - j][(m - 1) - (i - j - 1)])
elif j == i:
c[(n - 1) - j][(m - 1) - (i - j)].append(c[(n - 1) - (j - 1)][(m - 1) - (i - j)][0] ^ a[(n - 1) - (j - 1)][(m - 1) - (i - j)])
else:
for x in c[(n - 1) - j][(m - 1) - (i - j - 1)]:
c[(n - 1) - j][(m - 1) - (i - j)].append(x ^ a[(n - 1) - j][(m - 1) - (i - j - 1)])
for x in c[(n - 1) - (j - 1)][(m - 1) - (i - j)]:
c[(n - 1) - j][(m - 1) - (i - j)].append(x ^ a[(n - 1) - (j - 1)][(m - 1) - (i - j)])
wae = 0
i = (n + m) // 2 - 1
for j in range(min(m, n)):
d = {}
e = {}
for l1 in b[j][i - j]:
if not l1 in d:
d[l1] = 0
d[l1] += 1
for l2 in c[j][i - j]:
if not l2 in e:
e[l2] = 0
e[l2] += 1
for key in d.keys():
if key in d and key in e:
wae += d[key] * e[key]
print(wae)
``` | instruction | 0 | 34,253 | 15 | 68,506 |
No | output | 1 | 34,253 | 15 | 68,507 |
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 has a number written on it; the number on the cell (i, j) is a_{i, j}. Your task is to calculate the number of paths from the upper-left cell (1, 1) to the bottom-right cell (n, m) meeting the following constraints:
* You can move to the right or to the bottom only. Formally, from the cell (i, j) you may move to the cell (i, j + 1) or to the cell (i + 1, j). The target cell can't be outside of the grid.
* The xor of all the numbers on the path from the cell (1, 1) to the cell (n, m) must be equal to k (xor operation is the bitwise exclusive OR, it is represented as '^' in Java or C++ and "xor" in Pascal).
Find the number of such paths in the given grid.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 20, 0 β€ k β€ 10^{18}) β the height and the width of the grid, and the number k.
The next n lines contain m integers each, the j-th element in the i-th line is a_{i, j} (0 β€ a_{i, j} β€ 10^{18}).
Output
Print one integer β the number of paths from (1, 1) to (n, m) with xor sum equal to k.
Examples
Input
3 3 11
2 1 5
7 10 0
12 6 4
Output
3
Input
3 4 2
1 3 3 3
0 3 3 2
3 0 1 1
Output
5
Input
3 4 1000000000000000000
1 3 3 3
0 3 3 2
3 0 1 1
Output
0
Note
All the paths from the first example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (3, 3);
* (1, 1) β (1, 2) β (2, 2) β (3, 2) β (3, 3).
All the paths from the second example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (2, 4) β (3, 4);
* (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4);
* (1, 1) β (1, 2) β (1, 3) β (2, 3) β (3, 3) β (3, 4).
Submitted Solution:
```
import math
from collections import defaultdict
import sys
def main():
n, m, k = map(int, input().split())
g = [[] for _ in range(n)]
for i in range(n):
g[i] = list(map(int, input().split()))
cnt = defaultdict(int)
all = n + m - 2
half = all // 2
res = [0]
def go_start(x, y, val):
val ^= g[x][y]
if x + y == half:
cnt[(x, y, val)] += 1
return
if x+1 < n:
go_start(x + 1, y, val)
if y+1 < m:
go_start(x, y+1, val)
def go_end(x, y, val):
if n-1-x + m-1-y + half == all:
comp = k ^ val
if (x, y, comp) in cnt:
res[0] += 1
return
val ^= g[x][y]
if x > 0:
go_end(x-1, y, val)
if y > 0:
go_end(x, y-1, val)
go_start(0, 0, 0)
go_end(n-1, m-1, 0)
print(res[0])
if __name__ == '__main__':
main()
``` | instruction | 0 | 34,254 | 15 | 68,508 |
No | output | 1 | 34,254 | 15 | 68,509 |
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 has a number written on it; the number on the cell (i, j) is a_{i, j}. Your task is to calculate the number of paths from the upper-left cell (1, 1) to the bottom-right cell (n, m) meeting the following constraints:
* You can move to the right or to the bottom only. Formally, from the cell (i, j) you may move to the cell (i, j + 1) or to the cell (i + 1, j). The target cell can't be outside of the grid.
* The xor of all the numbers on the path from the cell (1, 1) to the cell (n, m) must be equal to k (xor operation is the bitwise exclusive OR, it is represented as '^' in Java or C++ and "xor" in Pascal).
Find the number of such paths in the given grid.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 20, 0 β€ k β€ 10^{18}) β the height and the width of the grid, and the number k.
The next n lines contain m integers each, the j-th element in the i-th line is a_{i, j} (0 β€ a_{i, j} β€ 10^{18}).
Output
Print one integer β the number of paths from (1, 1) to (n, m) with xor sum equal to k.
Examples
Input
3 3 11
2 1 5
7 10 0
12 6 4
Output
3
Input
3 4 2
1 3 3 3
0 3 3 2
3 0 1 1
Output
5
Input
3 4 1000000000000000000
1 3 3 3
0 3 3 2
3 0 1 1
Output
0
Note
All the paths from the first example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (3, 3);
* (1, 1) β (1, 2) β (2, 2) β (3, 2) β (3, 3).
All the paths from the second example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (2, 4) β (3, 4);
* (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4);
* (1, 1) β (1, 2) β (1, 3) β (2, 3) β (3, 3) β (3, 4).
Submitted Solution:
```
n, m, k = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
ma = {}
n1 = (n + m - 2) // 2
for mask in range(1 << n1):
s, x, y = 0, 0, 0
for i in range(n1):
if not(0 <= x < n and 0 <= y < m):
break
s ^= a[x][y]
if (mask >> i) & 1:
x += 1
else:
y += 1
else:
if not(0 <= x < n and 0 <= y < m):
continue
s ^= a[x][y]
ma[(x, y)] = ma.get((x, y), set()) | {s}
rez = 0
n2 = n + m - 2 - n1
for mask in range(1 << n2):
s, x, y = 0, n-1, m-1
for i in range(n2):
if not(0 <= x < n and 0 <= y < m):
break
s ^= a[x][y]
if (mask >> i) & 1:
x -= 1
else:
y -= 1
else:
if not(0 <= x < n and 0 <= y < m):
continue
if s ^ k in ma[(x, y)]:
rez += 1
print(rez)
# Mon Dec 14 2020 22:02:50 GMT+0300 (ΠΠΎΡΠΊΠ²Π°, ΡΡΠ°Π½Π΄Π°ΡΡΠ½ΠΎΠ΅ Π²ΡΠ΅ΠΌΡ)
``` | instruction | 0 | 34,255 | 15 | 68,510 |
No | output | 1 | 34,255 | 15 | 68,511 |
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 has a number written on it; the number on the cell (i, j) is a_{i, j}. Your task is to calculate the number of paths from the upper-left cell (1, 1) to the bottom-right cell (n, m) meeting the following constraints:
* You can move to the right or to the bottom only. Formally, from the cell (i, j) you may move to the cell (i, j + 1) or to the cell (i + 1, j). The target cell can't be outside of the grid.
* The xor of all the numbers on the path from the cell (1, 1) to the cell (n, m) must be equal to k (xor operation is the bitwise exclusive OR, it is represented as '^' in Java or C++ and "xor" in Pascal).
Find the number of such paths in the given grid.
Input
The first line of the input contains three integers n, m and k (1 β€ n, m β€ 20, 0 β€ k β€ 10^{18}) β the height and the width of the grid, and the number k.
The next n lines contain m integers each, the j-th element in the i-th line is a_{i, j} (0 β€ a_{i, j} β€ 10^{18}).
Output
Print one integer β the number of paths from (1, 1) to (n, m) with xor sum equal to k.
Examples
Input
3 3 11
2 1 5
7 10 0
12 6 4
Output
3
Input
3 4 2
1 3 3 3
0 3 3 2
3 0 1 1
Output
5
Input
3 4 1000000000000000000
1 3 3 3
0 3 3 2
3 0 1 1
Output
0
Note
All the paths from the first example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (3, 3);
* (1, 1) β (1, 2) β (2, 2) β (3, 2) β (3, 3).
All the paths from the second example:
* (1, 1) β (2, 1) β (3, 1) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (3, 2) β (3, 3) β (3, 4);
* (1, 1) β (2, 1) β (2, 2) β (2, 3) β (2, 4) β (3, 4);
* (1, 1) β (1, 2) β (2, 2) β (2, 3) β (3, 3) β (3, 4);
* (1, 1) β (1, 2) β (1, 3) β (2, 3) β (3, 3) β (3, 4).
Submitted Solution:
```
n, m, k = map(int, input().split())
l = [list(map(int, input().split())) for _ in range(n)]
re = 0
half = (m + n - 2) // 2
d = [dict() for _ in range(22)]
def forward(i, j, value):
if i + 1 >= n and j + 1 >= m:
return
if i + j == half:
tmp = value^l[i][j]
if tmp in d[i]:
d[i][tmp] += 1
else:
d[i][tmp] = 1
return None
forward(i+1, j, value^l[i+1][j])
forward(i, j+1, value^l[i][j+1])
def backward(i, j, value):
if i < 0 or j < 0:
return
if i + j == m - 1:
tmp = k^value
if tmp in d[i]:
global re
re += d[i][tmp]
return None
backward(i-1, j, value^l[i-1][j])
backward(i, j-1, value^l[i][j-1])
forward(0, 0, l[0][0])
backward(n-1, m-1, l[n-1][m-1])
print(re)
``` | instruction | 0 | 34,256 | 15 | 68,512 |
No | output | 1 | 34,256 | 15 | 68,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,350 | 15 | 68,700 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
import sys
n, m, k, q = [int(i) for i in sys.stdin.readline().split()]
indata = sys.stdin.readlines()
data = []
inf = 1<<50
for i in range(k):
data.append(tuple([int(f) for f in indata[i].split()]))
data.sort()
chutes = [int(i) for i in indata[-1].split()]
chutes.sort()
nearch = [(0,0)]*(m+1)
for i in range(1, chutes[0]+1):
nearch[i] = (chutes[0], chutes[0])
for i in range(q-1):
a = chutes[i]
b = chutes[i+1]
for j in range(a+1, b):
nearch[j] = (a,b)
nearch[b] = (b,b)
for i in range(chutes[-1], m+1):
nearch[i] = (chutes[-1],chutes[-1])
lastr = -1
rows = []
rowdata = {}
for d in data:
if d[0] != lastr:
lastr = d[0]
rows.append(d[0])
rowdata[d[0]] = []
rowdata[d[0]].append(d[1])
dp = [ [ (1, 0), (1, 0) ] ]
start = 0
if rows[0] == 1:
#1+' '
#dp[0] = [ (rowdata[1][-1], rowdata[1][-1] - 1 ) , (rowdata[1][0], 2 * rowdata[1][-1] - rowdata[1][0] - 1) ]
dp[0] = [ (rowdata[1][-1], rowdata[1][-1] - 1 ) , (1, inf) ]
start = 1
lnr = len(rows)
for i in range(start, lnr):
row = rowdata[rows[i]]
# ldp = dp[-1]
LR = (0,inf)
for f in range(4):
ldp = dp[-1][f//2]
am = ldp[1]
d = nearch[ldp[0]][f%2]
am += abs(ldp[0] - d)
am += abs(d - row[0])
am += row[-1] - row[0]
if am < LR[1]:
LR = (row[-1], am)
RL = (0,inf)
for f in range(4):
ldp = dp[-1][f//2]
am = ldp[1]
d = nearch[ldp[0]][f%2]
am += abs(ldp[0] - d)
am += abs(d - row[-1])
am += row[-1] - row[0]
if am < RL[1]:
RL = (row[0], am)
dp.append([LR, RL])
# print(rows)
# print(rowdata)
# print(dp)
print(min(dp[-1][0][1], dp[-1][1][1]) + rows[-1] - 1)
``` | output | 1 | 34,350 | 15 | 68,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,351 | 15 | 68,702 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
from sys import setrecursionlimit as SRL, stdin
SRL(10 ** 7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
left = [1000000] * 200005
right = [0] * 200005
n, m, k, q = rrd()
lst = 0
while k:
x, y = rrd()
left[x] = min(y, left[x])
right[x] = max(right[x], y)
lst = max(lst,x)
k -= 1
qt = list(rrd())
qt.sort()
from bisect import *
pre = [1] * 4
dpp = [0] * 4
dpn = [0] * 4
for i in range(1, lst):
now = [0] * 4
dpn = [500000000000] * 4
if not right[i]:
dpp = list(map(lambda x: x+1,dpp))
if i == 1:
pre = [qt[0]]*4
dpp = [qt[0]]*4
continue
l = bisect_left(qt, left[i])
r = bisect_left(qt, right[i])
if l<q and qt[l] == left[i]:
now[0] = qt[l]
now[1] = qt[l]
else:
now[0] = qt[l - 1] if l else 0
now[1] = qt[l] if l < q else 0
if r<q and qt[r] == right[i]:
now[2] = qt[r]
now[3] = qt[r]
else:
now[2] = qt[r - 1] if r else 0
now[3] = qt[r] if r < q else 0
# print(i, left[i], right[i], l, r, now)
for j in range(4):
if not now[j]:
continue
for k in range(4):
if not pre[k]:
continue
l = min(abs(right[i] - pre[k]) + abs(left[i] - now[j]), abs(right[i] - now[j]) + abs(left[i] - pre[k])) + 1
dpn[j] = min(dpn[j], dpp[k] + right[i] - left[i] + l)
pre = now[:]
dpp = dpn[:]
ans =min(dpp[i]+right[lst]-left[lst]+min(abs(pre[i]-left[lst]),abs(pre[i]-right[lst])) for i in range(4))
print(ans)
``` | output | 1 | 34,351 | 15 | 68,703 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,352 | 15 | 68,704 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
import sys
n, m, k, q = list(map(int, sys.stdin.readline().strip().split()))
T = [0] * k
for i in range (0, k):
T[i] = list(map(int, sys.stdin.readline().strip().split()))
T[i][1] = T[i][1] - 1
T[i][0] = T[i][0] - 1
T.sort() # treasures sorted by row
b = list(map(int, sys.stdin.readline().strip().split()))
b.sort()
for i in range (0, q):
b[i] = b[i] - 1 # sorted safe columns
L = [b[0]] * m # safe column left
R = [b[-1]] * m # safe column right
R1 = [10 ** 6] * n # leftmost treasure
R2 = [-1] * n # rightmost treasure
n1 = 0 # pathlength 1
n2 = 0 # pathlength 2
for i in range (0, k):
R1[T[i][0]] = min(R1[T[i][0]], T[i][1])
R2[T[i][0]] = max(R2[T[i][0]], T[i][1])
for i in range (0, q):
L[b[i]] = b[i]
R[b[i]] = b[i]
for i in range (1, m):
L[i] = max([L[i-1], L[i]])
R[m-i-1] = min([R[m-i], R[m-i-1]])
r = 0
c1 = 0
c2 = 0
n1 = 0
n2 = 0
if R2[0] != -1:
c1 = R2[0]
c2 = R2[0]
n1 = R2[0]
n2 = R2[0]
for i in range (1, n):
if R2[i] != -1:
r, c1, c2, n2, n1 = i, R1[i], R2[i], i-r+abs(R1[i]-R2[i])+min([n1+abs(c1-L[c1])+abs(R1[i]-L[c1]), n2+abs(c2-L[c2])+abs(R1[i]-L[c2]), n1+abs(c1-R[c1])+abs(R1[i]-R[c1]), n2+abs(c2-R[c2])+abs(R1[i]-R[c2])]), i-r+abs(R1[i]-R2[i])+min([n1+abs(c1-L[c1])+abs(R2[i]-L[c1]), n2+abs(c2-L[c2])+abs(R2[i]-L[c2]), n1+abs(c1-R[c1])+abs(R2[i]-R[c1]), n2+abs(c2-R[c2])+abs(R2[i]-R[c2])])
print(min([n1, n2]))
``` | output | 1 | 34,352 | 15 | 68,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,353 | 15 | 68,706 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
# see bisect module:
# https://codeforces.com/contest/1201/submission/58302708
# python complexity:
# https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
# solve using DP
n, m, k, q = map(int, input().split())
# n rows
# m cols
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
# binary search? :)
def binsearch(arr, val):
l, r = 0, len(arr)-1
while l <= r:
mid = l + (r - l) // 2
if (arr[mid] < val):
l = mid + 1
elif (arr[mid] > val):
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A) # this is invariant
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = m*m
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = 0, 0
found_valid = False
last_valid = None
for row in range(0, n):
#insert idea here
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = (tr_max[row] - tr_min[row])
r = (tr_max[row] - tr_min[row])
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
#l += min(ll, rl) + 1 + (tr_max[row] - tr_min[row])
#r += min(lr, rr) + 1 + (tr_max[row] - tr_min[row])
#l, r = r, l
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = new_l, new_r
last_valid = row
# insert last step on row n here
answ = l + tr_min[last_valid]
print(answ)
``` | output | 1 | 34,353 | 15 | 68,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,354 | 15 | 68,708 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
def nearest(point):
l = 0
r = q
while r - l > 1:
mid = int((r + l) / 2)
if safe[mid] <= point:
l = mid
else:
r = mid
if safe[l] > point:
return [safe[l]]
elif l + 1 == q:
return [safe[l]]
else:
return [safe[l], safe[l + 1]]
def way(come, row, side=True):
between = abs(right[row] - left[row])
if side:
return abs(come - left[row]) + between
else:
return abs(come - right[row]) + between
n, m, k, q = [int(x) for x in input().split()]
right = [-1] * n
left = [-1] * n
for i in range(k):
a, b = [int(x) - 1 for x in input().split()]
if right[a] == -1:
right[a] = left[a] = b
else:
right[a] = max(right[a], b)
left[a] = min(left[a], b)
safe = [int(x) - 1 for x in input().split()]
safe.sort()
left[0] = right[0]
if right[0] == -1:
L = R = min(nearest(0))
right[0] = left[0] = L
else:
L = R = right[0]
while right[n - 1] == -1:
n -= 1
last = 0
for i in range(1, n):
# print(last)
# print(L, R)
L += 1
R += 1
if right[i] == -1:
continue
left_way = 100000000000
right_way = 100000000000
lcolumns = nearest(left[last])
rcolumns = nearest(right[last])
for c in lcolumns:
left_way = min(left_way, L + way(c, i, False) + abs(c - left[last]))
right_way = min(right_way, L + way(c, i, True) + abs(c - left[last]))
for c in rcolumns:
left_way = min(left_way, R + way(c, i, False) + abs(c - right[last]))
right_way = min(right_way, R + way(c, i, True) + abs(c - right[last]))
# print(left_way, right_way)
L = left_way
R = right_way
last = i
print(min(L, R))#+ (n - 1))
``` | output | 1 | 34,354 | 15 | 68,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,355 | 15 | 68,710 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
from bisect import *
n, m, k, q = map(int, input().split())
right = [-1] * n
left = [-1] * n
for i in range(k):
row, col = map(int, input().split())
row -= 1
col -= 1
if right[row] == -1:
right[row] = left[row] = col
else:
right[row] = max(right[row], col)
left[row] = min(left[row], col)
safe = sorted(list(map(lambda qi: int(qi) - 1, input().split())))
# print(safe)
def dist(lower, upper, row):
posr = bisect_left(safe, lower)
options = []
if posr < len(safe):
options.append(safe[posr] - lower + abs(safe[posr] - upper))
posl = posr - 1
if posl >= 0:
options.append(lower - safe[posl] + abs(upper - safe[posl]))
return min(options)
if left[0] == -1:
left[0] = right[0] = 0
dleft = right[0] + (right[0] - left[0])
dright = right[0]
lastn = 0
for i in range(1, n):
if left[i] == -1:
continue
ilen = right[i] - left[i]
dleft_new = min(dleft + dist(left[lastn], right[i], i), dright + dist(right[lastn], right[i], i)) + ilen
dright_new = min(dleft + dist(left[lastn], left[i], i), dright + dist(right[lastn], left[i], i)) + ilen
dleft, dright = dleft_new, dright_new
lastn = i
print(min(dleft, dright) + lastn)
``` | output | 1 | 34,355 | 15 | 68,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,356 | 15 | 68,712 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
import bisect
n, m, k, q = map(int, input().split())
# min, max
vals = {}
vals[1] = [1, 1]
for i in range(k):
r, c = map(int, input().split())
if r not in vals:
vals[r] = [c, c]
else:
vals[r][0] = min(vals[r][0], c)
vals[r][1] = max(vals[r][1], c)
q = list(map(int, input().split()))
q.sort()
def find_shortest(lower, upper, row):
if row==1:
return upper-1
if lower > upper:
return find_shortest(upper, lower, row)
pos = bisect.bisect_left(q, lower)
options = []
if pos < len(q):
if q[pos]<=upper:
return upper-lower
else:
options.append(q[pos] - lower + q[pos] - upper)
pos2 = bisect.bisect_left(q, lower) - 1
if pos2 >= 0:
options.append(lower - q[pos2] + upper - q[pos2])
return min(options)
highest = 1
old_a, old_b = 0, 0
pos_a, pos_b = 1, 1
for row in range(1, n+1):
if not row in vals:
continue
highest = row
row_min, row_max = vals[row]
new_a = min(old_a + find_shortest(pos_a, row_max, row), old_b + find_shortest(pos_b, row_max, row)) + row_max - row_min
new_b = min(old_a + find_shortest(pos_a, row_min, row), old_b + find_shortest(pos_b, row_min, row)) + row_max - row_min
old_a, old_b = new_a, new_b
pos_a, pos_b = row_min, row_max
#print(old_a, old_b)
total = highest - 1
total += min(old_a, old_b)
print(total)
``` | output | 1 | 34,356 | 15 | 68,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image> | instruction | 0 | 34,357 | 15 | 68,714 |
Tags: binary search, dp, greedy, implementation
Correct Solution:
```
import sys
from bisect import bisect_left,bisect_right
input=sys.stdin.readline
n,m,k,q=map(int,input().split())
treasure=[[]for i in range(n)]
for _ in range(k):
x,y=map(int,input().split())
treasure[x-1].append(y-1)
safe=list(map(int,input().split()))
for i in range(q):
safe[i]-=1
safe.sort()
left=0
right=1
real=[[-1,-1] for i in range(n)]
for i in range(n):
if treasure[i]:
real[i][left]=min(treasure[i])
real[i][right]=max(treasure[i])
dp=[[0,0] for i in range(n)]
if real[0][right]!=-1:
dp[0][left]=real[0][right]
dp[0][right]=real[0][right]
real[0][left]=real[0][right]
else:
dp[0][left]=0
dp[0][right]=0
real[0][left]=0
real[0][right]=0
def go(a,b):
if a<b: a,b=b,a
bl=bisect_left(safe,b)
ar=bisect_right(safe,a)
if ar>bl: return a-b+1
else:
ret=int(1e9)
al=bisect_left(safe,a)
br=bisect_right(safe,b)
if al!=q:
ret=min((safe[al]-a)*2+1+a-b,ret)
if br!=0:
ret=min((b-safe[br-1])*2+1+a-b,ret)
return ret
cnt=0
pre=0
maxx=0
for i in range(1,n):
if real[i][left]==-1:
cnt+=1
else:
dp[i][left]=min(dp[pre][right]+go(real[pre][right],real[i][right]),dp[pre][left]+go(real[pre][left],real[i][right]))+cnt+real[i][right]-real[i][left]
dp[i][right]=min(dp[pre][right]+go(real[pre][right],real[i][left]),dp[pre][left]+go(real[pre][left],real[i][left]))+cnt+real[i][right]-real[i][left]
cnt=0
pre=i
print(min(dp[pre]))
``` | output | 1 | 34,357 | 15 | 68,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
[n,m,k,q] = [int(w) for w in input().split()]
trs = [[int(w)-1 for w in input().split()] for _ in range(k)]
b = [int(w)-1 for w in input().split()]
b.sort()
b.append(b[-1])
br = bl = 0
er = []
el = []
for i in range(m):
if br < q and i > b[br]:
bl = br
br += 1
el.append(b[bl])
er.append(b[br])
for x in b:
el[x] = er[x] = x
g = [None for _ in range(n)]
dy = 0
for r,c in trs:
if g[r] is None:
g[r] = c,c
else:
a,b = g[r]
if c < a:
g[r] = c,b
elif c > b:
g[r] = a,c
if r > dy:
dy = r
if g[0] is not None:
_,xr = g[0]
else:
xr = 0
dxl = dxr = xl = xr
for i in range(1,n):
if g[i] is None:
continue
gl,gr = g[i]
d = gr-gl
dxr, dxl = (d + min(dxl + abs(gl-el[xl]) + abs(xl-el[xl]),
dxl + abs(gl-er[xl]) + abs(xl-er[xl]),
dxr + abs(gl-el[xr]) + abs(xr-el[xr]),
dxr + abs(gl-er[xr]) + abs(xr-er[xr])),
d + min(dxl + abs(gr-el[xl]) + abs(xl-el[xl]),
dxl + abs(gr-er[xl]) + abs(xl-er[xl]),
dxr + abs(gr-el[xr]) + abs(xr-el[xr]),
dxr + abs(gr-er[xr]) + abs(xr-er[xr])))
xl,xr = gl,gr
print(min(dxl,dxr)+dy)
``` | instruction | 0 | 34,358 | 15 | 68,716 |
Yes | output | 1 | 34,358 | 15 | 68,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,m,k,q=map(int,input().split())
TR=[list(map(int,input().split())) for i in range(k)]
SAFE=list(map(int,input().split()))
SAFE.sort()
TRLIST=[[] for i in range(n+1)]
for x,y in TR:
TRLIST[x].append(y)
while TRLIST[-1]==[]:
TRLIST.pop()
n-=1
START={1:0} #place,step
import bisect
for step in range(1,n):
if TRLIST[step]==[] and step!=1:
continue
elif TRLIST[step]==[] and step==1:
MIN=MAX=1
else:
MIN=min(TRLIST[step])
MAX=max(TRLIST[step])
MINind=max(0,bisect.bisect_left(SAFE,MIN)-1)
MIN_L=SAFE[MINind]
if MINind==q-1:
MIN_R=MIN_L
else:
MIN_R=SAFE[MINind+1]
MAXind=max(0,bisect.bisect_left(SAFE,MAX)-1)
MAX_L=SAFE[MAXind]
if MAXind==q-1:
MAX_R=MAX_L
else:
MAX_R=SAFE[MAXind+1]
NEXT=dict()
for start in START:
st=START[start]
NEXT[MIN_L]=min(st+abs(MAX-start)+abs(MAX-MIN)+abs(MIN_L-MIN),NEXT.get(MIN_L,1<<50))
NEXT[MIN_R]=min(st+abs(MAX-start)+abs(MAX-MIN)+abs(MIN_R-MIN),NEXT.get(MIN_R,1<<50))
NEXT[MAX_L]=min(st+abs(MIN-start)+abs(MAX-MIN)+abs(MAX_L-MAX),NEXT.get(MAX_L,1<<50))
NEXT[MAX_R]=min(st+abs(MIN-start)+abs(MAX-MIN)+abs(MAX_R-MAX),NEXT.get(MAX_R,1<<50))
START=NEXT
#print(START)
LAST=1<<50
if TRLIST[n]==[]:
print(min(START.values())+n-1)
sys.exit()
MIN=min(TRLIST[n])
MAX=max(TRLIST[n])
#print(START)
for start in START:
st=START[start]
LAST=min(LAST,st+abs(MAX-start)+abs(MAX-MIN),st+abs(MIN-start)+abs(MAX-MIN))
print(LAST+n-1)
``` | instruction | 0 | 34,359 | 15 | 68,718 |
Yes | output | 1 | 34,359 | 15 | 68,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
# see bisect module:
# https://codeforces.com/contest/1201/submission/58302708
# python complexity:
# https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
# solve using DP
n, m, k, q = map(int, input().split())
# n rows
# m cols
tr_min = [None for _ in range(n)]
tr_max = [None for _ in range(n)]
for _ in range(k):
row, col = map(int, input().split())
row = n - row
col -= 1
if tr_min[row] == None or col < tr_min[row]:
tr_min[row] = col
if tr_max[row] == None or col > tr_max[row]:
tr_max[row] = col
tr_min[-1] = 0
tr_max[-1] = tr_max[-1] or 0
savecols = sorted(map(lambda t: int(t) - 1, input().split()))
# binary search? :)
def binsearch(arr, val):
l, r = 0, len(arr)-1
while l <= r:
mid = l + (r - l) // 2
if (arr[mid] < val):
l = mid + 1
elif (arr[mid] > val):
r = mid - 1
else:
return mid
return r
def find_short_descent(A, B):
if A > B:
return find_short_descent(B, A) # this is invariant
idx1 = binsearch(savecols, A)
idx2 = idx1 + 1
minval = 2 * m # for both directions
if idx2 < len(savecols):
if savecols[idx2] < B:
return B - A
else:
minval = min(minval, (savecols[idx2] << 1) - A - B)
if idx1 >= 0:
minval = min(minval, A + B - (savecols[idx1] << 1))
return minval
l, r = 0, 0
found_valid = False
last_valid = None
for row in range(0, n):
#insert idea here
if found_valid == False:
if tr_min[row] != None:
found_valid = True
last_valid = row
l = (tr_max[row] - tr_min[row])
r = (tr_max[row] - tr_min[row])
continue
continue
if tr_min[row] == None:
l += 1
r += 1
continue
ll = find_short_descent(tr_min[last_valid], tr_min[row])
lr = find_short_descent(tr_min[last_valid], tr_max[row])
rl = find_short_descent(tr_max[last_valid], tr_min[row])
rr = find_short_descent(tr_max[last_valid], tr_max[row])
#l += min(ll, rl) + 1 + (tr_max[row] - tr_min[row])
#r += min(lr, rr) + 1 + (tr_max[row] - tr_min[row])
#l, r = r, l
new_l = min(l + lr, r + rr) + 1 + (tr_max[row] - tr_min[row])
new_r = min(l + ll, r + rl) + 1 + (tr_max[row] - tr_min[row])
l, r = new_l, new_r
last_valid = row
# insert last step on row n here
answ = l + tr_min[last_valid]
print(answ)
``` | instruction | 0 | 34,360 | 15 | 68,720 |
Yes | output | 1 | 34,360 | 15 | 68,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
from sys import stdin
from bisect import bisect_left
input=stdin.readline
n,m,k,q=map(int,input().split(' '))
x=sorted(list(map(int,input().split(' ')))for i in range(k))
y=sorted(list(map(int,input().split(' '))))
def rr(c0,c1,c2):
return abs(c2-c0)+abs(c1-c2)
def tm(c0,c1):
t=bisect_left(y,c0)
tt=[]
if (t>0):
tt.append(rr(c0,c1,y[t-1]))
if (t<q):
tt.append(rr(c0,c1,y[t]))
return min(tt)
# thα»±c hiα»n tΓ¬m xem trong mα»t hΓ ng, kho bΓ‘u nαΊ±m tα»« khoαΊ£ng nΓ o ΔαΊΏn khoαΊ£ng nΓ o.
z=[]
for r,c in x:
if z and z[-1][0]==r:
z[-1][2]=c
else:
z.append([r,c,c])
v1,v2,r0,c01,c02=0,0,1,1,1
for r1,c11,c12 in z:
d=c12-c11+r1-r0
# bΓ¬nh thΖ°α»ng
if(r1>r0):
d01=tm(c01,c11)
d02=tm(c01,c12)
d11=tm(c02,c11)
d12=tm(c02,c12)
v2,v1=d+min(v1+d01,v2+d11),d +min(v1+d02,v2+d12)
#nαΊΏu cΓ³ kho bΓ‘u α» hΓ ng 1
else:
v1,v2=d+c12-c02,d+c11-c01
c01,c02,r0=c11,c12,r1
ans=min(v1,v2)
print(ans)
``` | instruction | 0 | 34,361 | 15 | 68,722 |
Yes | output | 1 | 34,361 | 15 | 68,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
import sys,atexit
from io import BytesIO
inp = BytesIO(sys.stdin.buffer.read())
input = lambda:inp.readline().decode('ascii')
buf = BytesIO()
sys.stdout.write = lambda s: buf.write(s.encode('ascii'))
atexit.register(lambda:sys.__stdout__.buffer.write(buf.getvalue()))
n,m,k,q = map(int,input().split())
T = [[int(x)-1 for x in input().split()] for _ in range(n)]
safe = [int(x)-1 for x in input().split()]
from collections import defaultdict as dd, deque
Ty = dd(list)
for y,x in T:
Ty[y].append(x)
segs = {}
for y in sorted(Ty):
tmp = sorted(Ty[y])
segs[y] = (tmp[0], tmp[-1])
###
S = [0]*m
for s in safe:
S[s] = 1
inf = 10**9
distL = [inf]*m
d = None
for i in range(m):
if S[i]:
d = 0
if d != None:
distL[i] = d
d += 1
distR = [inf]*m
d = 0
for i in reversed(range(m)):
if S[i]:
d = 0
if d != None:
distR[i] = d
d += 1
###
def cst(fro,to):
best = inf
if distL[fro] != inf:
i = fro - distL[fro]
ncost = distL[fro] + abs(i-to)
best = min(ncost,best)
if distR[fro] != inf:
i = fro + distR[fro]
ncost = distR[fro] + abs(i-to)
best = min(ncost,best)
return best
DP = [[0]*(m+1) for _ in range(2)]
DP[0][-1] = 0
DP[0][-1] = 0
lastl = 0
lastr = 0
mx = max(segs)
for i in range(mx + 1):
if i not in segs:
DP[0][i] = DP[0][i-1] + 1
DP[1][i] = DP[1][i-1] + 1
elif i != 0:
l,r = segs[i]
DP[0][i] = min(
DP[0][i-1] + cst(lastl,r) + r - l,
DP[1][i-1] + cst(lastr,r) + r - l
) + 1
DP[1][i] = min(
DP[0][i-1] + cst(lastl,l) + r - l,
DP[1][i-1] + cst(lastr,l) + r - l
) + 1
lastl = l
lastr = r
else:
l,r = segs[i]
DP[0][i] = DP[0][i-1] + r + (r - l)
DP[1][i] = DP[1][i-1] + l + (r - l)
lastl = l
lastr = r
print(max(DP[0][mx], DP[1][mx]))
``` | instruction | 0 | 34,362 | 15 | 68,724 |
No | output | 1 | 34,362 | 15 | 68,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
import sys
from bisect import bisect_left,bisect_right
input=sys.stdin.readline
n,m,k,q=map(int,input().split())
treasure=[[]for i in range(n)]
for _ in range(k):
x,y=map(int,input().split())
treasure[x-1].append(y-1)
safe=list(map(int,input().split()))
for i in range(q):
safe[i]-=1
safe.sort()
left=0
right=1
real=[[-1,-1] for i in range(n)]
for i in range(n):
if treasure[i]:
real[i][left]=min(treasure[i])
real[i][right]=max(treasure[i])
dp=[[0,0] for i in range(n)]
if real[0][right]!=-1:
dp[0][left]=real[0][right]
dp[0][right]=real[0][right]
else:
dp[0][left]=0
dp[0][right]=0
real[0][left]=0
real[0][right]=0
def go(a,b):
if a<b: a,b=b,a
bl=bisect_left(safe,b)
ar=bisect_right(safe,a)
if ar>bl: return a-b+1
else:
ret=int(1e9)
al=bisect_left(safe,a)
br=bisect_right(safe,b)
if al!=q:
ret=min((safe[al]-a)*2+1+a-b,ret)
if br!=0:
ret=min((b-safe[br-1])*2+1+a-b,ret)
return ret
cnt=0
pre=0
maxx=0
for i in range(1,n):
if real[i][left]==-1:
cnt+=1
else:
dp[i][left]=min(dp[pre][right]+go(real[pre][right],real[i][left]),dp[pre][left]+go(real[pre][left],real[i][left]))+cnt
dp[i][right]=min(dp[pre][right]+go(real[pre][right],real[i][right]),dp[pre][left]+go(real[pre][left],real[i][right]))+cnt
cnt=0
pre=i
print(min(dp[pre]))
``` | instruction | 0 | 34,363 | 15 | 68,726 |
No | output | 1 | 34,363 | 15 | 68,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
l=list(map(int,input().split(" ")))
l1=[]
for i in range(l[2]):
l1.append(list(map(int,input().split(" "))))
l2=list(map(int,input().split(" ")))
s=l1[0][1]-1
for i in range(l[2]-1):
maxi=999
a=l1[i][1]
b=l1[i+1][1]
for j in l2:
s1=abs(j-a)+1+abs(j-b)
if (s1<maxi):
maxi=s1
s=s+maxi
print(s)
``` | instruction | 0 | 34,364 | 15 | 68,728 |
No | output | 1 | 34,364 | 15 | 68,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are on the island which can be represented as a n Γ m table. The rows are numbered from 1 to n and the columns are numbered from 1 to m. There are k treasures on the island, the i-th of them is located at the position (r_i, c_i).
Initially you stand at the lower left corner of the island, at the position (1, 1). If at any moment you are at the cell with a treasure, you can pick it up without any extra time. In one move you can move up (from (r, c) to (r+1, c)), left (from (r, c) to (r, c-1)), or right (from position (r, c) to (r, c+1)). Because of the traps, you can't move down.
However, moving up is also risky. You can move up only if you are in a safe column. There are q safe columns: b_1, b_2, β¦, b_q. You want to collect all the treasures as fast as possible. Count the minimum number of moves required to collect all the treasures.
Input
The first line contains integers n, m, k and q (2 β€ n, m, k, q β€ 2 β
10^5, q β€ m) β the number of rows, the number of columns, the number of treasures in the island and the number of safe columns.
Each of the next k lines contains two integers r_i, c_i, (1 β€ r_i β€ n, 1 β€ c_i β€ m) β the coordinates of the cell with a treasure. All treasures are located in distinct cells.
The last line contains q distinct integers b_1, b_2, β¦, b_q (1 β€ b_i β€ m) β the indices of safe columns.
Output
Print the minimum number of moves required to collect all the treasures.
Examples
Input
3 3 3 2
1 1
2 1
3 1
2 3
Output
6
Input
3 5 3 2
1 2
2 3
3 1
1 5
Output
8
Input
3 6 3 2
1 6
2 2
3 4
1 6
Output
15
Note
In the first example you should use the second column to go up, collecting in each row treasures from the first column.
<image>
In the second example, it is optimal to use the first column to go up.
<image>
In the third example, it is optimal to collect the treasure at cell (1;6), go up to row 2 at column 6, then collect the treasure at cell (2;2), go up to the top row at column 1 and collect the last treasure at cell (3;4). That's a total of 15 moves.
<image>
Submitted Solution:
```
n, m, k, q = map(int,input().split())
izq = [float('inf')]*n
der = [0]*n
for i in range(k):
r,c = map(int,input().split())
if c < izq[r-1]:
izq[r-1] = c
if c > der[r-1]:
der[r-1] = c
seguras = list(map(int,input().split()))
fila = der[0]-1
subir = float('inf')
for i in range(q):
if subir > abs(seguras[i]-der[0]):
subir = abs(seguras[i]-der[0])
pos = seguras[i]
fila += subir + 1
#print(fila,subir,pos)
for i in range(1,n-1):
subir = float('inf')
if izq[i] == float('inf'):
subir = 0
elif izq[i] == der[i]:
fila += abs(izq[i]-pos)
for j in range(q):
if subir > abs(seguras[j]-der[i]):
subir = abs(seguras[j]-der[i])
pos = seguras[j]
else:
fila += (der[i]-izq[i])
if izq[i] < der[i]:
fila += izq[i]
pos = der[i]
else:
fila += der[i]
pos = izq[i]
for j in range(q):
if subir > abs(seguras[j]-pos):
subir = abs(seguras[j]-pos)
pos = seguras[j]
fila += subir + 1
#print(fila,subir,pos)
if izq[n-1] == float('inf'):
subir = 0
elif izq[n-1] == der[n-1]:
fila += abs(izq[n-1]-pos)
else:
fila += min(izq[n-1],der[n-1]) + (der[n-1]-izq[n-1])
print(fila)
``` | instruction | 0 | 34,365 | 15 | 68,730 |
No | output | 1 | 34,365 | 15 | 68,731 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,584 | 15 | 69,168 |
Tags: binary search, implementation, math
Correct Solution:
```
dx = {'U': 0, 'D': 0, 'L': -1, 'R': 1}
dy = {'U': 1, 'D': -1, 'L': 0, 'R': 0}
x, y, xl, yl = 0, 0, [], []
a, b = map(int, input().split())
for ch in input():
xl.append(x)
yl.append(y)
x += dx[ch]
y += dy[ch]
for xi, yi in zip(xl, yl):
mx, my = a - xi, b - yi
if x == 0 and mx != 0 or x != 0 and (mx % x != 0 or mx // x < 0):
continue
if y == 0 and my != 0 or y != 0 and (my % y != 0 or my // y < 0):
continue
if x != 0 and y != 0 and mx // x != my // y:
continue
print('Yes')
exit()
print('No')
# Made By Mostafa_Khaled
``` | output | 1 | 34,584 | 15 | 69,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,585 | 15 | 69,170 |
Tags: binary search, implementation, math
Correct Solution:
```
a,b=input().split()
a=int(a)
b=int(b)
s=input()
n=len(s)
L=[]
x=0
y=0
hor=s.count('R')-s.count('L')
ver=s.count('U')-s.count('D')
L=[[0,0]]
for i in range(n):
if(s[i]=='U'):
y+=1
elif(s[i]=='D'):
y-=1
elif(s[i]=='R'):
x+=1
else:
x-=1
L.append([x,y])
k=True
for i in range(n+1):
x=L[i][0]
y=L[i][1]
if(hor==0 and ver==0 and x==a and b==y):
print('Yes')
k=False
break
elif(hor==0 and ver!=0 and x==a and (b-y)%ver==0 and (b-y)*ver>=0):
print('Yes')
k=False
break
elif(ver==0 and hor!=0 and y==b and (a-x)%hor==0 and (a-x)*hor>=0):
print('Yes')
k=False
break
elif(ver!=0 and hor!=0 and(b-y)%ver==0 and ver*(b-y)>=0 and (a-x)%hor==0 and hor*(a-x)>=0 and(b-y)//ver==(a-x)//hor):
print('Yes')
k=False
break
if(k):
print('No')
``` | output | 1 | 34,585 | 15 | 69,171 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,586 | 15 | 69,172 |
Tags: binary search, implementation, math
Correct Solution:
```
a, b = (int(x) for x in input().split())
s = input()
if (a, b) == (0, 0):
print('Yes')
exit()
cur = (0, 0)
poss = []
for c in s:
poss.append(cur)
if c == 'U':
cur = (cur[0], cur[1] + 1)
elif c == 'D':
cur = (cur[0], cur[1] - 1)
elif c == 'L':
cur = (cur[0] - 1, cur[1])
else:
cur = (cur[0] + 1, cur[1])
if cur[0] == 0 and cur[1] == 0:
print('Yes' if (a, b) in poss else 'No')
exit()
for (x, y) in poss:
if cur[0] != 0 and (a - x) % cur[0] != 0: continue
if cur[1] != 0 and (b - y) % cur[1] != 0: continue
if (a - x) * cur[0] < 0 or (b - y) * cur[1] < 0: continue
if (a - x) * cur[1] == (b - y) * cur[0]:
print('Yes')
exit()
print('No')
``` | output | 1 | 34,586 | 15 | 69,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,587 | 15 | 69,174 |
Tags: binary search, implementation, math
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq 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")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=998244353
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
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 dif(a,b):
if(a > 0 and b < 0): return True
if(b > 0 and a < 0): return True
return False
a,b = value()
s = input()
C = Counter(s)
X = C['R'] - C['L']
Y = C['U'] - C['D']
x = 0
y = 0
ans = "No"
if((x,y) == (a,b)): ans = "Yes"
for i in s:
if(i == 'R'): x += 1
elif(i == 'L'): x -= 1
elif(i == 'U'): y += 1
else: y -= 1
need_x = a - x
need_y = b - y
ok = True
if((x,y) == (a,b)): ans = "Yes"
if(need_x == 0 or X == 0):
if(need_x != X): ok = False
else: flag1 = -1
elif( dif(X,need_x) or abs(need_x)%abs(X)):
ok = False
else:
flag1 = abs(need_x)//abs(X)
if(need_y == 0 or Y == 0):
if(need_y != Y): ok = False
else: flag2 = -1
elif( dif(Y,need_y) or abs(need_y)%abs(Y)):
ok = False
else:
flag2 = abs(need_y)//abs(Y)
if(ok and (flag2 == flag1 or flag1 == -1 or flag2 == -1)): ans = "Yes"
# print(X,need_x,Y,need_y,ans)
# print(x,y,ok)
print(ans)
``` | output | 1 | 34,587 | 15 | 69,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,588 | 15 | 69,176 |
Tags: binary search, implementation, math
Correct Solution:
```
dx = 0
dy = 0
a, b = list(map(int,input().split()))
s = input()
for i in s:
if i == 'U':
dy += 1
elif i == 'D':
dy -= 1
elif i == 'L':
dx -= 1
else:
dx += 1
x0 = 0
y0 = 0
for i in s:
if i == 'U':
y0 += 1
elif i == 'D':
y0 -= 1
elif i == 'L':
x0 -= 1
else:
x0 += 1
if (a-x0)*dy == (b-y0)*dx and (dx == 0 and x0 == a or dx != 0 and (a-x0)%dx == 0 and (a-x0)//dx >= -1) and (dy == 0 and y0 == b or dy != 0 and (b-y0)%dy == 0 and (b-y0)//dy >= -1):
print('Yes')
exit()
print('No')
``` | output | 1 | 34,588 | 15 | 69,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,589 | 15 | 69,178 |
Tags: binary search, implementation, math
Correct Solution:
```
x,y = map(int,input().split())
#print(x,y)
s = input()
#print(s)
pt = (0,0)
path = [(0,0)]
rect = [0,0,1,1]
for c in s:
if c == 'U': pt = (pt[0],pt[1]+1)
elif c == 'D': pt = (pt[0],pt[1]-1)
elif c == 'L': pt = (pt[0]-1,pt[1])
elif c == 'R': pt = (pt[0]+1,pt[1])
if pt[0] < rect[0]: rect[0] = pt[0]
if pt[0] >= rect[2]: rect[2] = pt[0]+1
if pt[1] < rect[1]: rect[1] = pt[1]
if pt[1] >= rect[3]: rect[3] = pt[1]+1
path.append(pt)
#print(pt)
#print(path)
#print(rect)
done = False
if pt[0] == 0:
if pt[1] == 0:
if (x,y) in path:
done = True
print("Yes")
else:
print("No")
done = True
elif pt[1] > 0:
n = max((y-rect[3])//pt[1]-2,0)
while n*pt[1]+rect[1] <= y:
if (x - n*pt[0],y - n*pt[1]) in path:
print("Yes")
done = True
break
n += 1
elif pt[1] < 0:
n = max((y - rect[1])//pt[1]-2,0)
while n*pt[1]+rect[3] >= y:
if (x - n*pt[0],y-n*pt[1]) in path:
print("Yes")
done = True
break
n += 1
elif pt[0] > 0:
n = max((x-rect[2])//pt[0]-2,0)
while n*pt[0]+rect[0] <= x:
if (x - n*pt[0],y - n*pt[1]) in path:
print("Yes")
done = True
break
n += 1
elif pt[0] < 0:
n = max((x-rect[0])//pt[0]-2,0)
while n*pt[0]+rect[2] >= x:
if (x - n*pt[0],y - n*pt[1]) in path:
print("Yes")
done = True
break
n += 1
if not done:
print("No")
``` | output | 1 | 34,589 | 15 | 69,179 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,590 | 15 | 69,180 |
Tags: binary search, implementation, math
Correct Solution:
```
target = tuple(map(int, input().split()))
s = input()
#print(target)
#print(s)
ok = False
pos = (0, 0)
for c in s:
if c == 'L': pos = (pos[0]-1, pos[1])
if c == 'R': pos = (pos[0]+1, pos[1])
if c == 'U': pos = (pos[0], pos[1]+1)
if c == 'D': pos = (pos[0], pos[1]-1)
if pos == target: ok = True
if pos == (0, 0): #termin pe pozitia din care am pornit
if ok: print('Yes')
else: print('No')
exit()
if pos[0] == 0:
if target[1] * pos[1] < 0: raport = 0
else: raport = target[1] // pos[1]
else:
if target[0] * pos[0] < 0: raport = 0
else: raport = target[0] // pos[0]
if raport > 0: raport = max(0, raport - 1000)
if raport < 0: raport = min(0, raport + 1000)
#print('Ajung in (%i, %i) dupa o executie, si raport = %i' %(pos[0], pos[1], raport))
coord = (pos[0] * raport, pos[1]*raport)
for rep in range(0, 10**4):
if coord == target: ok = True
for c in s:
if c == 'L': coord = (coord[0]-1, coord[1])
if c == 'R': coord = (coord[0]+1, coord[1])
if c == 'U': coord = (coord[0], coord[1]+1)
if c == 'D': coord = (coord[0], coord[1]-1)
if coord == target: ok = True
if ok: print('Yes')
else: print('No')
``` | output | 1 | 34,590 | 15 | 69,181 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2). | instruction | 0 | 34,591 | 15 | 69,182 |
Tags: binary search, implementation, math
Correct Solution:
```
a, b = map(int, input().split())
s = str(input())
sl = len(s)
x = [0 for i in range(101)]
y = [0 for i in range(101)]
for i in range(sl):
x[i + 1] = x[i]
y[i + 1] = y[i]
if s[i] == 'U':
y[i + 1] += 1
elif s[i] == 'D':
y[i + 1] -= 1
elif s[i] == 'L':
x[i + 1] -= 1
else:
x[i + 1] += 1
for i in range(0,sl):
if x[sl] == 0:
if a == x[i]:
if y[sl] == 0 and b == y[i] or y[sl] != 0 and (b - y[i]) % y[sl] == 0 and (b - y[i]) // y[sl] >= 0:
print('Yes')
exit()
elif (a - x[i]) % x[sl] == 0 and (a - x[i]) // x[sl] >= 0 and b == y[i] + (a - x[i]) // x[sl] * y[sl]:
print('Yes')
exit()
print('No')
``` | output | 1 | 34,591 | 15 | 69,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
target = tuple(map(int, input().split()))
s = input()
#print(target)
#print(s)
ok = False
pos = (0, 0)
for c in s:
if c == 'L': pos = (pos[0]-1, pos[1])
if c == 'R': pos = (pos[0]+1, pos[1])
if c == 'U': pos = (pos[0], pos[1]+1)
if c == 'D': pos = (pos[0], pos[1]-1)
if pos == target: ok = True
if pos == (0, 0): #termin pe pozitia din care am pornit
if ok: print('Yes')
else: print('No')
exit()
if pos[0] == 0:
if target[1] * pos[1] < 0: raport = 0
else: raport = target[1] // pos[1]
else:
if target[0] * pos[0] < 0: raport = 0
else: raport = target[0] // pos[0]
if raport > 0: raport = max(0, raport - 1000)
if raport < 0: raport = min(0, raport + 1000)
#print('Ajung in (%i, %i) dupa o executie, si raport = %i' %(pos[0], pos[1], raport))
coord = (pos[0] * raport, pos[1]*raport)
for rep in range(0, 5000):
if coord == target: ok = True
for c in s:
if c == 'L': coord = (coord[0]-1, coord[1])
if c == 'R': coord = (coord[0]+1, coord[1])
if c == 'U': coord = (coord[0], coord[1]+1)
if c == 'D': coord = (coord[0], coord[1]-1)
if coord == target: ok = True
if ok: print('Yes')
else: print('No')
``` | instruction | 0 | 34,592 | 15 | 69,184 |
Yes | output | 1 | 34,592 | 15 | 69,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
a, b = map(int, input().split())
s = input().strip()
c2d = dict()
c2d['U'] = (0, 1)
c2d['D'] = (0, -1)
c2d['L'] = (-1, 0)
c2d['R'] = (1, 0)
dx = dy = 0
for c in s:
dx += c2d[c][0]; dy += c2d[c][1]
ans = not a and not b
x = 0; y = 0
for c in s:
x += c2d[c][0]; y += c2d[c][1]
xx = a - x
yy = b - y
if ((xx % dx == 0 and xx // dx >= 0) if dx else not xx) and ((yy % dy == 0 and yy // dy >= 0) if dy else not yy) and (not dx or not dy or xx // dx == yy // dy):
ans = True
print("Yes" if ans else "No")
``` | instruction | 0 | 34,593 | 15 | 69,186 |
Yes | output | 1 | 34,593 | 15 | 69,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
go = {'U' : (0, 1), 'D' : (0, -1), 'R' : (1, 0), 'L' : (-1, 0)}
a, b = map(int, input().split())
s = input()
dx = dy = x = y = cx = cy = 0
for c in s:
dx += go[c][0]
dy += go[c][1]
ans = a == b == 0
for c in s:
x += go[c][0]
y += go[c][1]
cx, cy = a - x, b - y
flg = False
if dx: flg = not cx % dx and cx // dx >= 0
else: flg = not cx
if dy: flg = flg and not cy % dy and cy // dy >= 0
else: flg = flg and not cy
flg = flg and (not dx or not dy or cx // dx == cy // dy)
if flg:
ans = True
break
print("Yes" if ans else "No")
``` | instruction | 0 | 34,594 | 15 | 69,188 |
Yes | output | 1 | 34,594 | 15 | 69,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
def inc(c, x, y):
if c == 'R':
x += 1
if c == 'L':
x -= 1
if c == 'U':
y += 1
if c == 'D':
y -= 1
return x, y
a, b = map(int, input().split())
s = input()
x, y = 0, 0
for i in range(len(s)):
x, y = inc(s[i], x, y)
nx, ny = 0, 0
for i in range(len(s) + 1):
if x == 0 and y == 0 and nx == a and ny == b:
print('Yes')
exit()
if x == 0 and y != 0 and nx == a and (b - ny) % y == 0 and (b - ny) // y >= 0:
print('Yes')
exit()
if x != 0 and y == 0 and ny == b and (a - nx) % x == 0 and (a - nx) // x >= 0:
print('Yes')
exit()
if x != 0 and y != 0 and (a - nx) % x == 0 and (b - ny) % y == 0 and (a - nx) // x >= 0 and (b - ny) // y >= 0 and (a - nx) // x == (b - ny) // y >= 0:
print('Yes')
exit()
if i < len(s):
nx, ny = inc(s[i], nx, ny)
print('No')
``` | instruction | 0 | 34,595 | 15 | 69,190 |
Yes | output | 1 | 34,595 | 15 | 69,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
a, b = map(int,input().split())
s = input()
xi = 0
yi = 0
error = 0
for i in s:
if i == "R":
xi += 1
elif i == "L":
xi -= 1
elif i == "D":
yi -= 1
elif i == "U":
yi += 1
if xi != 0:
num = a // xi
if num > -1:
if yi != 0:
if a % xi == 0 and num * yi == b:
error = 1
else:
if a % xi == 0 and b == 0:
error = 1
else:
num = 0
if yi != 0:
if a == 0 and b % yi == 0:
error = 1
else:
if a == 0 and b == 0:
error = 1
xi2 = 0
yi2 = 0
for i in s:
if i == "R":
xi2 += 1
elif i == "L":
xi2 -= 1
elif i == "D":
yi2 -= 1
elif i == "U":
yi2 += 1
if xi != 0:
num = (a-xi2) // xi
if num > -1:
if yi != 0:
if (a-xi2) % xi == 0 and num * yi == (b-yi2):
error = 1
break
else:
if (a-xi2) % xi == 0 and (b-yi2) == 0:
error = 1
break
else:
num = 0
if yi != 0:
if (a-xi2) == 0 and (b-yi2) % yi == 0:
error = 1
break
else:
if (a-xi2) == 0 and (b-yi2) == 0:
error = 1
break
if error == 1:
print("Yes")
else:
print("No")
``` | instruction | 0 | 34,596 | 15 | 69,192 |
No | output | 1 | 34,596 | 15 | 69,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
target = tuple(map(int, input().split()))
s = input()
#print(target)
#print(s)
ok = False
pos = (0, 0)
for c in s:
if c == 'L': pos = (pos[0]-1, pos[1])
if c == 'R': pos = (pos[0]+1, pos[1])
if c == 'U': pos = (pos[0], pos[1]+1)
if c == 'D': pos = (pos[0], pos[1]-1)
if pos == target: ok = True
if pos == (0, 0): #termin pe pozitia din care am pornit
if ok: print('Yes')
else: print('No')
exit()
if pos[0] == 0:
if target[1] * pos[1] < 0: raport = 0
else: raport = target[1] // pos[1]
else:
if target[0] * pos[0] < 0: raport = 0
else: raport = target[0] // pos[0]
coord = (pos[0] * raport, pos[1]*raport)
for rep in range(0, 10**4):
if coord == target: ok = True
for c in s:
if c == 'L': coord = (coord[0]-1, coord[1])
if c == 'R': coord = (coord[0]+1, coord[1])
if c == 'U': coord = (coord[0], coord[1]+1)
if c == 'D': coord = (coord[0], coord[1]-1)
if coord == target: ok = True
if ok: print('Yes')
else: print('No')
``` | instruction | 0 | 34,597 | 15 | 69,194 |
No | output | 1 | 34,597 | 15 | 69,195 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
a, b = (int(x) for x in input().split())
s = input()
cur = (0, 0)
poss = []
for c in s:
poss.append(cur)
if c == 'U':
cur = (cur[0], cur[1] + 1)
elif c == 'D':
cur = (cur[0], cur[1] - 1)
elif c == 'L':
cur = (cur[0] - 1, cur[1])
else:
cur = (cur[0] + 1, cur[1])
for (x, y) in poss:
if (a - x) * cur[1] == (b - y) * cur[0]:
print('Yes')
exit()
print('No')
``` | instruction | 0 | 34,598 | 15 | 69,196 |
No | output | 1 | 34,598 | 15 | 69,197 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
Submitted Solution:
```
dx = 0
dy = 0
a, b = list(map(int,input().split()))
s = input()
for i in s:
if i == 'U':
dy += 1
elif i == 'D':
dy -= 1
elif i == 'L':
dx -= 1
else:
dx += 1
x0 = 0
y0 = 0
for i in s:
if i == 'U':
y0 += 1
elif i == 'D':
y0 -= 1
elif i == 'L':
x0 -= 1
else:
x0 += 1
if (a-x0)*dy == (b-y0)*dx:
print('Yes')
exit()
print('No')
``` | instruction | 0 | 34,599 | 15 | 69,198 |
No | output | 1 | 34,599 | 15 | 69,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,300 | 15 | 70,600 |
Tags: implementation, sortings
Correct 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
def root(parent, a):
while parent[a] != a:
parent[a] = parent[parent[a]]
a = parent[a]
return a
def union(parent, size, a, b):
roota, rootb = root(parent, a), root(parent, b)
if roota == rootb:
return
parent[rootb] = roota
size[roota] += size[rootb]
size[rootb] = 0
def prime_factors(n):
num = n
count = 0 #optimization (to count iterations)
index = 0 #index (to test)
t = [2, 3, 5, 7] #list (to test)
f = [] #prime factors list
while t[index] ** 2 <= n:
count += 1 #increment (how many loops to find factors)
if len(t) == (index + 1):
t.append(t[-2] + 6) #extend test list (as much as needed) [2, 3, 5, 7, 11, 13...]
if n % t[index]: #if 0 does else (otherwise increments, or try next t[index])
index += 1 #increment index
else:
n = n // t[index] #drop max number we are testing... (this should drastically shorten the loops)
f.append(t[index]) #append factor to list
if n > 1:
f.append(n) #add last factor...
return f
if __name__ == "__main__":
for _ in range(iinput()):
n=iinput()
s=[]
for i in range(n):
a,b=rinput()
s.append((a,b))
s.sort()
ans=''
curr=[0,0]
flag=True
for i in range(n):
x=s[i][0]-curr[0]
y=s[i][1]-curr[1]
if x<0 or y<0:
flag=False
break
ans+='R'*x + 'U'*y
curr=[s[i][0],s[i][1]]
if flag:
print('YES')
print(ans)
else:
print('NO')
``` | output | 1 | 35,300 | 15 | 70,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,301 | 15 | 70,602 |
Tags: implementation, sortings
Correct Solution:
```
T=int(input())
for _ in range(T):
n=int(input())
L=[(0,0)]
for i in range(0,n):
x,y=map(int,input().split())
L.append((x,y))
L.sort()
flag=0
for i in range(1,len(L)):
if(L[i][0]==L[i-1][0]):
if(L[i][1]<=L[i-1][1]):
flag=1
break
elif(L[i][0]>L[i-1][0]):
if(L[i][1]<L[i-1][1]):
flag=1
break
#print(L)
if(flag!=0):
print('NO')
else:
print('YES')
st=''
for i in range(1,len(L)):
if(L[i][0]==L[i-1][0]):
for j in range(L[i][1]-L[i-1][1]):
st+='U'
elif(L[i][0]>L[i-1][0]):
for j in range(L[i][0]-L[i-1][0]):
st+='R'
for j in range(L[i][1]-L[i-1][1]):
st+='U'
print(st)
``` | output | 1 | 35,301 | 15 | 70,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,302 | 15 | 70,604 |
Tags: implementation, sortings
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
lis=[]
for i in range(n):
x,y = map(int,input().split())
lis.append([x,y])
lis=sorted(lis,key=lambda x:x[0]+x[1])
lastx=0
lasty=0
flag=1
for item in lis:
x=item[0]
y=item[1]
if(lastx<=x and lasty<=y):
lastx=x
lasty=y
continue
else:
print("NO")
flag=0
break
if(flag==1):
print("YES")
lastx=0
lasty=0
for item in lis:
x = item[0]
y = item[1]
print("R"*(x-lastx),end="")
print("U"*(y-lasty),end="")
lasty=y
lastx=x
print("")
``` | output | 1 | 35,302 | 15 | 70,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,303 | 15 | 70,606 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
for i in range(n):
t = int(input())
x=y=0
z=[]
g=1
s=''
for i in range(t):
a,b=map(int,input().split())
z.append((a,b))
p=sorted(z , key=lambda k: [k[1], k[0]])
# print(p)
for i in p:
p=i[0]
q=i[1]
if p>=x and q>=y and g==1:
for j in range(x,p):
x+=1
s+='R'
for j in range(y,q):
y+=1
s+='U'
#print(s)
else:
g=0
break
if g:
print("YES")
print(s)
else:
print("NO")
``` | output | 1 | 35,303 | 15 | 70,607 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,304 | 15 | 70,608 |
Tags: implementation, sortings
Correct Solution:
```
for u in range(int(input())):
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
l.sort()
r=''
x,y=0,0
f=0
for i in range(n):
if(l[i][0]>=x and l[i][1]>=y):
xx=l[i][0]-x
r=r+'R'*xx
yy=l[i][1]-y
r=r+'U'*yy
x,y=l[i][0],l[i][1]
else:
f=1
break
if(f==1):
print("NO")
else:
print("YES")
print(r)
``` | output | 1 | 35,304 | 15 | 70,609 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,305 | 15 | 70,610 |
Tags: implementation, sortings
Correct Solution:
```
for t in range(int(input())):
n, packages = int(input()), []
for i in range(n):
x, y = map(int, input().split())
packages.append((x,y))
packages.sort()
packages.insert(0, (0,0))
res = ''
for (x1, y1), (x2, y2) in zip(packages, packages[1:]):
if x1 < x2 and y1 > y2:
res = False
break
else:
res += ('R' * (x2 - x1)) + ('U' * (y2 - y1))
print(f'YES\n{res}' if res != False else 'NO')
``` | output | 1 | 35,305 | 15 | 70,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,306 | 15 | 70,612 |
Tags: implementation, sortings
Correct Solution:
```
for t in range(int(input())):
adj = [[]for i in range(1001)]
for z in range(int(input())):
x,y = map(int,input().split())
adj[x].append(y)
x,y =0,0
s=""
ans = "YES"
for i in range(1001):
adj[i].sort()
if len(adj[i]) != 0:
s+='R'*(i-x)
x=i
for j in range(len(adj[i])):
if adj[i][j]-y<0:
ans = "NO"
break
else:
s+='U'*(adj[i][j]-y)
y=adj[i][j]
if ans=="NO":
break
if ans=="YES":
print(ans)
print(s)
else:
print(ans)
``` | output | 1 | 35,306 | 15 | 70,613 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 β€ j β€ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 β€ t β€ 100) β the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 β€ n β€ 1000) β the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 β€ x_i, y_i β€ 1000) β the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path β a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image> | instruction | 0 | 35,307 | 15 | 70,614 |
Tags: implementation, sortings
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=[list(map(int,input().split())) for i in range(n)]
a.sort()
cx,cy,nx,ny=0,0,0,0
ans=''
for i in a:
cx,cy,nx,ny=nx,ny,i[0],i[1]
if ny<cy:
print("NO")
break
else:
ans+="R"*(nx-cx)+"U"*(ny-cy)
else:
print("YES")
print(ans)
``` | output | 1 | 35,307 | 15 | 70,615 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
s=input()
x=abs(s.count('L')-s.count('R'))
y=abs(s.count('U')-s.count('D'))
print(-1 if len(s)&1>0 else (x+y)>>1)
# Made By Mostafa_Khaled
``` | instruction | 0 | 35,620 | 15 | 71,240 |
Yes | output | 1 | 35,620 | 15 | 71,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
s=input()
i=0
x=0
y=0
while i<len(s):
if s[i]=="R":
x=x+1
if s[i]=="L":
x=x-1
if s[i]=="U":
y=y+1
if s[i]=="D":
y=y-1
i=i+1
i=-1
if x<0:
x=-x
if y<0:
y=-y
x=x+y
if x%2==0:
print(x//2)
else:
print(i)
``` | instruction | 0 | 35,621 | 15 | 71,242 |
Yes | output | 1 | 35,621 | 15 | 71,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
import math
import sys
import re
def func(s):
if len(s)%2 != 0:
return -1
else:
a = abs(s.count('U')-s.count('D'))
b = abs(s.count('L') - s.count('R'))
return (a+b)//2
s = input()
print(func(s))
``` | instruction | 0 | 35,622 | 15 | 71,244 |
Yes | output | 1 | 35,622 | 15 | 71,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
vert=0
hor=0
s=input()
for i in s:
if i=='U':
vert+=1
elif i=='D':
vert-=1
elif i=='R':
hor+=1
elif i=='L':
hor-=1
if len(s)%2==0:
print((abs(vert)+abs(hor))//2)
else:
print(-1)
``` | instruction | 0 | 35,623 | 15 | 71,246 |
Yes | output | 1 | 35,623 | 15 | 71,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
n=list(input())
a=n.count('R')
b=n.count('L')
c=n.count('U')
d=n.count('D')
if len(n)%2==1:
print(-1)
else:
x=(a+b)//2
y=(c+d)//2
i=max(a,b)-x
j=max(c,d)-y
print(i+j)
``` | instruction | 0 | 35,624 | 15 | 71,248 |
No | output | 1 | 35,624 | 15 | 71,249 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 β€ |s| β€ 100 000) β the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer β the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
Submitted Solution:
```
import math
instr = input()
if len(instr) % 2 != 0:
print(-1)
else:
directions = {'R': 0, 'L': 0, 'U': 0, 'D': 0}
for ins in instr:
if not ins in directions:
directions[ins] = 0
else:
directions[ins] += 1
diff = int(math.fabs(directions['R'] + directions['L']) / 2) + int(math.fabs(directions['U'] + directions['D']) / 2)
print(diff)
``` | instruction | 0 | 35,625 | 15 | 71,250 |
No | output | 1 | 35,625 | 15 | 71,251 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.