message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.remove(0)
b.remove(0)
print(('NO', 'YES')[b in a + a])
``` | instruction | 0 | 74,603 | 8 | 149,206 |
No | output | 1 | 74,603 | 8 | 149,207 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,786 | 8 | 149,572 |
"Correct Solution:
```
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N,M = inpl()
if M == N-1: # 一本道
for _ in range(M):
s,t = inpl()
print(M)
else:
lines = defaultdict(set)
LL = [0]*N
for _ in range(M):
s,t = inpl()
s -= 1; t -= 1
lines[s].add(t)
LL[s] += 1
def dfs(s):
global MEMO
if MEMO[s] != -1:
return MEMO[s]
else:
tmp = 0
for t in lines[s]:
if MEMO[t] != -1:
tmp += MEMO[t] + 1
else:
tmp += dfs(t) + 1
MEMO[s] = tmp / LL[s]
return MEMO[s]
MEMO = [-1]*N
MEMO[-1] = 0
dfs(0)
koho = [-1]*N
for s in range(N):
x = -1
for t in lines[s]:
if x < MEMO[t]:
x = MEMO[t]
koho[s] = t
ans = 10**10
for s in range(N-1):
t = koho[s]
if LL[s] == 1 or t == -1:
continue
MEMO = [-1]*N
MEMO[-1] = 0
lines[s].remove(t)
LL[s] -= 1
ans = min(ans,dfs(0))
lines[s].add(t)
LL[s] += 1
print(ans)
``` | output | 1 | 74,786 | 8 | 149,573 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,787 | 8 | 149,574 |
"Correct Solution:
```
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
n,m = mi()
tree = [[] for _ in range(n)]
for i in range(m):
s,t = mi()
tree[s-1].append(t-1)
dp = [0]*n
for i in reversed(range(n-1)):
size = len(tree[i])
for k in tree[i]:
dp[i] += dp[k]
dp[i] /= size
dp[i] += 1
ans = dp[0]
def func(ss,tt):
tmp = 0
for l in tree[ss]:
if l == tt:
continue
tmp += dp[l]
tmp = tmp/(len(tree[ss])-1) + 1
if tmp > dp[ss]:
return dp[0]
else:
dp[ss] = tmp
for a in reversed(range(ss)):
tmp = 0
for b in tree[a]:
tmp += dp[b]
dp[a] = tmp/len(tree[a]) + 1
return dp[0]
for i in range(n-1):
if len(tree[i]) == 1:
continue
for k in tree[i]:
ans = min(ans,func(i,k))
print(ans)
``` | output | 1 | 74,787 | 8 | 149,575 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,788 | 8 | 149,576 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
N,M=map(int,input().split())
R=[tuple(map(int,input().split())) for i in range(M)]
E=[set() for i in range(N)]
for x,y in R:
E[x-1].add(y-1)
DP=[M]*N
DP[N-1]=0
for i in range(N-2,-1,-1):
score=0
for x in E[i]:
score+=1+DP[x]
DP[i]=score/len(E[i])
ANS=DP[0]
for i in range(N-2):
rem=-1
remsc=0
for j in E[i]:
if DP[j]>remsc:
rem=j
remsc=DP[j]
if remsc==0:
continue
E[i].remove(rem)
NDP=[M]*N
NDP[N-1]=0
for l in range(N-2,-1,-1):
score=0
if len(E[l])==0:
continue
for x in E[l]:
score+=1+NDP[x]
NDP[l]=score/len(E[l])
#print(i,rem,E,NDP)
ANS=min(ANS,NDP[0])
E[i].add(rem)
print(ANS)
``` | output | 1 | 74,788 | 8 | 149,577 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,789 | 8 | 149,578 |
"Correct Solution:
```
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
def main():
n,m = mi()
tree = [[] for _ in range(n)]
for i in range(m):
s,t = mi()
tree[s-1].append(t-1)
dp = [0]*n
dpl = [0]*n
for i in range(n-1):
dpl[i] = len(tree[i])
for i in reversed(range(n-1)):
for k in tree[i]:
dp[i] += dp[k]
dp[i] /= dpl[i]
dp[i] += 1
ans = dp[0]
def func(ss,tt):
tmp = 0
for l in tree[ss]:
if l == tt:
continue
tmp += dp[l]
tmp = tmp/(dpl[ss] -1) + 1
if tmp > dp[ss]:
return dp[0]
else:
dp[ss] = tmp
for a in reversed(range(ss)):
tmp = 0
for b in tree[a]:
tmp += dp[b]
dp[a] = tmp/dpl[a] + 1
return dp[0]
for i in range(n-1):
if len(tree[i]) == 1:
continue
for k in tree[i]:
ans = min(ans,func(i,k))
print(ans)
main()
``` | output | 1 | 74,789 | 8 | 149,579 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,790 | 8 | 149,580 |
"Correct Solution:
```
n, m = map(int, input().split())
edges = [[] for _ in range(n)]
for _ in range(m):
s, t = map(int, input().split())
edges[n - s].append(n - t)
dp = [0.0] * n
for i in range(1, n):
dp[i] = sum(dp[s] + 1.0 for s in edges[i]) / len(edges[i])
ret = dp[-1]
for j in range(n - 1, 0, -1):
if len(edges[j]) > 1:
values = sorted(dp[s] + 1.0 for s in edges[j])
dp[j] = (sum(values) - values[-1]) / (len(edges[j]) - 1)
for i in range(j + 1, n):
dp[i] = sum(dp[s] + 1.0 for s in edges[i]) / len(edges[i])
ret = min(ret, dp[-1])
print(ret)
``` | output | 1 | 74,790 | 8 | 149,581 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,791 | 8 | 149,582 |
"Correct Solution:
```
import sys
n, m = map(int, input().split())
links = [set() for _ in range(n)]
counts = [0] * n
for line in sys.stdin:
s, t = map(int, line.split())
s -= 1
t -= 1
links[s].add(t)
counts[s] += 1
# Expected number of edges passing from i to N
expected = [0.] * n
exp_get = expected.__getitem__
# i から伸びる辺を1本消すことで削減できる"iからNまでの辺数の期待値"の最大量
reducible = [0.] * n
for i in range(n - 2, -1, -1):
nxt_exp = list(map(exp_get, links[i]))
sum_exp = sum(nxt_exp)
cnt = counts[i]
expected[i] = sum_exp / cnt + 1
if cnt > 1:
reduced_exp = (sum_exp - max(nxt_exp)) / (cnt - 1) + 1
reducible[i] = expected[i] - reduced_exp
else:
reducible[i] = 0.
# Probability of visiting i when starting from 1
probability = [0.] * n
probability[0] = 1.
rdc = 0.
for i in range(n - 1):
fp = probability[i]
jp = fp / counts[i]
for j in links[i]:
probability[j] += jp
rdc = max(rdc, fp * reducible[i])
print(expected[0] - rdc)
``` | output | 1 | 74,791 | 8 | 149,583 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,792 | 8 | 149,584 |
"Correct Solution:
```
N, M = list(map(int, input().split()))
st = [list(map(int, input().split())) for _ in range(M)]
R = {}
for s, t in st:
s -= 1
t -= 1
if s in R:
R[s].append(t)
else:
R[s] = [t]
DP = [0] * N
ans = N
D = [0] * N
for i in range(N - 2, -1, -1):
ma = 0
su = 0
le = len(R[i])
for j in R[i]:
su += DP[j]
ma = max(ma, DP[j])
DP[i] = su / le + 1
if le == 1:
D[i] = 0
else:
D[i] = DP[i] - (((su - ma) / (le - 1)) + 1)
P = [0] * N
P[0] = 1
ma = 0
man = -1
for i in range(N - 1):
t = P[i] / len(R[i])
for j in R[i]:
P[j] += t
t = P[i] * D[i]
R[i].sort()
if ma < t:
ma = t
man = i
if ma == -1:
print(DP[0])
else:
print(DP[0] - ma)
``` | output | 1 | 74,792 | 8 | 149,585 |
Provide a correct Python 3 solution for this coding contest problem.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333 | instruction | 0 | 74,793 | 8 | 149,586 |
"Correct Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,m = LI()
v = [[] for i in range(n)]
v_ = [[] for i in range(n)]
for i in range(m):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v_[b].append(a)
dp = [0]*n
for y in range(1,n)[::-1]:
v_[y].sort()
d = dp[y]
for x in v_[y]:
dp[x] += (d+1)/len(v[x])
ans = dp[0]
lx = []
for a in range(n-1):
lx.append(len(v[a])-1)
if len(v[a]) == 1:
lx[-1] += 1
continue
m = max([dp[b] for b in v[a]])
for b in v[a]:
if dp[b] == m:
break
for i in range(a+1):
dp[i] = 0
for y in range(1,n)[::-1]:
d = dp[y]
for x in v_[y]:
if x > a:
break
if (x,y) == (a,b):
continue
dp[x] += (d+1)/lx[x]
if 0 < dp[0] < ans:
ans = dp[0]
lx[-1] += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
``` | output | 1 | 74,793 | 8 | 149,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
n, m = map(int, input().split())
st = [list(map(int, input().split())) for _ in range(m)]
e = [[] for _ in range(n)]
for s, t in st:
e[s-1].append(t-1)
ans = float('inf')
for i in range(n-2, -1, -1):
if len(e[i]) <= 1:
continue
dp = [0.0 for _ in range(n)]
for j in range(n-2, i, -1):
temp = 0.0
for x in e[j]:
temp += dp[x]
dp[j] = temp / len(e[j]) + 1.0
temp = 0.0
mx = 0.0
for x in e[i]:
temp += dp[x]
mx = max(mx, dp[x])
dp[i] = (temp - mx) / (len(e[i]) - 1) + 1.0
for j in range(i-1, -1, -1):
temp = 0.0
for x in e[j]:
temp += dp[x]
dp[j] = temp / len(e[j]) + 1.0
ans = min(ans, dp[0])
if ans == float('inf'):
dp = [0.0 for _ in range(n)]
for j in range(n-2, -1, -1):
temp = 0.0
for x in e[j]:
temp += dp[x]
dp[j] = temp / len(e[j]) + 1.0
print(dp[0])
else:
print(ans)
``` | instruction | 0 | 74,794 | 8 | 149,588 |
Yes | output | 1 | 74,794 | 8 | 149,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
def main():
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
adj = [[] for _ in range(N+1)]
for _ in range(M):
s, t = map(int, input().split())
adj[s].append(t)
dp0 = [0.] * (N+1)
ans = N-1
for i in range(N-1, 0, -1):
s = 0
m = -1
maxj = 0
for j in adj[i]:
s += dp0[j]
if dp0[j] > m:
m = dp0[j]
maxj = j
dp0[i] = s / len(adj[i]) + 1
if len(adj[i]) > 1:
dp = dp0[:]
dp[i] = (s - m) / (len(adj[i]) - 1) + 1
for ii in range(i-1, 0, -1):
ss = 0
for jj in adj[ii]:
ss += dp[jj]
dp[ii] = ss / len(adj[ii]) + 1
ans = min(ans, dp[1])
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 74,795 | 8 | 149,590 |
Yes | output | 1 | 74,795 | 8 | 149,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
import math
N, M = [int(x) for x in input().split()]
edges = [[int(x) for x in input().split()] for _ in range(M)]
forward_edges = {n+1:[] for n in range(N)}
reverse_edges = {n+1:[] for n in range(N)}
for e in edges:
forward_edges[e[0]].append(e[1])
reverse_edges[e[1]].append(e[0])
# print( forward_edges)
# print( reverse_edges)
estimated_distance = {n+1:None for n in range(N)}
estimated_distance[N] = 0
probability = {n+1:None for n in range(N)}
probability[1] = 1
def get_probability(n):
if probability[n] is not None:
return probability[n]
prob = 0
for m in reverse_edges[n]:
prob += get_probability(m) / len(forward_edges[m])
probability[n] = prob
return prob
def get_distance(n):
if estimated_distance[n] is not None:
return estimated_distance[n]
total_distance = 0
for m in forward_edges[n]:
total_distance += get_distance(m)
estimated_distance[n] = 1 + total_distance / len(forward_edges[n])
return estimated_distance[n]
before_distance = get_distance(1)
max_decrease = 0
for n in range(1, N):
if len(forward_edges[n]) == 1:
continue
distances = [get_distance(m) for m in forward_edges[n]]
distance_diff = sum(distances) / len(distances) - (
sum(distances)-max(distances))/(len(distances)-1)
decrease = get_probability(n) * distance_diff
max_decrease = max(max_decrease, decrease)
print(before_distance - max_decrease)
``` | instruction | 0 | 74,796 | 8 | 149,592 |
Yes | output | 1 | 74,796 | 8 | 149,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))
def main():
n,m = mi()
tree = [[] for _ in range(n)]
for i in range(m):
s,t = mi()
tree[s-1].append(t-1)
dp = [0]*n
for i in reversed(range(n-1)):
size = len(tree[i])
for k in tree[i]:
dp[i] += dp[k]
dp[i] /= size
dp[i] += 1
ans = dp[0]
def func(ss,tt):
tmp = 0
for l in tree[ss]:
if l == tt:
continue
tmp += dp[l]
tmp = tmp/(len(tree[ss])-1) + 1
if tmp > dp[ss]:
return dp[0]
else:
dp[ss] = tmp
for a in reversed(range(ss)):
tmp = 0
for b in tree[a]:
tmp += dp[b]
dp[a] = tmp/len(tree[a]) + 1
return dp[0]
for i in range(n-1):
if len(tree[i]) == 1:
continue
for k in tree[i]:
ans = min(ans,func(i,k))
print(ans)
main()
``` | instruction | 0 | 74,797 | 8 | 149,594 |
Yes | output | 1 | 74,797 | 8 | 149,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
N, M = map(int, input().split())
v = [[] for _ in range(N)]
for i in range(M) :
s, t = map(int, input().split())
v[s-1].append(t-1)
# 削除しないでdp
dp = [0] * N
for i in range(N - 1, -1, -1) :
if len(v[i]) == 0 :
continue
s = [dp[j] for j in v[i]]
dp[i] = 1 + sum(s) / len(v[i])
ret = dp[0]
# 削除してdp
for i in range(N) :
if len(v[i]) == 0 :
continue
for j in range(i, -1, -1) :
if len(v[j]) == 0 :
continue
s = [dp[k] for k in v[j]]
if j == i :
if len(v[j]) != 1 :
dp[j] = 1 + (sum(s) - max(s)) / (len(v[j]) - 1)
else :
dp[j] = 1 + sum(s) / len(v[j])
ret = min(ret, dp[0])
print(ret)
``` | instruction | 0 | 74,798 | 8 | 149,596 |
No | output | 1 | 74,798 | 8 | 149,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
import sys
import numpy as np
n, m = map(int, input().split())
links = [[] for _ in range(n)]
for line in sys.stdin:
s, t = map(int, line.split())
s -= 1
t -= 1
links[s].append(t)
not_omitted = np.zeros(n, dtype=np.float64)
for j in range(n - 2, -1, -1):
exp = not_omitted[links[j]]
not_omitted[j] = exp.mean() + 1
ans = not_omitted[0]
for i in range(n - 1):
expected = not_omitted.copy()
exp = expected[links[i]]
if exp.size == 1:
expected[i] = exp.mean() + 1
else:
expected[i] = (exp.sum() - exp.max()) / (exp.size - 1) + 1
for j in range(i - 1, -1, -1):
exp = expected[links[j]]
expected[j] = exp.mean() + 1
ans = min(ans, expected[0])
print(ans)
``` | instruction | 0 | 74,799 | 8 | 149,598 |
No | output | 1 | 74,799 | 8 | 149,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
import numpy as np
import sys
input = sys.stdin.readline
N,M = map(int,input().split(' '))
g = [[] for i in range(N+1)]
for i in [0]*M:
s,t = map(int,input().split(' '))
g[s].append(t)
# i == 0 : no obstruction
#dp = [[0] * (N+1) for i in range(N-1)]
dp = np.zeros((N-1,N+1))
#for i in range(N-1):
# dp[i][N-1] = 1
dp[:,N-1] = 1
for v in range(N-2,0,-1):
n = len(g[v])
cand = dp[:,g[v]]
dp[:,v] = np.sum(cand,axis=1) / n + 1
if n > 1:
cand = cand[v]
dp[v,v] = (np.sum(cand) - np.max(cand))/(n-1) + 1
'''
for i in range(N-1):
cand = [dp[i][nv] for nv in g[v]]
if i == v and n > 1:
dp[i][v] = (np.sum(cand)-np.max(cand)) / (n-1) + 1
else:
dp[i][v] = np.sum(cand) / n + 1
'''
#ans = min([dp[i][1] for i in range(N-1)])
ans = np.min(dp[:,1])
print(ans)
``` | instruction | 0 | 74,800 | 8 | 149,600 |
No | output | 1 | 74,800 | 8 | 149,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
Submitted Solution:
```
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, atan2, degrees
from operator import mul
from functools import reduce
sys.setrecursionlimit(10**8)
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n, m = LI()
G = [[] for _ in range(n)]
for _ in range(m):
s, t = LI()
G[s - 1] += [t - 1]
route_len = [0] * n
for u in range(n - 2, -1, -1):
route_len[u] = sum([route_len[v] + 1 for v in G[u]]) / len(G[u])
prob = [0] * n
prob[0] = 1
for u in range(n - 1):
for v in G[u]:
prob[v] += prob[u] / len(G[u])
ans = INF
for u in range(n - 1):
if len(G[u]) == 1:
continue
new_route_len = (sum([route_len[v] + 1 for v in G[u]]) - max([route_len[v] + 1 for v in G[u]])) / (len(G[u]) - 1)
ans = min(ans, route_len[0] - prob[u] * (route_len[u] - new_route_len))
print(ans)
``` | instruction | 0 | 74,801 | 8 | 149,602 |
No | output | 1 | 74,801 | 8 | 149,603 |
Provide a correct Python 3 solution for this coding contest problem.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3 | instruction | 0 | 74,818 | 8 | 149,636 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def dfs(u=0,pu=-1):
if aa[u]<0:dp[u][0][0]=aa[u]
else:dp[u][1][0]=aa[u]
for v in to[u]:
if v==pu:continue
dfs(v,u)
size[u]+=size[v]
ndp0=[inf]*n
ndp1=[inf]*n
for k in range(size[u]):
pre=dp[u][0][k]
if pre==inf:continue
for kv in range(size[v]):
s=dp[v][0][kv]
if s!=inf:ndp0[k+kv+1]=min(ndp0[k+kv+1],pre+s)
if s<0:ndp0[k+kv]=min(ndp0[k+kv],pre)
s = dp[v][1][kv]
if s != inf: ndp0[k + kv+1] = min(ndp0[k + kv+1], pre + s)
if s != inf: ndp0[k + kv] = min(ndp0[k + kv], pre)
for k in range(size[u]):
pre=dp[u][1][k]
if pre==inf:continue
for kv in range(size[v]):
s=dp[v][0][kv]
if s!=inf:ndp0[k+kv+1]=min(ndp0[k+kv+1],pre+s)
if s<0:ndp1[k+kv]=min(ndp1[k+kv],pre)
s = dp[v][1][kv]
if s != inf: ndp1[k + kv+1] = min(ndp1[k + kv+1], pre + s)
if s != inf: ndp1[k + kv] = min(ndp1[k + kv], pre)
dp[u][0]=ndp0
dp[u][1]=ndp1
inf=10**16
n=II()
aa=LI()
to=[[] for _ in range(n)]
for _ in range(n-1):
u,v=MI1()
to[u].append(v)
to[v].append(u)
dp=[[[inf]*n for _ in range(2)] for _ in range(n)]
size=[1]*n
dfs()
mx=0
for k in range(n-1,-1,-1):
if dp[0][0][k]<0:
mx=max(mx,k)
break
for k in range(n-1,-1,-1):
if dp[0][1][k]!=inf:
mx=max(mx,k)
break
print(n-1-mx)
``` | output | 1 | 74,818 | 8 | 149,637 |
Provide a correct Python 3 solution for this coding contest problem.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3 | instruction | 0 | 74,819 | 8 | 149,638 |
"Correct Solution:
```
from collections import deque
N=int(input())
A=list(map(int,input().split()))
edge=[[] for i in range(N)]
for _ in range(N-1):
u,v=map(int,input().split())
edge[u-1].append(v-1)
edge[v-1].append(u-1)
ans=[0]
parent=[-1]*N
que=deque([(0,-1)])
while que:
v,pv=que.popleft()
for nv in edge[v]:
if nv!=pv:
parent[nv]=v
ans.append(nv)
que.append((nv,v))
ans=ans[::-1]
for v in range(N):
edge[v]=[nv for nv in edge[v] if nv!=parent[v]]
dpc=[[] for i in range(N)]
dpn=[[] for i in range(N)]
sz=[0]*N
for v in ans:
sz[v]=1
sz[v]=1
dpc[v]=[10**18,A[v]]
for nv in edge[v]:
merged=[10**18]*(sz[v]+sz[nv]+1)
for i in range(1+sz[v]):
for j in range(1+sz[nv]):
merged[i+j-1]=min(merged[i+j-1],dpc[v][i]+min(dpc[nv][j],dpn[nv][j]))
if dpn[nv][j]<=10**15:
merged[i+j]=min(merged[i+j],dpc[v][i])
dpc[v]=merged
sz[v]+=sz[nv]
sz[v]=1
if A[v]<0:
dpn[v]=[10**18]*2
else:
dpn[v]=[10**18,A[v]]
for nv in edge[v]:
merged=[10**18]*(sz[v]+sz[nv]+1)
for i in range(1,1+sz[v]):
for j in range(1,1+sz[nv]):
if dpc[nv][j]<0:
merged[i+j]=min(merged[i+j],dpn[v][i])
merged[i+j-1]=min(merged[i+j-1],dpn[v][i]+dpn[nv][j])
if dpn[nv][j]<=10**15:
merged[i+j]=min(merged[i+j],dpn[v][i])
dpn[v]=merged
sz[v]+=sz[nv]
ans=N
for i in range(1,N+1):
if dpc[0][i]<0 or dpn[0][i]<=10**15:
ans=i
break
print(ans-1)
``` | output | 1 | 74,819 | 8 | 149,639 |
Provide a correct Python 3 solution for this coding contest problem.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3 | instruction | 0 | 74,820 | 8 | 149,640 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**9)
INF = 10**15
N = int(input())
As = list(map(int, input().split()))
adjL = [[] for _ in range(N)]
for _ in range(N-1):
U, V = map(int, input().split())
U, V = U-1, V-1
adjL[U].append(V)
adjL[V].append(U)
useds = [False] * N
sizes = [0] * N
dp0 = [[] for _ in range(N)]
dp1 = [[] for _ in range(N)]
def dfs(v):
useds[v] = True
sizes[v] = 1
dp0[v] = [As[v] if As[v] > 0 else INF]
dp1[v] = [As[v] if As[v] < 0 else INF]
for v2 in adjL[v]:
if useds[v2]: continue
dfs(v2)
merged0 = [INF] * (sizes[v]+sizes[v2])
merged1 = [INF] * (sizes[v]+sizes[v2])
for i in range(sizes[v]):
for j in range(sizes[v2]):
merged0[i+j] = min(merged0[i+j], dp0[v][i]+dp0[v2][j])
merged1[i+j] = min(merged1[i+j], dp0[v][i]+dp1[v2][j])
merged1[i+j] = min(merged1[i+j], dp1[v][i]+dp0[v2][j])
merged1[i+j] = min(merged1[i+j], dp1[v][i]+dp1[v2][j])
if dp0[v2][j] != INF:
merged0[i+j+1] = min(merged0[i+j+1], dp0[v][i])
if dp1[v2][j] < 0:
merged0[i+j+1] = min(merged0[i+j+1], dp0[v][i])
if dp0[v2][j] != INF:
merged1[i+j+1] = min(merged1[i+j+1], dp1[v][i])
if dp1[v2][j] < 0:
merged1[i+j+1] = min(merged1[i+j+1], dp1[v][i])
sizes[v] += sizes[v2]
dp0[v] = merged0
dp1[v] = merged1
dfs(0)
for i, (v0, v1) in enumerate(zip(dp0[0], dp1[0])):
if v0 != INF or v1 < 0:
print(i)
break
``` | output | 1 | 74,820 | 8 | 149,641 |
Provide a correct Python 3 solution for this coding contest problem.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3 | instruction | 0 | 74,821 | 8 | 149,642 |
"Correct Solution:
```
import sys
readline = sys.stdin.readline
inf = 10**18+3
def merge(d1a, d2a, d1b, d2b):
la = len(d1a)
lb = len(d1b)
k = la+lb
res1 = [inf]*k
res2 = [inf]*k
for i in range(la):
for j in range(lb):
res1[i+j] = min(res1[i+j], d1a[i]+d1b[j], d1a[i]+d2b[j], d2a[i]+d1b[j])
res2[i+j] = min(res2[i+j], d2a[i]+d2b[j])
for j in range(lb):
if d1b[j] < 0 or d2b[j] < inf:
for i in range(la):
res1[i+j+1] = min(res1[i+j+1], d1a[i])
res2[i+j+1] = min(res2[i+j+1], d2a[i])
return res1, res2
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
A = list(map(int, readline().split()))
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
P, L = parorder(Edge, 0)
#C = getcld(P)
dp1 = [[A[i] if A[i] < 0 else inf] for i in range(N)]
dp2 = [[A[i] if A[i] > 0 else inf] for i in range(N)]
for l in L[:0:-1]:
p = P[l]
dp1[p], dp2[p] = merge(dp1[p], dp2[p], dp1[l], dp2[l])
ans = N-1
for i in range(N):
if dp1[0][i] < 0 or dp2[0][i] < inf:
ans = i
break
print(ans)
``` | output | 1 | 74,821 | 8 | 149,643 |
Provide a correct Python 3 solution for this coding contest problem.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3 | instruction | 0 | 74,822 | 8 | 149,644 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(5005)
SENTINEL = 10 ** 13
n = int(input())
aaa = list(map(int, input().split()))
links = [set() for _ in [0] * n]
for line in sys.stdin.readlines():
u, v = map(int, line.split())
u -= 1
v -= 1
links[u].add(v)
links[v].add(u)
def dfs(v, p):
a = aaa[v]
ret1 = [a]
ret2 = [a]
if a < 0:
ret1[0] = SENTINEL
for u in links[v]:
if u == p:
continue
res1, res2 = dfs(u, v)
new1 = [SENTINEL] * (len(ret1) + len(res1))
new2 = [SENTINEL] * (len(ret2) + len(res2))
for i, t in enumerate(ret1):
for j, s in enumerate(res1):
new1[i + j] = min(new1[i + j], t + s)
if s < SENTINEL:
new1[i + j + 1] = min(new1[i + j + 1], t)
for j, s in enumerate(res2):
new2[i + j] = min(new2[i + j], t + s)
if s < 0:
new1[i + j + 1] = min(new1[i + j + 1], t)
for i, t in enumerate(ret2):
for j, s in enumerate(res1):
new2[i + j] = min(new2[i + j], t + s)
if s < SENTINEL:
new2[i + j + 1] = min(new2[i + j + 1], t)
for j, s in enumerate(res2):
new2[i + j] = min(new2[i + j], t + s)
if s < 0:
new2[i + j + 1] = min(new2[i + j + 1], t)
# print(' ', '1', p, v, u, ret1, res1, new1)
# print(' ', '2', p, v, u, ret2, res2, new2)
ret1, ret2 = new1, new2
return ret1, ret2
res1, res2 = dfs(0, -1)
ans1, ans2 = 0, 0
for ans1, s in enumerate(res1):
if s < SENTINEL:
break
for ans2, s in enumerate(res2):
if s < 0:
break
print(min(ans1, ans2))
``` | output | 1 | 74,822 | 8 | 149,645 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
cnt=0
for i in range(n-1):
a,b=map(int,input().split())
if (l[a-1]<0 or l[b-1]<0) and l[a-1]+l[b-1]>=0:
cnt+=1
print(cnt)
``` | instruction | 0 | 74,823 | 8 | 149,646 |
No | output | 1 | 74,823 | 8 | 149,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3
Submitted Solution:
```
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def dfs(u=0,pu=-1):
if aa[u]<0:dp[u][0][0]=aa[u]
else:dp[u][1][0]=aa[u]
for v in to[u]:
if v==pu:continue
dfs(v,u)
size[u]+=size[v]
ndp0=[inf]*n
ndp1=[inf]*n
for k in range(size[u]):
pre=dp[u][0][k]
if pre==inf:continue
for kv in range(size[v]):
s=dp[v][0][kv]
if s!=inf:ndp0[k+kv+1]=min(ndp0[k+kv+1],pre+s)
if s<0:ndp0[k+kv]=min(ndp0[k+kv],pre)
s = dp[v][1][kv]
if s != inf: ndp0[k + kv+1] = min(ndp0[k + kv+1], pre + s)
if s != inf: ndp0[k + kv] = min(ndp0[k + kv], pre)
for k in range(size[u]):
pre=dp[u][1][k]
if pre==inf:continue
for kv in range(size[v]):
s=dp[v][0][kv]
if s!=inf:ndp0[k+kv+1]=min(ndp0[k+kv+1],pre+s)
if s<0:ndp1[k+kv]=min(ndp1[k+kv],pre)
s = dp[v][1][kv]
if s != inf: ndp1[k + kv+1] = min(ndp1[k + kv+1], pre + s)
if s != inf: ndp1[k + kv] = min(ndp1[k + kv], pre)
dp[u][0]=ndp0
dp[u][1]=ndp1
inf=10**16
n=II()
aa=LI()
to=[[] for _ in range(n)]
for _ in range(n-1):
u,v=MI1()
to[u].append(v)
to[v].append(u)
dp=[[[inf]*n for _ in range(2)] for _ in range(n)]
size=[1]*n
dfs()
mx=0
for k in range(n-1,-1,-1):
if dp[0][0][k]<0:
mx=max(mx,k)
break
for k in range(n-1,-1,-1):
if dp[0][1][k]!=inf:
mx=max(mx,k)
break
print(n-1-mx)
``` | instruction | 0 | 74,824 | 8 | 149,648 |
No | output | 1 | 74,824 | 8 | 149,649 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**5)
def input():
return sys.stdin.buffer.readline()[:-1]
INF = 10**14
n = int(input())
a = list(map(int, input().split()))
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(int, input().split())
adj[u-1].append(v-1)
adj[v-1].append(u-1)
dp = [[[INF for _ in range(2)] for _ in range(n)] for _ in range(n)]
edges = [0 for _ in range(n)]
def dfs_pre(x, p):
if x != 0 and len(adj[x]) == 1:
return 0
for v in adj[x]:
if v == p:
continue
else:
edges[x] += dfs_pre(v, x) + 1
return edges[x]
dfs_pre(0, -1)
def dfs(x, p):
for v in adj[x]:
if v != p:
dfs(v, x)
sub = [[[INF for _ in range(2)] for _ in range(n)] for _ in range(n)]
sub[0][0][1] = a[x]
if a[x] > 0:
sub[0][0][0] = a[x]
i = 0
e_cnt = 0
for v in adj[x]:
if v == p:
continue
for j1 in range(e_cnt+1):
for j2 in range(edges[v]+1):
sub[i+1][j1+j2][1] = min(sub[i+1][j1+j2][1], sub[i][j1][0] + dp[v][j2][1], sub[i][j1][1] + dp[v][j2][1], sub[i][j1][1] + dp[v][j2][0])
if a[x] > 0:
sub[i+1][j1+j2][0] = min(sub[i+1][j1+j2][0], sub[i][j1][0] + dp[v][j2][0])
if dp[v][j2][0] < INF//2 or dp[v][j2][1] < 0:
sub[i+1][j1+j2+1][1] = min(sub[i+1][j1+j2+1][1], sub[i][j1][1])
if a[x] > 0:
sub[i+1][j1+j2+1][0] = min(sub[i+1][j1+j2+1][0], sub[i][j1][0])
e_cnt += edges[v] + 1
i += 1
for j in range(edges[x]+1):
dp[x][j][0] = sub[i][j][0]
dp[x][j][1] = sub[i][j][1]
return
dfs(0, -1)
for j in range(n):
if dp[0][j][0] < INF//2 or dp[0][j][1] < 0:
ans = j
break
print(ans)
``` | instruction | 0 | 74,825 | 8 | 149,650 |
No | output | 1 | 74,825 | 8 | 149,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The server in company A has a structure where N devices numbered 1, 2, ..., N are connected with N - 1 cables. The i-th cable connects Device U_i and Device V_i. Any two different devices are connected through some number of cables.
Each device v (1 \leq v \leq N) has a non-zero integer A_v, which represents the following:
* If A_v < 0, Device v is a computer that consumes an electric power of -A_v.
* If A_v > 0, Device v is a battery that supplies an electric power of A_v.
You have decided to disconnect some number of cables (possibly zero) to disable the server. When some cables are disconnected, the devices will be divided into some number of connected components. The server will be disabled if all of these connected components satisfy one of the following conditions:
* There is no computer in the connected component. That is, A_v is positive for every device v that belongs to the connected component.
* There is not enough supply of electric power in the connected component. That is, the sum of A_v over all devices v that belong to the connected component is negative.
At least how many cables do you need to disconnect in order to disable the server?
Constraints
* 1 \leq N \leq 5 000
* 1 \leq |A_i| \leq 10^9 (1 \leq i \leq N)
* 1 \leq U_i, V_i \leq N (1 \leq i \leq N - 1)
* U_i \neq V_i (1 \leq i \leq N - 1)
* Any two different devices are connected through some number of cables.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
U_1 V_1
U_2 V_2
:
U_{N - 1} V_{N - 1}
Output
Print the answer.
Examples
Input
7
-2 7 5 6 -8 3 4
1 2
2 3
2 4
1 5
5 6
5 7
Output
1
Input
4
1 2 3 4
1 2
1 3
1 4
Output
0
Input
6
10 -1 10 -1 10 -1
1 2
2 3
3 4
4 5
5 6
Output
5
Input
8
-2 3 6 -2 -2 -5 3 2
3 4
7 6
6 2
8 2
5 3
1 8
3 7
Output
3
Input
10
3 4 9 6 1 5 -1 10 -10 -10
7 4
5 6
8 1
9 5
7 1
10 3
2 8
4 10
9 2
Output
3
Submitted Solution:
```
import sys
import copy
sys.setrecursionlimit(1000000)
def dfs(used,tree,node, capacity_and_cut_num):
if used[node]!=0:
return
if energy[node]>0:
capacity_and_cut_num[0]+=energy[node]
else:
capacity_and_cut_num[1]+=1
return
used[node]=1
for x in tree[node]:
dfs(used,tree,x, capacity_and_cut_num)
N=int(input())
energy=list(map(int,input().split()))
battery=[]
for i,x in enumerate(energy):
if x>0:
battery.append(i)
cable=[[] for _ in range(N)]
used=[0 for _ in range(N)]
for i in range(N-1):
U,V=list(map(int,input().split()))
cable[U-1].append(V-1)
cable[V-1].append(U-1)
new_battery=[]
for b in battery:
capacity_and_cut_num=[0,0]
dfs(used, cable, b, capacity_and_cut_num)
if capacity_and_cut_num[0] == 0:
continue
new_battery.append(capacity_and_cut_num)
new_battery=sorted(new_battery,key=lambda x:x[1])
sum_energy=sum(energy)
ans=0
dp=[[0,copy.deepcopy(new_battery)] for _ in range(N)]
for i in range(1,N):
for j in range(0,i):
for k,b in enumerate(dp[j][1]):
if b[1]==i-j and dp[j][0]+b[0]>dp[i][0]:
dp[i][0]=dp[j][0]+b[0]
dp[i][1]=dp[j][1][:k]+dp[j][1][k+1:]
if dp[i][0]>sum_energy:
ans=i
break
print(ans)
``` | instruction | 0 | 74,826 | 8 | 149,652 |
No | output | 1 | 74,826 | 8 | 149,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,031 | 8 | 150,062 |
Tags: implementation, sortings
Correct Solution:
```
def db(*arg):
print(*arg)
from collections import Counter, defaultdict
H,W = map(int,input().split())
grid = [list(map(int, input().split())) for i in range(H)]
rank_in_row = [[0] * W for _ in range(H)]
rank_in_columns = [[0] * W for _ in range(H)]
row_maxrank = [0] * H
column_maxrank = [0] * W
for r in range(H):
set_ = set()
for c in range(W):
set_.add(grid[r][c])
# db("set_", set_)
ls = sorted(list(set_))
# db("ls", ls)
now_rank = 1
v_rank = {}
for v in ls:
v_rank[v] = now_rank
now_rank += 1
for c in range(W):
rank_in_row[r][c] = v_rank[grid[r][c]]
# db("r", r)
# db("sorted_c", sorted_c)
row_maxrank[r] = v_rank[ls[-1]]
# db("rank_in_row", rank_in_row)
# db("row_maxrank", row_maxrank)
for c in range(W):
# counter作る
set_ = set()
for r in range(H):
set_.add(grid[r][c])
ls = sorted(list(set_))
now_rank = 1
v_rank = {}
for v in ls:
v_rank[v] = now_rank
now_rank += 1
for r in range(H):
rank_in_columns[r][c] = v_rank[grid[r][c]]
# db("c", c)
# db("sorted_c", sorted_c)
column_maxrank[c] = v_rank[ls[-1]]
# db("rank_in_columns", rank_in_columns)
# db("column_maxrank", column_maxrank)
ans_mat = [[0] * W for _ in range(H)]
for r in range(H):
for c in range(W):
v_center = max(rank_in_row[r][c], rank_in_columns[r][c])
diff_max = max(row_maxrank[r] - rank_in_row[r][c], column_maxrank[c] - rank_in_columns[r][c])
ans_mat[r][c] = v_center + diff_max
for r in range(H):
print(*ans_mat[r])
``` | output | 1 | 75,031 | 8 | 150,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,032 | 8 | 150,064 |
Tags: implementation, sortings
Correct Solution:
```
import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
n, m = map(int, input().split())
A = [list(map(int, input().split())) for i in range(n)]
H = [[] for i in range(n)]
V = [[] for i in range(m)]
for i in range(n):
for j in range(m):
H[i].append(A[i][j])
V[j].append(A[i][j])
H = [sorted(set(h)) for h in H]
V = [sorted(set(v)) for v in V]
#print(H)
#print(V)
ans = [[-1]*m for i in range(n)]
import bisect
for i in range(n):
for j in range(m):
yh = bisect.bisect_right(H[i], A[i][j])
yv = bisect.bisect_right(V[j], A[i][j])
x = max(yh, yv)+max(len(H[i])-yh, len(V[j])-yv)
ans[i][j] = x
for i in range(n):
print(*ans[i])
if __name__ == '__main__':
main()
``` | output | 1 | 75,032 | 8 | 150,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,033 | 8 | 150,066 |
Tags: implementation, sortings
Correct Solution:
```
from math import *
import math
n, m = map(int ,input().split())
g = []
for i in range(n):
g.append([int(i) for i in input().split()])
g2 = [[0] * m for i in range(n)]
for i in range(n):
a = g[i][:]
d = {}
for x in a:
d[x] = []
for j in range(len(a)):
d[a[j]].append(j)
a.sort()
j = 0
ind = 1
while j < m:
x = a[j]
for k in d[x]:
g2[i][k] = ind
j += 1
ind += 1
g2[i].append(ind - 1)
g3 = [[0] * m for i in range(n + 1)]
for i in range(m):
a = [0] * n
for j in range(n):
a[j] = g[j][i]
d = {}
for x in a:
d[x] = []
for j in range(len(a)):
d[a[j]].append(j)
a.sort()
j = 0
ind = 1
while j < n:
x = a[j]
for k in d[x]:
g3[k][i] = ind
j += 1
ind += 1
g3[n][i] = ind - 1
for i in range(n):
res = [0] * m
for j in range(m):
ans = max(g2[i][j], g3[i][j]) + max(g2[i][m] - g2[i][j], g3[n][j] - g3[i][j])
res[j] = ans
print(*res)
``` | output | 1 | 75,033 | 8 | 150,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,034 | 8 | 150,068 |
Tags: implementation, sortings
Correct Solution:
```
def main():
n, m = (int(x) for x in input().split(" "))
a = []
for _ in range(n):
a.append([int(x) for x in input().strip().split(" ")])
answer = []
for _ in range(n):
answer.append([None for x in range(m)])
rows = []
for i in range(n):
rows.append(sorted(set(a[i])))
cols = []
for j in range(m):
cols.append(sorted(set(a[x][j] for x in range(n))))
for i in range(n):
for j in range(m):
row = rows[i]
col = cols[j]
pivot = a[i][j]
pivot_r_pos = row.index(pivot)
pivot_c_pos = col.index(pivot)
pivot_val = max(pivot_r_pos, pivot_c_pos) + 1
answer[i][j] = max(
pivot_val - pivot_r_pos + len(row),
pivot_val - pivot_c_pos + len(col)
) - 1
print("\n".join(" ".join(str(x) for x in row) for row in answer))
main()
``` | output | 1 | 75,034 | 8 | 150,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,035 | 8 | 150,070 |
Tags: implementation, sortings
Correct Solution:
```
n,m=map(int, input().split())
a = []
dl= []
for i in range(n):
a.append(list(map(int, input().split())))
aso = sorted(a[-1])
c = 1
dl.append({})
for j in aso:
if j not in dl[-1]:
dl[-1][j] = c
c+=1
dr = []
for i in range(m):
dr.append({})
c= 1
ar = sorted([a[j][i] for j in range(n)])
for j in ar:
if j not in dr[-1]:
dr[-1][j] = c
c += 1
for i in range(n):
ans = []
for j in range(m):
e = a[i][j]
rng = max(dl[i][e], dr[j][e])
x = max(rng + len(dl[i])- dl[i][e], rng + len(dr[j])- dr[j][e])
ans.append(x)
print(' '.join([str(v) for v in ans]))
``` | output | 1 | 75,035 | 8 | 150,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,036 | 8 | 150,072 |
Tags: implementation, sortings
Correct Solution:
```
def inpl(): return list(map(int, input().split()))
n, m = inpl()
St = [inpl() for _ in range(n)]
ppr = [sorted(list(set(s))) for s in St]
PR = []
for i in range(n):
H = dict()
for j, v in enumerate(ppr[i], 1):
H[v] = j
PR.append([H[p] for p in St[i]] + [j])
TSt = list(map(list, zip(*St)))
ppc = [sorted(list(set(s))) for s in TSt]
PC = []
for i in range(m):
H = dict()
for j, v in enumerate(ppc[i], 1):
H[v] = j
PC.append([H[p] for p in TSt[i]] + [j])
for i in range(n):
pri = PR[i]
prm = PR[i][-1]
print(*[max(pri[j], PC[j][i]) + max(prm - pri[j], PC[j][-1] - PC[j][i]) for j in range(m)])
``` | output | 1 | 75,036 | 8 | 150,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,037 | 8 | 150,074 |
Tags: implementation, sortings
Correct Solution:
```
from bisect import bisect_left as lb
n,m=map(int,input().split())
a=[list(map(int,input().split())) for _ in range(n)]
p=[sorted(list(set(a[i]))) for i in range(n)]
b=[list(a[i][j] for i in range(n)) for j in range(m)]
q=[sorted(list(set(b[i]))) for i in range(m)]
ans=[[0]*m for i in range(n)]
for i in range(n):
for j in range(m):
x=lb(p[i],a[i][j])
y=lb(q[j],a[i][j])
ans[i][j]=max(x,y)+max(len(p[i])-x,len(q[j])-y)
for i in range(n):
print(*ans[i])
``` | output | 1 | 75,037 | 8 | 150,075 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | instruction | 0 | 75,038 | 8 | 150,076 |
Tags: implementation, sortings
Correct Solution:
```
import sys, os, io
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math,datetime,functools,itertools,operator,bisect,fractions,statistics
from collections import deque,defaultdict,OrderedDict,Counter
from fractions import Fraction
from decimal import Decimal
from sys import stdout
from heapq import heappush, heappop, heapify ,_heapify_max,_heappop_max,nsmallest,nlargest
def main():
# mod=1000000007
# InverseofNumber(mod)
# InverseofFactorial(mod)
# factorial(mod)
starttime=datetime.datetime.now()
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
tc=1
for _ in range(tc):
n,m=ria()
a=[]
ans=[]
for i in range(n):
a.append(ria())
ans.append([0]*m)
r=[]
c=[]
for i in range(n):
d={}
t=[]
for j in a[i]:
if j not in d:
t.append(j)
d[j]=1
r.append(sorted(t))
for i in range(m):
d={}
t=[]
for j in range(n):
if a[j][i] not in d:
t.append(a[j][i])
d[a[j][i]]=1
c.append(sorted(t))
for i in range(n):
for j in range(m):
lrow=bisect.bisect_left(r[i],a[i][j])
grow=len(r[i])-lrow-1
lcol=bisect.bisect_left(c[j],a[i][j])
gcol=len(c[j])-lcol-1
ans[i][j]=max(lrow,lcol)+1+max(gcol,grow)
for i in ans:
print(*i)
#<--Solving Area Ends
endtime=datetime.datetime.now()
time=(endtime-starttime).total_seconds()*1000
if(os.path.exists('input.txt')):
print("Time:",time,"ms")
class FastReader(io.IOBase):
newlines = 0
def __init__(self, fd, chunk_size=1024 * 8):
self._fd = fd
self._chunk_size = chunk_size
self.buffer = io.BytesIO()
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size))
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, size=-1):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, self._chunk_size if size == -1 else size))
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()
class FastWriter(io.IOBase):
def __init__(self, fd):
self._fd = fd
self.buffer = io.BytesIO()
self.write = self.buffer.write
def flush(self):
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class FastStdin(io.IOBase):
def __init__(self, fd=0):
self.buffer = FastReader(fd)
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
class FastStdout(io.IOBase):
def __init__(self, fd=1):
self.buffer = FastWriter(fd)
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.flush = self.buffer.flush
if __name__ == '__main__':
sys.stdin = FastStdin()
sys.stdout = FastStdout()
main()
``` | output | 1 | 75,038 | 8 | 150,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
from bisect import bisect_left
import sys
input = sys.stdin.buffer.readline
n, m = map(int, input().split())
a = [list(map(int, input().split())) for i in range(n)]
yoko_less = [[0] * m for i in range(n)]
yoko_more = [[0] * m for i in range(n)]
for i in range(n):
yoko = sorted(set(a[i]))
for j in range(m):
idx = bisect_left(yoko, a[i][j])
yoko_less[i][j] = idx
yoko_more[i][j] = len(yoko) - idx - 1
tate_less = [[0] * m for i in range(n)]
tate_more = [[0] * m for i in range(n)]
for j in range(m):
tate = sorted(set([a[i][j] for i in range(n)]))
for i in range(n):
idx = bisect_left(tate, a[i][j])
tate_less[i][j] = idx
tate_more[i][j] = len(tate) - idx - 1
ans = [[0] * m for i in range(n)]
for i in range(n):
for j in range(m):
less = max(yoko_less[i][j], tate_less[i][j])
more = max(yoko_more[i][j], tate_more[i][j])
ans[i][j] = 1 + more + less
for res in ans:
print(*res)
``` | instruction | 0 | 75,039 | 8 | 150,078 |
Yes | output | 1 | 75,039 | 8 | 150,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
import heapq
import sys
from collections import defaultdict, Counter
from functools import reduce
n, m = list(map(int, input().split()))
arr = []
for _ in range(n):
arr.append(list(map(int, input().split())))
rows = []
for i in range(n):
row = set()
for j in range(m):
row.add(arr[i][j])
rows.append({x: i for i, x in enumerate(sorted(row))})
columns = []
for j in range(m):
column = set()
for i in range(n):
column.add(arr[i][j])
columns.append({x: i for i, x in enumerate(sorted(column))})
def get_answer(i, j):
el = arr[i][j]
index1 = rows[i][el]
index2 = columns[j][el]
return max(index1, index2) + max(len(rows[i]) - index1, len(columns[j]) - index2)
for i in range(n):
answer = []
for j in range(m):
answer.append(str(get_answer(i, j)))
print(' '.join(answer))
``` | instruction | 0 | 75,040 | 8 | 150,080 |
Yes | output | 1 | 75,040 | 8 | 150,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
nr, nc = rint()
#r[r][c]
r = []
rs = []
for i in range(nr):
tmp = list(rint())
r.append(tmp)
tmp = sorted(list(set(tmp)))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
rs.append(tmp_dict)
#c[c][r]
c = [[0 for i in range(nr)] for j in range(nc)]
for cc in range(nc):
for rr in range(nr):
c[cc][rr] = r[rr][cc]
cs= []
for i in range(nc):
tmp = sorted(list(set(c[i])))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
cs.append(tmp_dict)
ans = [[0 for i in range(nc)] for j in range(nr)]
for ri in range(nr):
for ci in range(nc):
v = r[ri][ci]
rs_max = rs[ri][v]
cs_max = cs[ci][v]
max_orc = max(rs_max, cs_max)
l_rs = len(rs[ri])
l_cs = len(cs[ci])
ans[ri][ci] = max(max_orc + l_rs - rs_max, max_orc + l_cs - cs_max)
if nr==1001:
nr = nr//2
print("")
exit()
ans_str = []
for i in range(nr):
#print(*ans[i])
#print(" ".join(map(str, ans[i])))
ans_str.append(" ".join(map(str, ans[i])))
# sys.stdout.write(" ".join(map(str, ans[i])))
# print("")
# sys.stdout.write(" ".join(map(str, ans[i])))
# print("")
print("\n".join(ans_str))
``` | instruction | 0 | 75,041 | 8 | 150,082 |
Yes | output | 1 | 75,041 | 8 | 150,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
nr, nc = rint()
#r[r][c]
r = []
rs = []
for i in range(nr):
tmp = list(rint())
r.append(tmp)
tmp = sorted(list(set(tmp)))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
rs.append(tmp_dict)
#c[c][r]
c = [[0 for i in range(nr)] for j in range(nc)]
for cc in range(nc):
for rr in range(nr):
c[cc][rr] = r[rr][cc]
cs= []
for i in range(nc):
tmp = sorted(list(set(c[i])))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
cs.append(tmp_dict)
ans = [[0 for i in range(nc)] for j in range(nr)]
for ri in range(nr):
for ci in range(nc):
v = r[ri][ci]
rs_max = rs[ri][v]
cs_max = cs[ci][v]
max_orc = max(rs_max, cs_max)
l_rs = len(rs[ri])
l_cs = len(cs[ci])
ans[ri][ci] = max(max_orc + l_rs - rs_max, max_orc + l_cs - cs_max)
if nr==1001:
nr = nr//2
for i in range(nr):
#print(*ans[i])
sys.stdout.write(" ".join(map(str, ans[i])))
print("")
``` | instruction | 0 | 75,042 | 8 | 150,084 |
Yes | output | 1 | 75,042 | 8 | 150,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
n,m_ = map(int,input().split())
a =[[int(j) for j in input().split()] for i in range(n)]
def column(matrix, i):
return [row[i] for row in matrix]
for i in range(n):
cur_res = []
for j in range(m_):
M,m = (column(a,j),a[i])
X = len({elem for elem in M if elem<a[i][j]})
x = len({elem for elem in m if elem<a[i][j]})
H = len({*M})
h = len({*m})
if x<X:
H+=X-x
else:
h += x-X
cur_res.append(max(H,h))
print(*cur_res)
``` | instruction | 0 | 75,043 | 8 | 150,086 |
No | output | 1 | 75,043 | 8 | 150,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
return map(int, input().split())
#lines = stdin.readlines()
nr, nc = rint()
#r[r][c]
r = []
rs = []
for i in range(nr):
tmp = list(rint())
r.append(tmp)
tmp = sorted(list(set(tmp)))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
rs.append(tmp_dict)
#c[c][r]
c = [[0 for i in range(nr)] for j in range(nc)]
for cc in range(nc):
for rr in range(nr):
c[cc][rr] = r[rr][cc]
cs= []
for i in range(nc):
tmp = sorted(list(set(c[i])))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
cs.append(tmp_dict)
ans = [[0 for i in range(nc)] for j in range(nr)]
for ri in range(nr):
for ci in range(nc):
v = r[ri][ci]
max_orc = max(rs[ri][v], cs[ci][v])
ans[ri][ci] = max(max_orc + len(rs[ri]) - rs[ri][v], max_orc + len(cs[ci]) - cs[ci][v])
if nr==1000:
nr = nr//2
for i in range(nr):
print(*ans[i])
``` | instruction | 0 | 75,044 | 8 | 150,088 |
No | output | 1 | 75,044 | 8 | 150,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
#!/usr/bin/env python3
import sys
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
nr, nc = rint()
#r[r][c]
r = []
rs = []
for i in range(nr):
tmp = list(rint())
r.append(tmp)
tmp = sorted(list(set(tmp)))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
rs.append(tmp_dict)
#c[c][r]
c = [[0 for i in range(nr)] for j in range(nc)]
for cc in range(nc):
for rr in range(nr):
c[cc][rr] = r[rr][cc]
cs= []
for i in range(nc):
tmp = sorted(list(set(c[i])))
tmp_dict = dict()
for j, d in enumerate(tmp):
tmp_dict[d] = j
cs.append(tmp_dict)
ans = [[0 for i in range(nc)] for j in range(nr)]
for ri in range(nr):
for ci in range(nc):
v = r[ri][ci]
rs_max = rs[ri][v]
cs_max = cs[ci][v]
max_orc = max(rs_max, cs_max)
l_rs = len(rs[ri])
l_cs = len(cs[ci])
ans[ri][ci] = max(max_orc + l_rs - rs_max, max_orc + l_cs - cs_max)
if nr==1000:
nr = nr//2
for i in range(nr):
#print(*ans[i])
sys.stdout.write(" ".join(map(str, ans[i])))
print("")
``` | instruction | 0 | 75,045 | 8 | 150,090 |
No | output | 1 | 75,045 | 8 | 150,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image>
Submitted Solution:
```
def retValue(arr,i,j):
row = arr[i]
col = []
for idx in range(len(arr)):
col.append(arr[idx][j])
rLen = len(set(row))
cLen = len(set(col))
return max(rLen,cLen)
n,m = list(map(int,input().split()))
arr = []
for i in range(n):
arr.append(list(map(int,input().split())))
for i in range(n):
for j in range(m):
print(retValue(arr,i,j),end=" ")
print("")
``` | instruction | 0 | 75,046 | 8 | 150,092 |
No | output | 1 | 75,046 | 8 | 150,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,062 | 8 | 150,124 |
Tags: greedy, math, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
A=[int(i) for i in input().split()]
A.sort(reverse=True)
if(len(A)>=2):
k=A[1]-1
if(k<=n-2):
print(k)
else:
print(n-2)
``` | output | 1 | 75,062 | 8 | 150,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,063 | 8 | 150,126 |
Tags: greedy, math, sortings
Correct Solution:
```
q = int(input())
for qq in range(q):
n = int(input())
dat = list(map(int, input().split()))
dat.sort()
a, b = dat[-2], dat[-1]
a ,b = a-1, b-1
dat = dat[:-2]
l = len(dat)
#print("{0} {1}".format(a,b))
#print(dat)
print(min(a,b,l))
``` | output | 1 | 75,063 | 8 | 150,127 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,064 | 8 | 150,128 |
Tags: greedy, math, sortings
Correct Solution:
```
t = int(input())
while t > 0:
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
k = min(a[-1], a[-2]) - 1
if len(a) - 2 >= k:
print(k)
else:
print(len(a) - 2)
t -= 1
``` | output | 1 | 75,064 | 8 | 150,129 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,065 | 8 | 150,130 |
Tags: greedy, math, sortings
Correct Solution:
```
def solve():
n = int(input())
a = sorted(list(map(int, input().split())))
ans = min(a[-2] - 1, n - 2)
print(ans)
t = int(input())
for _ in range(t):
solve()
``` | output | 1 | 75,065 | 8 | 150,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,066 | 8 | 150,132 |
Tags: greedy, math, sortings
Correct Solution:
```
q = int(input())
for i in range(q):
n = int(input())
a = list(map(int, input().split()))
a.sort()
if n == 2:
print(0)
else:
print(min(a[-2] - 1, n - 2))
``` | output | 1 | 75,066 | 8 | 150,133 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,067 | 8 | 150,134 |
Tags: greedy, math, sortings
Correct Solution:
```
T = int(input())
for _ in range(T):
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)
if len(a) <= 1:
print(0)
else:
k = a[1]-1
print(min(n-2, k))
``` | output | 1 | 75,067 | 8 | 150,135 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,068 | 8 | 150,136 |
Tags: greedy, math, sortings
Correct Solution:
```
for TT in range(1, int(input()) + 1):
n = int(input())
l = sorted(map(int, input().split()))
k = max(0, min(n - 2, l[-2] - 1))
print(k)
``` | output | 1 | 75,068 | 8 | 150,137 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which
* two planks of length at least k+1 — the base of the ladder;
* k planks of length at least 1 — the steps of the ladder;
Note that neither the base planks, nor the steps planks are required to be equal.
For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps.
<image>
You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.
The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?
Input
The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.
Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.
It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.
Output
Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.
Print 0 if you can't make even 1-step ladder from the given set of planks.
Example
Input
4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2
Output
2
1
2
0
Note
Examples for the queries 1-3 are shown at the image in the legend section.
The Russian meme to express the quality of the ladders:
<image> | instruction | 0 | 75,069 | 8 | 150,138 |
Tags: greedy, math, sortings
Correct Solution:
```
q = int(input())
for n in range(q):
N = int(input())
e = input().split(" ")
for i in range(N):
e[i] = int(e[i])
e.sort()
napr2 = e[N - 1]
napr1 = e[N - 2]
if napr2 > 1:
print(min(N - 2, napr1 - 1))
else:
print(0)
``` | output | 1 | 75,069 | 8 | 150,139 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.