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 |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9. | instruction | 0 | 67,271 | 15 | 134,542 |
Tags: dp
Correct Solution:
```
from sys import stdin
n=int(stdin.readline().strip())
s=[]
s1=[]
for i in range(n):
a,b=map(int,stdin.readline().strip().split())
s.append((a,b))
s1.append((b,a))
s.sort()
s1.sort(reverse=True)
mt=dict()
for i in s:
if i[0]<=i[1]:
if i[1] in mt:
mt[i[1]].append(i)
else:
mt.update({i[1]:[i]})
for i in s1:
if i[1]>i[0]:
if i[1] in mt:
mt[i[1]].append((i[1],i[0]))
else:
mt.update({i[1]:[(i[1],i[0])]})
v=[[(0,0)]]
k=list(mt.keys())
k.sort()
for i in k:
v.append(mt[i])
n=len(v)
dp=[[-1,-1] for i in range(n)]
dp[0][0]=0
dp[0][1]=0
dist=[0 for i in range(n)]
for i in range(1,n):
x=0
for j in range(1,len(v[i])):
x+=abs(v[i][j][0]-v[i][j-1][0])+abs(v[i][j][1]-v[i][j-1][1])
dist[i]=x
for i in range(1,n):
dp[i][1]=dist[i]+(min(dp[i-1][1]+abs(v[i][0][0]-v[i-1][-1][0])+abs(v[i][0][1]-v[i-1][-1][1]),dp[i-1][0]+abs(v[i][0][0]-v[i-1][0][0])+abs(v[i][0][1]-v[i-1][0][1])))
dp[i][0]=dist[i]+(min(dp[i-1][1]+abs(v[i][-1][0]-v[i-1][-1][0])+abs(v[i][-1][1]-v[i-1][-1][1]),dp[i-1][0]+abs(v[i][-1][0]-v[i-1][0][0])+abs(v[i][-1][1]-v[i-1][0][1])))
print(min(dp[-1]))
``` | output | 1 | 67,271 | 15 | 134,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9. | instruction | 0 | 67,272 | 15 | 134,544 |
Tags: dp
Correct Solution:
```
import itertools as it
def dist(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def spir_dist(x):
a, b = x
if a >= b:
return b
else:
return 2 * b - a
n = int(input())
A = [[0, 0]]
for _ in range(n):
x, y = map(int, input().split())
A += [[x, y]]
A_s = sorted(A, key=max)
A_g = it.groupby(A_s, key=max)
A_t = [p + p if len(p) == 1 else [p[0], p[-1]]
for p in [sorted(list(q[1]), key=spir_dist) for q in A_g]]
B = [[0,0]]
for i in range(1, len(A_t)):
pa, pb = A_t[i]
d = dist(pa, pb)
y = min([B[i - 1][k] + dist(A_t[i - 1][k], pa) for k in [0, 1]]) + d
x = min([B[i - 1][k] + dist(A_t[i - 1][k], pb) for k in [0, 1]]) + d
B += [[x, y]]
print(min(B[len(A_t) - 1]))
#JSR
``` | output | 1 | 67,272 | 15 | 134,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9. | instruction | 0 | 67,273 | 15 | 134,546 |
Tags: dp
Correct Solution:
```
def dista(a, b):
return abs(lista[a][0]-lista[b][0]) + abs(lista[a][1]-lista[b][1])
lista = []
ne = 0
n = int(input())
dist = [0] * (n+1)
lista.append((0, 0))
for _ in range(n):
x, y = map(int, input().split())
lista.append((x, y))
lista = sorted(lista, key= lambda x: min(x))
lista = sorted(lista, key= lambda x: max(x))
n += 1
ini = 0
ne = 1
oy = 0
ox = 0
while ne < n:
ini = ne
maxi = max(lista[ne])
while ne < n and max(lista[ne]) == maxi:
ne += 1
minx = ini
miny = ini
for i in range(ini, ne):
if lista[i][0] < lista[minx][0]:
minx = i
elif lista[i][0] == lista[minx][0] and lista[i][1] > lista[minx][1]:
minx = i
if lista[i][1] < lista[miny][1]:
miny = i
elif lista[i][1] == lista[miny][1] and lista[i][0] > lista[miny][0]:
miny = i
mxy = dista(minx, miny)
if dista(miny, ox) + dist[ox] < dist[oy] + dista(miny, oy):
dist[minx] = dista(ox, miny) + dist[ox] + mxy
else:
dist[minx] = dista(oy, miny) + dist[oy] + mxy
if dista(ox, minx) + dist[ox] < dist[oy] + dista(oy, minx):
dist[miny] = dista(ox, minx) + dist[ox] + mxy
else:
dist[miny] = dista(oy, minx) + dist[oy] + mxy
ox = minx
oy = miny
print(min(dist[miny], dist[minx]))
``` | output | 1 | 67,273 | 15 | 134,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9. | instruction | 0 | 67,274 | 15 | 134,548 |
Tags: dp
Correct Solution:
```
def get_input_list():
return list(map(int, input().split()))
def sort_(p):
np = []
for i in p:
np.append([i[0],-i[1]])
np.sort()
return np
def distance(A,B):
return abs(B[0] - A[0]) + abs(B[1] - A[1])
n = int(input())
p_ = []
for _ in range(n):
p_.append(get_input_list())
d = {}
for i in p_:
if (str(max(i))) in d:
d[str(max(i))].append(i)
else:
d[str(max(i))] = [i]
l = [int(i) for i in d]
l.sort()
left = [0,0]
right = [0,0]
sleft = 0
sright = 0
for i_ in l:
i = str(i_)
p = sort_(d[i])
left_ = p[0]
right_ = p[-1]
a1 = distance(left, left_)
b1 = distance(left, right_)
a2 = distance(right, left_)
b2 = distance(right, right_)
c = distance(p[0],p[-1])
sl = sleft
sr = sright
sleft = min(sr + a1, sl + a2) + c
sright = min(sr + b1, sl + b2) + c
left = left_
right = right_
print(min(sleft, sright))
``` | output | 1 | 67,274 | 15 | 134,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
def solve():
Point=[]
n=int(input())
for i in range(n):
x,y=map(int,input().split())
Point.append((x,y))
data={}
for each in Point:
if each[0]<each[1]:
try:
tm=data[each[1]]
except KeyError:
data[each[1]]={}
try:
data[each[1]]['xi']=min(data[each[1]]['xi'],each[0])
except KeyError:
data[each[1]]['xi']=each[0]
try:
data[each[1]]['xa'] = max(data[each[1]]['xa'], each[0])
except KeyError:
data[each[1]]['xa'] = each[0]
else:
try:
tm=data[each[0]]
except KeyError:
data[each[0]]={}
try:
data[each[0]]['yi']=min(data[each[0]]['yi'],each[1])
except KeyError:
data[each[0]]['yi']=each[1]
try:
data[each[0]]['ya']=max(data[each[0]]['ya'],each[1])
except KeyError:
data[each[0]]['ya'] = each[1]
pre1=(0,0,0)
pre2=(0,0,0)
for each in sorted(data.keys()):
x1,y1,w1=pre1
x2,y2,w2=pre2
if len(data[each])==2:
if 'xa' in data[each]:
x3, y3 = data[each]['xa'], each
x4, y4 = data[each]['xi'], each
if 'ya' in data[each]:
x3, y3 = each, data[each]['ya']
x4, y4 = each, data[each]['yi']
else:
x3,y3=data[each]['xi'],each
x4,y4=each,data[each]['yi']
d=abs(x3-x4)+abs(y3-y4)
pre1 = (x3, y3, min(abs(x1 - x4) + abs(y1 - y4) + w1 + d, abs(x2 - x4) + abs(y2 - y4) + w2 + d))
pre2=(x4,y4,min(abs(x1-x3)+abs(y1-y3)+w1+d,abs(x2-x3)+abs(y2-y3)+w2+d))
print(min(pre1[2],pre2[2]))
if __name__=='__main__':
solve()
``` | instruction | 0 | 67,275 | 15 | 134,550 |
Yes | output | 1 | 67,275 | 15 | 134,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
import sys
def minp():
return sys.stdin.readline().strip()
def dist(x1,y1,x2,y2):
return abs(x1-x2)+abs(y1-y2)
n = int(minp())
a = [None]*n
for i in range(n):
x,y = map(int,minp().split())
a[i] = (max(x,y),x,-y)
a.sort()
#print(a)
p = [None]*2
d = [None]*2
p[0] = [None]*(n+1)
p[1] = [None]*(n+1)
d[0] = [None]*(n+1)
d[1] = [None]*(n+1)
d[0][0] = 0
d[1][0] = 0
p[0][0] = (0,0,0)
p[1][0] = (0,0,0)
i = 0
k = 1
while i < n:
x = a[i]
xx = x[0]
j = i + 1
while j < n and a[j][0] == xx:
j += 1
y = a[j-1]
p0 = p[0][k-1]
p1 = p[1][k-1]
d0 = d[0][k-1]
d1 = d[1][k-1]
dd = dist(x[1],x[2],y[1],y[2])
d2 = dist(p0[1],p0[2],x[1],x[2])
d3 = dist(p1[1],p1[2],x[1],x[2])
d[0][k] = min(d0+d2,d1+d3)+dd
p[0][k] = y
d2 = dist(p0[1],p0[2],y[1],y[2])
d3 = dist(p1[1],p1[2],y[1],y[2])
d[1][k] = min(d0+d2,d1+d3)+dd
p[1][k] = x
k += 1
i = j
print(min(d[0][k-1],d[1][k-1]))
``` | instruction | 0 | 67,276 | 15 | 134,552 |
Yes | output | 1 | 67,276 | 15 | 134,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
import traceback
class Input(object):
def __init__(self):
self.fh = sys.stdin
def next_line(self):
while True:
line = sys.stdin.readline()
if line == '\n':
continue
return line
def next_line_ints(self):
line = self.next_line()
return [int(x) for x in line.split()]
def next_line_strs(self):
line = self.next_line()
return line.split()
def get_dist(p1, p2):
return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
def calculate_finish_cost(dp_reach, points):
""" Return dp_finish of this level. """
assert len(dp_reach) == len(points)
if len(points) == 1:
return dp_reach
round_cost = get_dist(points[0], points[-1])
# dp_finish = min(2 * round_cost + (dp[p1] - dist)). omit 2 * round_cost for now.
dp_finish = dp_reach[:]
min_diff = dp_reach[0]
for i in range(1, len(points)):
min_diff = min(min_diff - get_dist(points[i], points[i-1]), dp_reach[i])
dp_finish[i] = min(min_diff, dp_finish[i])
min_diff = dp_reach[-1]
for i in range(len(points) - 2, -1, -1):
min_diff = min(min_diff - get_dist(points[i], points[i+1]), dp_reach[i])
dp_finish[i] = min(min_diff, dp_finish[i])
assert len(dp_finish) == len(points)
return [x + 2 * round_cost for x in dp_finish]
def calculate_reach_cost(dp_finish, from_points, to_points):
"""calculate from dp_finish of current level to the dp_reach of the next level."""
assert len(dp_finish) == len(from_points)
from_k = [y/max(x, 0.5) for x, y in from_points]
to_k = [y/max(x, 0.5) for x, y in to_points]
dp_reach = []
from_index = 0
for i in range(len(to_points)):
while from_index + 1 < len(from_points) and from_k[from_index + 1] > to_k[i]:
from_index += 1
dp = dp_finish[from_index] + get_dist(from_points[from_index], to_points[i])
if from_index + 1 < len(from_points):
dp = min(dp, dp_finish[from_index + 1] + get_dist(from_points[from_index + 1], to_points[i]))
dp_reach.append(dp)
assert len(dp_reach) == len(to_points)
return dp_reach
def get_min_dist(points):
# 1. split points into levels, sort points in each level in x increase, y decrease order.
level_dict = {}
for point in points:
level = max(point[0], point[1])
if level in level_dict:
level_dict[level].append(point)
else:
level_dict[level] = [point]
level_points = []
for level in sorted(level_dict.keys()):
p = level_dict[level]
level_points.append(sorted(p, key=lambda x: x[0] - x[1]))
# 2. calculate the min cost to reach a level at a point.
# calculate the min cost to finish a level at a point.
dp_reach = []
for p in level_points[0]:
dp_reach.append(p[0] + p[1])
dp_finish = calculate_finish_cost(dp_reach, level_points[0])
for i in range(len(level_points) - 1):
from_points = level_points[i]
to_points = level_points[i + 1]
dp_reach = calculate_reach_cost(dp_finish, from_points, to_points)
dp_finish = calculate_finish_cost(dp_reach, to_points)
# 3. the result is to finish at any points at the last level.
return min(dp_finish)
def main():
input = Input()
while True:
try:
nums = input.next_line_ints()
if not nums:
break
n = nums[0]
points = []
for _ in range(n):
x, y = input.next_line_ints()
points.append((x, y))
except:
print('read input failed')
try:
min_dist = get_min_dist(points)
except:
traceback.print_exc(file=sys.stdout)
print('get_min_dist failed')
print("{}".format(min_dist))
main()
``` | instruction | 0 | 67,277 | 15 | 134,554 |
Yes | output | 1 | 67,277 | 15 | 134,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
import sys
def cal(a,b):
return abs(a[0]-b[0])+abs(a[1]-b[1])
def cmp(a,b):
if a[0]!=b[0]:return a[0]<b[0]
return a[1]>b[1]
rd=sys.stdin.readlines()
n=int(rd[0])
data={}
for _ in range(0,n):
x,y=map(int,rd[_+1].split())
if max(x,y) not in data:
data[max(x,y)]=[]
data[max(x,y)].append((x,y))
dp1,dp2=0,0
pre1,pre2=(0,0),(0,0)
for i in sorted(list(data.keys())):
now1,now2=data[i][0],data[i][0]
for x in data[i]:
if cmp(now1,x):now1=x
if cmp(x,now2):now2=x
dp1,dp2=min(dp1+cal(pre1,now2)+cal(now2,now1),dp2+cal(pre2,now2)+cal(now2,now1)),min(dp1+cal(pre1,now1)+cal(now1,now2),dp2+cal(pre2,now1)+cal(now1,now2))
pre1,pre2=now1,now2
print(min(dp1,dp2))
``` | instruction | 0 | 67,278 | 15 | 134,556 |
Yes | output | 1 | 67,278 | 15 | 134,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
import sys
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n = inp()
dot = []
for _ in range(n):
x,y = inpl()
dot.append([x,y,max(x,y)])
dot.sort(key = lambda x:x[2])
nd = []
nlv = -1
res = [0,0]
pre_coo = [[0,0],[0,0]]
for i in range(n):
x,y,lv = dot[i]
nlv = lv
nd.append([x,y])
if i == n-1 or dot[i+1][2] != nlv:
if len(nd) == 1:
t0x = t1x = nd[0][0]
t0y = t1y = nd[0][1]
cos = 0
else:
t0x = t1y = nlv
t0y = t1x = nlv
for x,y in nd:
if x == nlv:
t1y = min(t1y,y)
if y == nlv:
t0x = min(t0x,x)
cos = abs(t0x-nlv) + abs(t1y-nlv)
pre_res = res[::]
p0x,p0y = pre_coo[0]; p1x,p1y = pre_coo[1]
res[0] = min(abs(p0x-t1x)+abs(p0y-t1y)+pre_res[0], abs(p1x-t1x)+abs(p1y-t1y)+pre_res[1]) + cos
res[1] = min(abs(p0x-t0x)+abs(p0y-t0y)+pre_res[0], abs(p1x-t0x)+abs(p1y-t0y)+pre_res[1]) + cos
nd = []
pre_coo[0] = [t0x,nlv]; pre_coo[1] = [nlv,t1y]
print(min(res))
``` | instruction | 0 | 67,279 | 15 | 134,558 |
No | output | 1 | 67,279 | 15 | 134,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
from math import *
n=int(input())
T=[[],[]]
D=[]
M=[]
T[0].append(0)
T[1].append(0)
D.append(0)
M.append(0)
def Dis(X1,Y1,X2,Y2):
return abs(X1-X2)+abs(Y1-Y2)
for i in range(1,n+1):
xi,yi=input().split()
xi=int(xi)
yi=int(yi)
T[0].append(xi)
T[1].append(yi)
D.append(Dis(0,0,xi,yi))
M.append(max(xi,yi))
s=1
while s!=n:
Min=D[s]
for i in range(s,n+1):
if Min>D[i] :
Min=D[i]
else:
continue
SD=D[s]
D[s]=Min
D[i]=SD
M[s],M[i]=M[i],M[s]
T[0][s],T[0][i]=T[0][i],T[0][s]
T[1][s],T[1][i]=T[1][i],T[1][s]
s=s+1
for i in range(1,n-1):
if i<n-2 and (abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1]))>(abs(T[0][i]-T[0][i+2])+abs(T[1][i]-T[1][i+2])) and (abs(T[0][i+1]-T[0][i+3])+abs(T[1][i+1]-T[1][i+3]))<(abs(T[0][i+2]-T[0][i+3])+abs(T[1][i+2]-T[1][i+3])) :
T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
if i==n-2 and (abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1]))>(abs(T[0][i]-T[0][i+2])+abs(T[1][i]-T[1][i+2])):
T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
S=0
for i in range(n):
S=S+abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1])
print(S)
``` | instruction | 0 | 67,280 | 15 | 134,560 |
No | output | 1 | 67,280 | 15 | 134,561 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
n=int(input())
def getdist(p1,p2):
return abs(p1[0]-p2[0]) + abs(p1[1]-p2[1])
lvl=set()
a=[]
for i in range(n):
x,y=map(int,input().split())
a.append([max(x,y),[x,y]])
lvl.add(max(x,y))
#dp[numlvls][0,1]=[mindist,lastpt]
dp=[[[0,[0,0]],[0,[0,0]]] for i in range(len(lvl)+1)]
a.sort()
i=0
cnt=1
while(i<n):
grp=[a[i][1]]
while(i+1<n and a[i][0]==a[i+1][0]):
i+=1
grp.append(a[i][1])
#print('grp',grp)
dist=getdist(grp[0],grp[-1])
dp[cnt][0][0]=min(dp[cnt-1][0][0] + getdist(dp[cnt-1][0][1],grp[0]),dp[cnt-1][1][0] + getdist(dp[cnt-1][1][1],grp[0]))
dp[cnt][1][0]=min(dp[cnt-1][0][0] + getdist(dp[cnt-1][0][1],grp[-1]),dp[cnt-1][1][0] + getdist(dp[cnt-1][1][1],grp[-1]))
dp[cnt][0][1]=grp[-1]
#print(grp[0],dp[cnt-1][0][0] + getdist(dp[cnt-1][1][1],grp[0]),dp[cnt-1][1][0] + getdist(dp[cnt-1][1][1],grp[0]))
#print(grp[0],dp[cnt-1][0][0] + getdist(dp[cnt-1][1][1],grp[0]),dp[cnt-1][1][0] + getdist(dp[cnt-1][1][1],grp[0]))
dp[cnt][1][1]=grp[0]
dp[cnt][0][0]+=dist
dp[cnt][1][0]+=dist
i+=1
cnt+=1
#print(dp)
print(min(dp[-1][0][0],dp[-1][1][0]))
``` | instruction | 0 | 67,281 | 15 | 134,562 |
No | output | 1 | 67,281 | 15 | 134,563 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Maksim walks on a Cartesian plane. Initially, he stands at the point (0, 0) and in one move he can go to any of four adjacent points (left, right, up, down). For example, if Maksim is currently at the point (0, 0), he can go to any of the following points in one move:
* (1, 0);
* (0, 1);
* (-1, 0);
* (0, -1).
There are also n distinct key points at this plane. The i-th point is p_i = (x_i, y_i). It is guaranteed that 0 ≤ x_i and 0 ≤ y_i and there is no key point (0, 0).
Let the first level points be such points that max(x_i, y_i) = 1, the second level points be such points that max(x_i, y_i) = 2 and so on. Maksim wants to visit all the key points. But he shouldn't visit points of level i + 1 if he does not visit all the points of level i. He starts visiting the points from the minimum level of point from the given set.
The distance between two points (x_1, y_1) and (x_2, y_2) is |x_1 - x_2| + |y_1 - y_2| where |v| is the absolute value of v.
Maksim wants to visit all the key points in such a way that the total distance he walks will be minimum possible. Your task is to find this distance.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of key points.
Each of the next n lines contains two integers x_i, y_i (0 ≤ x_i, y_i ≤ 10^9) — x-coordinate of the key point p_i and y-coordinate of the key point p_i. It is guaranteed that all the points are distinct and the point (0, 0) is not in this set.
Output
Print one integer — the minimum possible total distance Maksim has to travel if he needs to visit all key points in a way described above.
Examples
Input
8
2 2
1 4
2 3
3 1
3 4
1 1
4 3
1 2
Output
15
Input
5
2 1
1 0
2 0
3 2
0 3
Output
9
Note
The picture corresponding to the first example: <image>
There is one of the possible answers of length 15.
The picture corresponding to the second example: <image>
There is one of the possible answers of length 9.
Submitted Solution:
```
from math import *
n=int(input("n="))
T=[[],[]]
D=[]
M=[]
T[0].append(0)
T[1].append(0)
D.append(0)
M.append(0)
def Dis(X1,Y1,X2,Y2):
return abs(X1-X2)+abs(Y1-Y2)
for i in range(1,n+1):
xi,yi=input().split()
xi=int(xi)
yi=int(yi)
T[0].append(xi)
T[1].append(yi)
D.append(Dis(0,0,xi,yi))
M.append(max(xi,yi))
s=1
while s!=n:
Min=D[s]
for i in range(s,n+1):
if Min>D[i] :
Min=D[i]
else:
continue
SD=D[s]
D[s]=Min
D[i]=SD
M[s],M[i]=M[i],M[s]
T[0][s],T[0][i]=T[0][i],T[0][s]
T[1][s],T[1][i]=T[1][i],T[1][s]
s=s+1
#print(T[0],"\n",T[1])
for i in range(1,n-1):
shit=0
if i<n-2 and (abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1]))>(abs(T[0][i]-T[0][i+2])+abs(T[1][i]-T[1][i+2])) and (abs(T[0][i+1]-T[0][i+3])+abs(T[1][i+1]-T[1][i+3]))<(abs(T[0][i+2]-T[0][i+3])+abs(T[1][i+2]-T[1][i+3])) :
#if (abs(T[0][i+1]-T[1][i+1]))>(abs(T[0][i+2]-T[1][i+2])) and D[i+1]<D[i+2] and M[i+1]==M[i+2] :
T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
#shit=1
#if shit!=1 and D[i+1]>=D[i+2]:
#T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
#T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
if i==n-2 and (abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1]))>(abs(T[0][i]-T[0][i+2])+abs(T[1][i]-T[1][i+2])):
T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
#if shit!=1 and (abs(T[0][i+1]-T[1][i+1]))>(abs(T[0][i+2]-T[1][i+2])) :
#T[0][i+1],T[0][i+2]=T[0][i+2],T[0][i+1]
#T[1][i+1],T[1][i+2]=T[1][i+2],T[1][i+1]
#M[i+1],M[i+2]=M[i+2],M[i+1]
#print(T[0],"\n",T[1])
S=0
for i in range(n):
S=S+abs(T[0][i]-T[0][i+1])+abs(T[1][i]-T[1][i+1])
print(S)
#print(D)
#print(M)
``` | instruction | 0 | 67,282 | 15 | 134,564 |
No | output | 1 | 67,282 | 15 | 134,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,531 | 15 | 135,062 |
Tags: greedy, math
Correct Solution:
```
answers = []
def solve(n, s):
store = []
for i, ele in enumerate(s):
if ele == '*':
store.append(i)
length = len(store)
if length == 0:
answers.append(0)
return
median = None
if length % 2 == 0:
median = (store[length//2] + store[length//2 - 1]) // 2
else:
median = store[length//2]
hashStore = {}
for ele in store:
hashStore[ele] = 1
leftLimit = median
rightLimit = median + 1
while leftLimit in hashStore:
leftLimit -= 1
while rightLimit in hashStore:
rightLimit += 1
newStore = {}
count = 0
for i in range(leftLimit, -1, -1):
if i in hashStore:
count += leftLimit - i
leftLimit -= 1
# print(count)
length = n
for i in range(rightLimit+1, length):
if i in hashStore:
count += i - rightLimit
rightLimit += 1
answers.append(count)
T = int(input())
while T:
n = int(input())
s = input()
solve(n, s)
T -= 1
for ans in answers:
print(ans)
``` | output | 1 | 67,531 | 15 | 135,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,532 | 15 | 135,064 |
Tags: greedy, math
Correct Solution:
```
import sys
import collections
import math
inf = sys.maxsize
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()
mod = 1000000007
for _ in range(int(input())):
n = int(input())
s = input()
u = [[0] * 2 for i in range(n)]
v = [[0] * 2 for i in range(n)]
for i in range(n):
if i == 0:
if s[i] == '*':
u[i][0] = 0
u[i][1] = 1
else:
u[i][0] = 0
u[i][1] = 0
else:
if s[i] == '*':
u[i][0] = u[i - 1][0]
u[i][1] = u[i - 1][1] + 1
else:
u[i][0] = u[i - 1][0] + u[i - 1][1]
u[i][1] = u[i - 1][1]
for i in range(n - 1, -1, -1):
if i == n - 1:
if s[i] == '*':
v[i][0] = 0
v[i][1] = 1
else:
v[i][0] = 0
v[i][1] = 0
else:
if s[i] == '*':
v[i][0] = v[i + 1][0]
v[i][1] = v[i + 1][1] + 1
else:
v[i][0] = v[i + 1][0] + v[i + 1][1]
v[i][1] = v[i + 1][1]
minVal = u[-1][0]
for i in range(n-1):
minVal = min(minVal, u[i][0]+v[i+1][0])
print(minVal)
``` | output | 1 | 67,532 | 15 | 135,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,533 | 15 | 135,066 |
Tags: greedy, math
Correct Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
arr = [1 if i == '*' else 0 for i in input()]
ships = sum(arr)
left = 0
right = n - 1
ans = 0
i = 1
while (right - left > 0) and (ships >= 2):
ships -= 2
while arr[left] != 1:
left +=1
while arr[right] != 1:
right -= 1
ans += right - left - 1 - ships
right -=1
left+=1
print(ans)
``` | output | 1 | 67,533 | 15 | 135,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,534 | 15 | 135,068 |
Tags: greedy, math
Correct Solution:
```
"""
"""
import sys
from sys import stdin
tt = int(stdin.readline())
ANS = []
for loop in range(tt):
n = int(stdin.readline())
a = list(stdin.readline()[:-1])
m1 = None
m2 = None
alls = 0
for i in range(n):
if a[i] == "*":
alls += 1
if alls <= 1:
ANS.append("0")
continue
cnt = 0
for i in range(n):
if a[i] == "*":
cnt += 1
if cnt == (alls+1)//2:
m1 = i
break
st = m1 - (alls+1)//2 + 1
#print (m1,st)
ans = 0
for i in range(n):
if a[i] == "*":
ans += abs(i-st)
st += 1
#print (m1)
ANS.append(str(ans))
print ("\n".join(ANS))
``` | output | 1 | 67,534 | 15 | 135,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,535 | 15 | 135,070 |
Tags: greedy, math
Correct Solution:
```
import sys
input = sys.stdin.readline
def calc(x):
ANS=0
for i in range(len(B)):
ANS+=abs(B[i]-(x+i))
return ANS
t=int(input())
for tests in range(t):
n=int(input())
A=list(input().strip())
B=[]
for i in range(n):
if A[i]=="*":
B.append(i)
left=0
right=n-len(B)
while right-left>3:
mid=left+(right-left)//3
mid2=left+(right-left)*2//3
c=calc(mid)
c2=calc(mid2)
if c==c2:
left=mid
right=mid2
elif c>c2:
left=mid
else:
right=mid2
ANS=1<<60
for i in range(left,right+1):
ANS=min(ANS,calc(i))
print(ANS)
``` | output | 1 | 67,535 | 15 | 135,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,536 | 15 | 135,072 |
Tags: greedy, math
Correct Solution:
```
import math
test = int(input())
for t in range(test):
# n, k = map(int, input().split())
n = int(input())
# x = list(map(int, input().split()))
s = input()
x = []
for i in range(n):
if s[i]=="*":
x.append(i+1)
a = len(x)//2
y = [x[a]-a+i for i in range(len(x))]
p = 0
for i in range(len(x)):
p += abs(x[i]-y[i])
print(p)
``` | output | 1 | 67,536 | 15 | 135,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,537 | 15 | 135,074 |
Tags: greedy, math
Correct Solution:
```
def solve():
# put code here
n=int(input())
s=input()
l=0
r=n-1
while l<n and s[l]=='.':
l+=1
while r>=0 and s[r]=='.':
r-=1
if l>=r:
print(0)
return
sr = s.count('*')
sl=0
ans=0
for k in s:
if k=='*':
sl+=1
sr-=1
else:
ans += min(sl, sr)
print(ans)
t = int(input())
for _ in range(t):
solve()
``` | output | 1 | 67,537 | 15 | 135,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9 | instruction | 0 | 67,538 | 15 | 135,076 |
Tags: greedy, math
Correct Solution:
```
"""
// Author : snape_here - Susanta Mukherjee
"""
from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
def lsi(): return list(msi())
def read():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def gcd(x, y):
while y:
x, y = y, x % y
return x
def lcm(x, y):
return (x*y)//(gcd(x,y))
mod=1000000007
def modInverse(b,m):
g = gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
def ceil2(x,y):
if x%y==0:
return x//y
else:
return x//y+1
def modu(a,b,m):
a = a % m
inv = modInverse(b,m)
if(inv == -1):
return -999999999
else:
return (inv*a)%m
from math import log,factorial,cos,tan,sin,radians,floor,sqrt,ceil,log2
import bisect
import random
import string
from decimal import *
getcontext().prec = 50
abc="abcdefghijklmnopqrstuvwxyz"
pi=3.141592653589793238
def gcd1(a):
if len(a) == 1:
return a[0]
ans = a[0]
for i in range(1,len(a)):
ans = gcd(ans,a[i])
return ans
def mykey(x):
return len(x)
def main():
for _ in range(ii()):
n=ii()
s=si()
l=[]
for i in range(n):
if s[i]=='*':
l.append(i)
#print(l)
if len(l)<=1:
print(0)
continue
x = len(l)
c = x//2
y = l[c]-c
ans = 0
for i in range(len(l)):
ans += abs(y-l[i])
y += 1
print(ans)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
#read()
main()
``` | output | 1 | 67,538 | 15 | 135,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
from math import ceil
for _ in range(int(input())):
n = int(input())
s = input()
if s.count('*') < 2:
print(0)
else:
order_num = ceil(s.count('*') / 2)
ind = -1
stars = 0
while stars != order_num:
ind += 1
if s[ind] == '*':
stars += 1
steps = 0
pos = ind - 1
empty_space = 0
while pos != -1:
if s[pos] == '*':
steps += empty_space
else:
empty_space += 1
pos -= 1
pos = ind + 1
empty_space = 0
while pos != n:
if s[pos] == '*':
steps += empty_space
else:
empty_space += 1
pos += 1
print(steps)
``` | instruction | 0 | 67,539 | 15 | 135,078 |
Yes | output | 1 | 67,539 | 15 | 135,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
import math
import collections
import itertools
import bisect
for tt in range(1, int(input()) + 1):
n = int(input())
s = input()
if s.count("*") == 0:
print("0")
continue
one_indexes = [i for i, x in enumerate(s) if x == "*"]
median_count = len(one_indexes) // 2
median_index = one_indexes[median_count]
min_swaps = 0
for count, index in enumerate(one_indexes):
min_swaps += abs(median_index - index) - abs(median_count - count)
print(str(min_swaps))
``` | instruction | 0 | 67,540 | 15 | 135,080 |
Yes | output | 1 | 67,540 | 15 | 135,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
s=input();y=0;b=[]
for i in range(n):
if s[i]=='*':y+=1;b.append(i)
x=y//2
if len(b)==n or len(b)==0 or len(b)==1 : print(0)
else:
moves=0
for i in range(len(b)):
moves+=abs(abs(b[x]-b[i]-1)-abs(x-i-1))
print(moves)
``` | instruction | 0 | 67,541 | 15 | 135,082 |
Yes | output | 1 | 67,541 | 15 | 135,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
s=input()
a=[0]*n
b=[0]*n
l=0
r=n-1
for i in range(n):
if s[i]=='.':
a[i]=i-l
l+=1
for i in range(n-1,-1,-1):
if s[i]=='.':
b[i]=r-i
r-=1
ans=0
for i in range(n):
ans+=min(a[i],b[i])
print(ans)
``` | instruction | 0 | 67,542 | 15 | 135,084 |
Yes | output | 1 | 67,542 | 15 | 135,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
# import sys
# if not sys.warnoptions:
# import warnings
# warnings.simplefilter("ignore")
def countPairs(arr, n):
map = dict()
for i in range(n):
map[arr[i] - i] = map.get(arr[i] - i, 0) + 1
res = 0
for x in map:
cnt = map[x]
res += ((cnt * (cnt - 1)) // 2)
return res
def ii():
return int(input())
def li():
return [int(i) for i in input().split()]
for t in range(ii()):
n = ii()
s = input()
med = []
for i in range(n):
if s[i] == "*":
med.append(i)
if len(med)%2 == 1:
t1 = 0
t2 = 0
mid = med[(len(med))//2]
for i in range(mid,n):
if s[i] == "*":
t1+=i-mid
mid+=1
mid = med[(len(med))//2]
for i in range(mid,-1,-1):
if s[i] == "*":
t1+=mid-i
mid-=1
print(t1)
if len(med)%2 == 0:
print(med)
if len(med) == 0:
print(0)
else:
t1 = 0
t2 = 0
mid = med[(len(med))//2]
for i in range(mid,n):
if s[i] == '*':
t1+=i-mid
mid+=1
mid = med[(len(med))//2]
for i in range(mid,-1,-1):
if s[i] == '*':
t1+=mid-i
mid-=1
mid = med[(len(med))//2 - 1]
for i in range(mid,n):
if s[i] == '*':
t2+=i-mid
mid+=1
mid = med[(len(med))//2 - 1]
for i in range(mid,-1,-1):
if s[i] == '*':
t2+=mid-i
mid-=1
print(min(t1,t2))
``` | instruction | 0 | 67,543 | 15 | 135,086 |
No | output | 1 | 67,543 | 15 | 135,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
#from _typeshed import SupportsKeysAndGetItem
import sys
#sys.stdin=open("input.txt","r");
#sys.stdout=open("output.txt","w")
####### GLOBAL ###############
NO=lambda:print("NO")
YES=lambda:print("YES")
_1=lambda:print(-1)
ari=lambda:[int(_) for _ in input().split()]
cin=lambda:int(input())
cis=lambda:input()
########### END #########
######
test_case=1
test_case=int(input())
######
def ans():
n=cin()
st=cis()
first=None
last=0
for i in range(n):
if st[i]=="*":
if first==None:
first=i
last=i
if first==None or first==last:
print(0)
return
hf=(first+last)//2
lcount=0
rcount=0
for i in range(first,hf+1):
if st[i]=="*":
lcount+=1
if (hf+i+1)< n:
if st[hf+i+1]=="*":
rcount+=1
total=(lcount+rcount)//2
if (lcount+rcount)%2!=0:
total+=1
c=0
for i in range(n):
if st[i]=="*":
c+=1
if c>=total:
hf=i
break
mid=hf
cnt=0
mid=mid
for i in range(mid,first-1,-1):
if st[i]=="*":
cnt+=mid-i
mid=mid-1
mid=hf+1
for i in range(mid,last+1):
if st[i]=="*":
cnt+=(i-mid)
mid+=1
print(cnt)
for _ in range(test_case):
ans()
``` | instruction | 0 | 67,544 | 15 | 135,088 |
No | output | 1 | 67,544 | 15 | 135,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
import io, os
import sys
input = lambda: sys.stdin.readline().rstrip()
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def solve_tc():
n = int(input())
s = list(input())
ans = 0
cnt = 0
cnn = -1
ship = 0
for i in s:
if i == "*":
ship += 1
if ship == 1 or ship == 0:
return str(0)
for i in s:
cnn+=1
if i == "*":
cnt += 1
if cnt == ship//2:
ship2_p = cnn
if cnt == ship//2 + 1:
ship2 = cnn
break
if not ship & 1:
s[ship2_p] = "."
s[ship2-1] = "*"
ship2_p = ship2-1
else:
ship2_p = int(ship2)
brk = False
s1 = list(s)
while 1:
ind = int(ship2)
tmp = 0
while 1:
ind+=1
if ind == n:
brk = True
break
if s[ind] == "*":
s[ind] = "."
ship2 = ship2 + 1
break
else:
tmp += 1
if brk:
brk = False
break
ans += tmp
while 1:
ind = int(ship2_p)
tmp = 0
while 1:
ind -= 1
if ind < 0:
brk = True
break
if s1[ind] == "*":
s1[ind] = "."
ship2_p = ship2_p - 1
break
else:
tmp += 1
if brk:
break
ans += tmp
return str(ans)
t = int(input())
while t > 0:
t -= 1
# sys.stdout.write(" ".join(map(str, solve_tc())))
sys.stdout.write(solve_tc())
sys.stdout.write("\n")
``` | instruction | 0 | 67,545 | 15 | 135,090 |
No | output | 1 | 67,545 | 15 | 135,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.
For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible:
* the sheep at the 4 position moves to the right, the state of the level: "**..*.";
* the sheep at the 2 position moves to the right, the state of the level: "*.*.*.";
* the sheep at the 1 position moves to the right, the state of the level: ".**.*.";
* the sheep at the 3 position moves to the right, the state of the level: ".*.**.";
* the sheep at the 2 position moves to the right, the state of the level: "..***.";
* the sheep are lined up and the game ends.
For a given level, determine the minimum number of moves you need to make to complete the level.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^6).
The second line of each test case contains a string of length n, consisting of the characters '.' (empty space) and '*' (sheep) — the description of the level.
It is guaranteed that the sum of n over all test cases does not exceed 10^6.
Output
For each test case output the minimum number of moves you need to make to complete the level.
Example
Input
5
6
**.*..
5
*****
3
.*.
3
...
10
*.*...*.**
Output
1
0
0
0
9
Submitted Solution:
```
import math
from itertools import combinations as cb
from collections import defaultdict as df
from collections import deque
for _ in range(int(input())):
n=int(input())
s=input()
aa=[]
result=10**9+7
for i in range(n):
if(s[i]=='*'):
aa.append(i)
if len(aa)==0:
print(0)
else:
a,b=[],[]
for i in range(len(aa)):
if(i==0):
a.append(0)
else:
a.append(i*(aa[i]-aa[i-1]-1) +a[i-1])
for i in range(len(aa)-1,-1,-1):
if(i==len(aa)-1):
b.append(0);
else:
b.append((len(aa)-1-i)*(aa[i+1]-aa[i]-1) + b[len(aa)-2-i])
b=sorted(b)[::-1]
for i in range(len(aa)):
result=min(result,a[i]+b[i])
print(result)
``` | instruction | 0 | 67,546 | 15 | 135,092 |
No | output | 1 | 67,546 | 15 | 135,093 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,958 | 15 | 135,916 |
"Correct Solution:
```
H, W, N = map( int, input().split())
X = [ tuple( map( int, input().split())) for _ in range(N)]
X.sort()
d = 0
ans = H
for i in range(N):
if X[i][1]+d == X[i][0]:
d += 1
if X[i][1] + d < X[i][0]:
ans = X[i][0]-1
break
print(ans)
``` | output | 1 | 67,958 | 15 | 135,917 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,959 | 15 | 135,918 |
"Correct Solution:
```
import sys
H,W,N = map(int,input().split())
ans = H
XY = []
now = 0
for i in range(N):
X,Y = map(int,input().split())
XY.append([X,Y])
XY.sort()
for i in range(N):
X = XY[i][0]
Y = XY[i][1]
if Y < X - now:
print (X-1)
sys.exit()
elif Y == X - now:
now += 1
print (H)
``` | output | 1 | 67,959 | 15 | 135,919 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,960 | 15 | 135,920 |
"Correct Solution:
```
import bisect
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
H, W, N = list(map(int, sys.stdin.buffer.readline().split()))
XY = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(N)]
blocked = set()
blocks = [[] for _ in range(W + 1)]
for h, w in sorted(XY):
blocked.add((h, w))
blocks[w].append(h)
for w in range(W + 1):
blocks[w].append(H + 1)
# 高橋くんは毎回動く
# 青木くんが動く回数を決めたとき、先に動けるだけ動くとする
# 後から動いたほうがいい場合はもっと動く回数を少なくできるので
h, w = 1, 1
hist = []
while True:
hist.append((h, w))
if h + 1 <= H and (h + 1, w) not in blocked:
h += 1
else:
break
if w + 1 <= W and (h, w + 1) not in blocked:
w += 1
ans = INF
for h, w in hist:
hi = bisect.bisect_left(blocks[w], h + 1)
ans = min(ans, blocks[w][hi] - 1)
# print(h, w, blocks[w])
print(ans)
``` | output | 1 | 67,960 | 15 | 135,921 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,961 | 15 | 135,922 |
"Correct Solution:
```
X,Y,N = list(map(int,input().split()))
l = []
for i in range(N):
x,y = list(map(int,input().split()))
l.append([x,y])
l.sort()
cnt = 0
ans = 0
for i in l:
if i[0] > i[1]+cnt:
ans = i[0]
break
elif i[0] == i[1]+cnt:
cnt += 1
if ans != 0:
print(ans-1)
else:
print(X)
``` | output | 1 | 67,961 | 15 | 135,923 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,962 | 15 | 135,924 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
H, W, N = map(int, input().split())
A = [[] for _ in range(H+1)]
for _ in range(N):
X, Y = map(int, input().split())
A[X].append(Y)
ans = H
Ymax = 1
for n in range(1, H):
cango = True
for y in A[n+1]:
if y <= Ymax:
ans = n
break
elif y == Ymax+1:
cango = False
if ans != H:
break
if cango:
Ymax += 1
print(ans)
``` | output | 1 | 67,962 | 15 | 135,925 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,963 | 15 | 135,926 |
"Correct Solution:
```
H, W, N = map(int, input().split())
L = [list(map(int, input().split())) for i in range(N)]
dic = {}
for l in L:
try:
dic[l[0]].append(l[1])
except:
dic[l[0]] = [l[1]]
def get(H, N):
area = 1.
for i in range(1, H):
try:
for block in sorted(dic[i+1]):
if 1 <= block and block <= area:
return i
if not area+1 in dic[i+1]:
area += 1
except:
area = area+1
return H
print(get(H, N))
``` | output | 1 | 67,963 | 15 | 135,927 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,964 | 15 | 135,928 |
"Correct Solution:
```
H, W, N = map(int, input().split())
posObss = [{H} for y in range(W)]
for _ in range(N):
X, Y = map(int, input().split())
posObss[Y - 1].add(X - 1)
ans = H
xNow = 0
for y in range(W):
xLim = min([x for x in posObss[y] if x > xNow])
ans = min(ans, xLim)
if y == W - 1: break
xNow += 1
while xNow in posObss[y + 1]:
xNow += 1
if xNow >= xLim: break
print(ans)
``` | output | 1 | 67,964 | 15 | 135,929 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000 | instruction | 0 | 67,965 | 15 | 135,930 |
"Correct Solution:
```
#設定
import sys
input = sys.stdin.buffer.readline
#ライブラリインポート
from collections import defaultdict
INF = float("inf")
#入力受け取り
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
H, W, N = getlist()
L = []
for i in range(N):
x, y = getlist()
L.append((x, y))
L = sorted(L)
damage = 0
ans = INF
xval = 0
for i in range(N):
x, y = L[i][0], L[i][1]
if x >= y + 1 + damage:
ans = x - 1
break
if x == y + damage and xval != x:
damage += 1
xval = x
print(min(ans, H))
if __name__ == '__main__':
main()
``` | output | 1 | 67,965 | 15 | 135,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
H, W, n = map(int, input().split())
obst = []
for _ in range(n):
x, y = map(int, input().split())
if x >= y:
obst.append([x-1, y-1, x-y])
#obst.sort(key=lambda x: (x[2], x[0]))
#print(obst)
bothered = [1000000] * (H+1)
for i in range(len(obst)):
h, w, gap = obst[i][0], obst[i][1], obst[i][2]
#if gap == 0:
#bothered[1] = min(bothered[1], h+1)
#continue
bothered[gap+1] = min(bothered[gap+1], h+1)
#if h < bothered[gap]:
#print(h)
#break
obst.sort(key=lambda x: x[0])
for i in range(len(obst)):
h, w, gap = obst[i][0], obst[i][1], obst[i][2]
if gap == 0:
continue
if h < bothered[gap]:
print(h)
break
else:
print(H)
``` | instruction | 0 | 67,966 | 15 | 135,932 |
Yes | output | 1 | 67,966 | 15 | 135,933 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
readline = open(0).readline
write = open(1, 'w').write
H, W, N = map(int, readline().split())
Y = [W+1]*(H+1)
P = [[] for i in range(W+1)]
for i in range(N):
x, y = map(int, readline().split())
if x < y:
continue
Y[x-y] = min(Y[x-y], y-1)
P[y-1].append(x-1)
base = 0
ans = H
for y in range(W):
while Y[base] == y:
base += 1
xmin = y + base
for x in P[y]:
if xmin <= x:
ans = min(x, ans)
write("%d\n" % ans)
``` | instruction | 0 | 67,967 | 15 | 135,934 |
Yes | output | 1 | 67,967 | 15 | 135,935 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
from collections import defaultdict
import sys
def inpl(): return [int(i) for i in input().split()]
H, W, N = inpl()
if not N:
print(H)
sys.exit()
A = []
B = defaultdict(lambda: [])
C = defaultdict(lambda: H+1)
for _ in range(N):
x, y = inpl()
A.append((x,y))
B[y].append(x)
T = [0]*(W+1)
T[1] = 2
for i in range(1,W):
if not B[i+1]:
T[i+1] = T[i] + 1
continue
ctr = T[i]
while True:
if ctr in B[i+1]:
ctr += 1
continue
break
T[i+1] = min(ctr+1, H+1)
for x,y in A:
if x >= T[y]:
C[y] = min(C[y], x)
print(min([i-1 for i in C.values()]+[H]))
``` | instruction | 0 | 67,968 | 15 | 135,936 |
Yes | output | 1 | 67,968 | 15 | 135,937 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
import sys
input = sys.stdin.readline
H,W,N = map(int,input().split())
XY = sorted(tuple(int(x) for x in row.split()) for row in sys.stdin.readlines())
"""
・Tは常に移動
・選択肢はAのみ。Aが詰み地点に誘導するゲーム
・Aが誘導できるy座標集合は、今まで仕留められる場所が存在した場合を除いて区間[1,U]
"""
X_to_Y = [set() for _ in range(H+1)]
for x,y in XY:
X_to_Y[x].add(y)
U = 0
for x in range(1,H+1):
if x == H:
break
if not (U+1 in X_to_Y[x]):
U += 1
# ゴールしていればbreak
if any(y<=U for y in X_to_Y[x+1]):
break
print(x)
``` | instruction | 0 | 67,969 | 15 | 135,938 |
Yes | output | 1 | 67,969 | 15 | 135,939 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
h, w, n = map(int, input().split())
xy = [list(map(int, input().split())) for i in range(n)]
xy.sort(key=lambda x:x[1])
cnt = 0
for x, y in xy:
if y + cnt == x:
cnt += 1
elif y + cnt < x:
exit(print(x - 1))
print(h)
``` | instruction | 0 | 67,970 | 15 | 135,940 |
No | output | 1 | 67,970 | 15 | 135,941 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
h, w, n = map(int, input().split())
ps = [[] for i in range(h)]
blocks = set()
for i in range(n):
x, y = map(lambda x: int(x)-1, input().split())
# if x < y:
# continue
ps[y].append(x)
blocks.add((x, y))
y_app_x = [[w+1] for i in range(h)]
x, y = (0, 0)
cands = [w]
while y < h:
if (x+1, y) in blocks:
# 高橋君は移動できなければ = 障害物に移動すると即死
cands.append(x+1)
break
else:
ps[y] = [p for p in ps[y] if p > x]
if ps[y]:
cands.append(min(ps[y]))
x += 1
while (x, y+1) in blocks and x < w:
x += 1
y += 1
print(min(cands))
``` | instruction | 0 | 67,971 | 15 | 135,942 |
No | output | 1 | 67,971 | 15 | 135,943 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
import numpy as np
(H,W,N) = map(int,input().split())
if N==0:
print(W)
exit()
XY = np.array([ list(map(int,input().split())) for _ in range(N)], dtype=np.int)
X = XY[:,0]
Y = XY[:,1]
diff = X - Y
ind = np.where(diff >= 0)[0]
M = len(ind)
if M==0:
print(W)
exit()
order = X[ind].argsort()
X = (X[ind])[order]
Y = (Y[ind])[order]
ymax = 1
j = 0
x = 1
while j < M:
i = j
dx = X[i]-x
x = X[i]
ymax += dx-1
while j < M:
if X[j]==x:
j += 1
else:
break
if np.any(Y[i:j]<=ymax):
print(x-1)
exit()
elif np.any(Y[i:j]==ymax+1):
pass
else:
ymax += 1
print(W)
``` | instruction | 0 | 67,972 | 15 | 135,944 |
No | output | 1 | 67,972 | 15 | 135,945 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game using a grid with H rows and W columns of square cells. There are N obstacles on this grid; the i-th obstacle is at (X_i,Y_i). Here, we represent the cell at the i-th row and j-th column (1 \leq i \leq H, 1 \leq j \leq W) by (i,j). There is no obstacle at (1,1), and there is a piece placed there at (1,1).
Starting from Takahashi, he and Aoki alternately perform one of the following actions:
* Move the piece to an adjacent cell. Here, let the position of the piece be (x,y). Then Takahashi can only move the piece to (x+1,y), and Aoki can only move the piece to (x,y+1). If the destination cell does not exist or it is occupied by an obstacle, this action cannot be taken.
* Do not move the piece, and end his turn without affecting the grid.
The game ends when the piece does not move twice in a row.
Takahashi would like to perform as many actions (including not moving the piece) as possible before the game ends, while Aoki would like to perform as few actions as possible before the game ends. How many actions will Takahashi end up performing?
Constraints
* 1 \leq H,W \leq 2\times 10^5
* 0 \leq N \leq 2\times 10^5
* 1 \leq X_i \leq H
* 1 \leq Y_i \leq W
* If i \neq j, (X_i,Y_i) \neq (X_j,Y_j)
* (X_i,Y_i) \neq (1,1)
* X_i and Y_i are integers.
Input
Input is given from Standard Input in the following format:
H W N
X_1 Y_1
:
X_N Y_N
Output
Print the number of actions Takahashi will end up performing.
Examples
Input
3 3 1
3 2
Output
2
Input
10 10 14
4 3
2 2
7 3
9 10
7 7
8 1
10 10
5 4
3 4
2 8
6 4
4 4
5 8
9 2
Output
6
Input
100000 100000 0
Output
100000
Submitted Solution:
```
x,y,num = map(int, input().split())
gaiz = [x]*x
kaisu = x
for _ in range(num):
xg,yg = map(int,input().split())
if xg >= yg:
sa = xg-yg
if yg < gaiz[sa]:
gaiz[sa]=(yg)
if len(gaiz) ==0:
print(kaisu)
else:
for num,(maegai,gai) in enumerate(zip(gaiz[:-1],gaiz[1:])):
if maegai>gai:
kaisu = num+gai
if num > 0:
if gaiz[num-1]>gai:
kaisu-=1
break
print(kaisu)
``` | instruction | 0 | 67,973 | 15 | 135,946 |
No | output | 1 | 67,973 | 15 | 135,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,193 | 15 | 136,386 |
Tags: graphs
Correct Solution:
```
N, K = map(int, input().split())
X = list(map(lambda x: int(x) - 1, input().split()))
inf = 10**9+7
Fi = [inf]*N
La = [-1]*N
for i, x in enumerate(X):
Fi[x] = min(Fi[x], i)
for i, x in enumerate(X[::-1]):
La[x] = max(La[x], K-1-i)
ans = sum(1 if l < 0 else 0 for l in La)
for i in range(N-1):
if Fi[i] > La[i+1]:
ans += 1
if Fi[i+1] > La[i]:
ans += 1
print(ans)
``` | output | 1 | 68,193 | 15 | 136,387 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,194 | 15 | 136,388 |
Tags: graphs
Correct Solution:
```
def main():
n, k = map(int, input().split())
x = list(map(int, input().split()))
minus1 = [False] * (k+1)
plus1 = [False] * (k+1)
dminus1 = {}
dplus1 = {}
for i, val in enumerate(x):
if val < n and val+1 in dminus1:
for ind in dminus1[val+1]:
minus1[ind] = True
del(dminus1[val+1])
if val > 1 and val-1 in dplus1:
for ind in dplus1[val-1]:
plus1[ind] = True
del(dplus1[val-1])
if val in dminus1:
dminus1[val].append(i)
else:
dminus1[val] = [i]
if val in dplus1:
dplus1[val].append(i)
else:
dplus1[val] = [i]
usedMinus1 = set()
usedPlus1 = set()
res = n - len(set(x)) + (n-2)*2 + 2
for i, val in enumerate(x):
# k, k+1
if val != n and plus1[i] and val not in usedPlus1:
res -= 1
usedPlus1.add(val)
if val != 1 and minus1[i] and val not in usedMinus1:
res -= 1
usedMinus1.add(val)
print(res)
if __name__ == '__main__':
main()
``` | output | 1 | 68,194 | 15 | 136,389 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,195 | 15 | 136,390 |
Tags: graphs
Correct Solution:
```
n, k = map(int, input().split())
q = list(map(int, input().split()))
seen = [False]*(n+2)
cnt = (n-2)*3+2*2
impossible = set()
for x in q:
seen[x] = True
impossible.add((x,x))
if seen[x-1]: impossible.add((x, x-1))
if seen[x+1]: impossible.add((x, x+1))
print(cnt-len(impossible))
``` | output | 1 | 68,195 | 15 | 136,391 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,196 | 15 | 136,392 |
Tags: graphs
Correct Solution:
```
import math
import bisect
import heapq
from collections import defaultdict
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, x, y = egcd(b % a, a)
return (g, y - (b // a) * x, x)
def mulinv(b, n):
g, x, _ = egcd(b, n)
if g == 1:
return x % n
primes = []
def isprime(n):
for d in range(2, int(math.sqrt(n))+1):
if n % d == 0:
return False
return True
def argsort(ls):
return sorted(range(len(ls)), key=ls.__getitem__)
def f(p=0):
if p == 1:
return map(int, input().split())
elif p == 2:
return list(map(int, input().split()))
else:
return int(input())
n, k = f(1)
cl = f(2)
if n==1:
print(0)
else:
dl = [-1]*(n+2)
for i in range(k):
if dl[cl[i]]==-1:
dl[cl[i]] = i
pl = [[0 for _ in range(3)] for _ in range(n+2)]
for i in range(k-1, -1, -1):
if i>=dl[cl[i]-1]:
pl[cl[i]-1][2] = 1
if i>=dl[cl[i]+1]:
pl[cl[i]+1][0] = 1
pl[cl[i]][1] = 1
res = 4+(n-2)*3
for i in range(1, n+1):
if dl[i]!=-1:
res-=sum(pl[i])
print(res)
``` | output | 1 | 68,196 | 15 | 136,393 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,197 | 15 | 136,394 |
Tags: graphs
Correct Solution:
```
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def solve():
n, k = ri()
fst = [inf] * n
lst = [-inf] * n
A = list(ri())
for i in range(k):
x = A[i]
x -= 1
fst[x] = min(fst[x], i)
lst[x] = i
ans = 0
for i in range(n):
if fst[i] == inf:
ans += 1
if i > 0 and (fst[i] == inf or fst[i] > lst[i-1]):
ans += 1
if i < n-1 and (fst[i] == inf or fst[i] > lst[i+1]):
ans += 1
print(ans)
t = 1
#t = int(input())
while t:
t -= 1
solve()
``` | output | 1 | 68,197 | 15 | 136,395 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | instruction | 0 | 68,198 | 15 | 136,396 |
Tags: graphs
Correct Solution:
```
from math import *
from collections import *
from bisect import *
import sys
input=sys.stdin.readline
t=1
while(t):
t-=1
n,k=map(int,input().split())
a=list(map(int,input().split()))
vis=set()
for i in a:
vis.add((i,i))
if((i-1,i-1) in vis):
vis.add((i-1,i))
if((i+1,i+1) in vis):
vis.add((i+1,i))
r=n+(2*n)-2
print(r-len(vis))
``` | output | 1 | 68,198 | 15 | 136,397 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.