message stringlengths 2 49.9k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 446 108k | cluster float64 13 13 | __index_level_0__ int64 892 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Depth-first search (DFS) follows the strategy to search ”deeper” in the graph whenever possible. In DFS, edges are recursively explored out of the most recently discovered vertex $v$ that still has unexplored edges leaving it. When all of $v$'s edges have been explored, the search ”backtracks” to explore edges leaving the vertex from which $v$ was discovered.
This process continues until all the vertices that are reachable from the original source vertex have been discovered. If any undiscovered vertices remain, then one of them is selected as a new source and the search is repeated from that source.
DFS timestamps each vertex as follows:
* $d[v]$ records when $v$ is first discovered.
* $f[v]$ records when the search finishes examining $v$’s adjacency list.
Write a program which reads a directed graph $G = (V, E)$ and demonstrates DFS on the graph based on the following rules:
* $G$ is given in an adjacency-list. Vertices are identified by IDs $1, 2,... n$ respectively.
* IDs in the adjacency list are arranged in ascending order.
* The program should report the discover time and the finish time for each vertex.
* When there are several candidates to visit during DFS, the algorithm should select the vertex with the smallest ID.
* The timestamp starts with 1.
Constraints
* $1 \leq n \leq 100$
Input
In the first line, an integer $n$ denoting the number of vertices of $G$ is given. In the next $n$ lines, adjacency lists of $u$ are given in the following format:
$u$ $k$ $v_1$ $v_2$ ... $v_k$
$u$ is ID of the vertex and $k$ denotes its degree. $v_i$ are IDs of vertices adjacent to $u$.
Output
For each vertex, print $id$, $d$ and $f$ separated by a space character in a line. $id$ is ID of the vertex, $d$ and $f$ is the discover time and the finish time respectively. Print in order of vertex IDs.
Examples
Input
4
1 1 2
2 1 4
3 0
4 1 3
Output
1 1 8
2 2 7
3 4 5
4 3 6
Input
6
1 2 2 3
2 2 3 4
3 1 5
4 1 6
5 1 6
6 0
Output
1 1 12
2 2 11
3 3 8
4 9 10
5 4 7
6 5 6
Submitted Solution:
```
from collections import deque
def dfs(root):
time = 1
stack.append(root)
color[root] = 'gray'
arrive[root] = time
time += 1
while len(stack) > 0:
node = stack[-1]
for next in range(n):
if adjMat[node][next] == 1:
if color[next] == 'white':
color[next] = 'gray'
arrive[next] = time
time += 1
stack.append(next)
break
# In case there in no adjacent node whose color is white
color[node] = 'black'
finish[node] = time
time += 1
stack.pop()
n = int(input())
adjMat = [[0] * n for _ in range(n)]
color = ['white'] * n
stack = deque()
arrive = [0] * n
finish = [0] * n
for _ in range(n):
adj = list(map(int, input().split()))
i = adj[0]
v = adj[2:]
for j in v:
adjMat[i - 1][j - 1] = 1
dfs(0)
for i in range(n):
out = ''
out += '{} {} {}'.format(i+1, arrive[i], finish[i])
print(out)
``` | instruction | 0 | 80,796 | 13 | 161,592 |
No | output | 1 | 80,796 | 13 | 161,593 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,869 | 13 | 161,738 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
from itertools import permutations, combinations
raw_input = stdin.readline
pr = stdout.write
def in_num():
return int(raw_input())
def in_arr():
return map(int,raw_input().split())
def pr_num(n):
stdout.write(str(n)+'\n')
def pr_arr(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
# main code
n=input()
arr=[0]+in_arr()
p=[0,0]+in_arr()
ch=Counter()
for i in range(2,n+1):
ch[p[i]]+=1
ans=[[] for i in range(n+1)]
q=set()
c=0
for i in range(1,n+1):
if not ch[i]:
q.add(i)
c+=1
while q:
x=q.pop()
if x==1:
break
if not ans[x]:
ans[p[x]].append(1)
elif arr[x]==0:
ans[p[x]].append(sum(ans[x]))
elif arr[x]:
ans[p[x]].append(min(ans[x]))
ch[p[x]]-=1
if not ch[p[x]]:
q.add(p[x])
if arr[1]:
pr_num(c-min(ans[1])+1)
else:
pr_num(c-sum(ans[1])+1)
``` | output | 1 | 80,869 | 13 | 161,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,870 | 13 | 161,740 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
maxx = 10 ** 9
n = int(input())
a = [None] + list(map(int, input().split()))
p = [None, None] + list(map(int, input().split()))
g = [[] for i in range(n + 1)]
for i in range(n, 0, -1):
if g[i]:
c = 0
x, y = 0, maxx
for cv, wv in g[i]:
c += cv
x += cv - wv + 1
y = min(y, cv - wv)
w = c - y if a[i] else c - x + 1
else:
c = w = 1
if i == 1:
print(w)
else:
g[p[i]].append((c, w))
``` | output | 1 | 80,870 | 13 | 161,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,871 | 13 | 161,742 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
n=int(input())
OP=[0]+list(map(int,input().split()))
f=list(map(int,input().split()))
CHLIST=[[] for i in range(n+1)]
for i in range(n-1):
CHLIST[f[i]].append(i+2)
LEAFLIST=[]
for i in range(1,n+1):
if len(CHLIST[i])==0:
LEAFLIST.append(i)
LEAF=len(LEAFLIST)
HEIGHT=[0]*(n+1)
QUE=deque([1])
H=1
while QUE:
NQUE=deque()
while QUE:
x=QUE.pop()
HEIGHT[x]=H
for ch in CHLIST[x]:
NQUE.append(ch)
H+=1
QUE=NQUE
LIST=list(range(1,n+1))
LIST.sort(key=lambda x:HEIGHT[x],reverse=True)
NMINUS=[10]*(n+1)
def node_minus(n):
if NMINUS[n]!=10:
return NMINUS[n]
if len(CHLIST[n])==0:
return 0
if OP[n]==1:
ANS=-10**7
for ch in CHLIST[n]:
ANS=max(ANS,node_minus(ch))
NMINUS[n]=ANS
return ANS
else:
ANS=1
for ch in CHLIST[n]:
ANS-=1
ANS+=node_minus(ch)
NMINUS[n]=ANS
return ANS
for l in LIST:
node_minus(l)
print(LEAF+NMINUS[1])
``` | output | 1 | 80,871 | 13 | 161,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,872 | 13 | 161,744 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
n = int(input())
minmax = list(map(int, input().split()))
childs = [[] for i in range(n)]
for idx, father in enumerate(list(map(int,input().split()))):
childs[father-1].append(idx+1)
stack = []
stack.append(0)
ans = [None for ele in range(n)]
vis = [False for ele in range(n)]
while len(stack):
index = stack[-1]
if not vis[index]:
vis[index] = True
if len(childs[index]) == 0:
ans[index] = (0,1)
stack.pop()
else:
for child in childs[index]:
stack.append(child)
else:
stack.pop()
res = [ans[child] for child in childs[index]]
total = sum([ele[1] for ele in res])
if minmax[index] == 1:
ans[index] = min([ele[0] for ele in res]), total
else:
bigger_than = sum([ele[1] - ele[0] - 1 for ele in res])
ans[index] = total - bigger_than - 1, total
print(ans[0][1] - ans[0][0])
``` | output | 1 | 80,872 | 13 | 161,745 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,873 | 13 | 161,746 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
import math
import collections
from pprint import pprint as pp
mod = 998244353
MAX = 10**15
def inp():
return map(int, input().split())
def array():
return list(map(int, input().split()))
def vector(size, val=0):
vec = [val for i in range(size)]
return vec
def matrix(rowNum, colNum, val=0):
mat = []
for i in range(rowNum):
collumn = [val for j in range(colNum)]
mat.append(collumn)
return mat
n = int(input())
val = [0] + array()
par = [0, 0] + array()
dp = vector(n + 5)
leaf = 0
adj = matrix(n + 5, 0)
for i in range(2, n + 1):
adj[par[i]].append(i)
for i in range(n, 0, -1):
if(len(adj[i]) == 0):
dp[i] = 1
leaf += 1
elif val[i] == 1:
dp[i] = MAX
for x in adj[i]:
dp[i] = min(dp[i], dp[x])
else:
for x in adj[i]:
dp[i] += dp[x]
print(leaf + 1 - dp[1])
``` | output | 1 | 80,873 | 13 | 161,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,874 | 13 | 161,748 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
from collections import defaultdict
from collections import deque
# import sys
# sys.setrecursionlimit(400000)
n = int(input())
tree = defaultdict(set)
node_type = list(map(int,input().split()))
#leaf = [True for x in range(n)]
values = [0 for x in range(n)]
for i,x in enumerate(map(int,input().split())):
tree[x-1].add(i+1)
#leaf[x-1] = False
queue = deque([(0,False)])
while queue:
node, tag = queue.popleft()
if not node in tree:
values[node] = 1
continue
elif tag:
if node_type[node]:
values[node] = min(values[c] for c in tree[node])
else:
values[node] = sum(values[c] for c in tree[node])
else:
queue.appendleft((node,True))
queue.extendleft((c,False) for c in tree[node])
#print(values)
k = n-len(tree)
print (k-values[0]+1)
``` | output | 1 | 80,874 | 13 | 161,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,875 | 13 | 161,750 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
from collections import deque
N = int(input())
mima = [-1] + list(map(int, input().split()))
par = [-1, -1] + list(map(int, input().split()))
leaf = set(range(1, N+1))
cld = [0]*(N+1)
for p in par:
cld[p] += 1
if p in leaf:
leaf.remove(p)
dp = [0]*(N+1)
for i in leaf:
dp[i] = 1
Q = deque(list(leaf))
visited = leaf.copy()
while Q:
vn = Q.pop()
if vn == 1:
break
pv = par[vn]
if mima[pv] == 1:
if not dp[pv]:
dp[pv] = dp[vn]
else:
dp[pv] = min(dp[pv], dp[vn])
cld[pv] -= 1
if not cld[pv]:
Q.appendleft(pv)
else:
if not dp[pv]:
dp[pv] = dp[vn]
else:
dp[pv] += dp[vn]
cld[pv] -= 1
if not cld[pv]:
Q.appendleft(pv)
print(len(leaf) - dp[1] + 1)
``` | output | 1 | 80,875 | 13 | 161,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,876 | 13 | 161,752 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
R = lambda: map(int, input().split())
n = int(input())
fcs = [0] + list(R())
ps = [0, 0] + list(R())
cs = [1] * (n + 1)
for i in range(2, n + 1):
cs[ps[i]] = 0
nc = sum(cs) - 1
for i in range(n, 1, -1):
if fcs[ps[i]] == 0:
cs[ps[i]] += cs[i]
else:
if not cs[ps[i]]:
cs[ps[i]] = cs[i]
else:
cs[ps[i]] = min(cs[ps[i]], cs[i])
print(nc - cs[1] + 1)
``` | output | 1 | 80,876 | 13 | 161,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image> | instruction | 0 | 80,877 | 13 | 161,754 |
Tags: binary search, dfs and similar, dp, greedy, trees
Correct Solution:
```
n=int(input())
op=[int(g) for g in input().split()]
parent=[int(g)-1 for g in input().split()]
tree=[[] for i in range(n)]
for i in range(n-1):
tree[parent[i]].append(i+1)
l=sum([1 for i in range(n) if len(tree[i])==0])
l1=[-1]*n
for i in range(n-1,-1,-1):
if len(tree[i])==0:
l1[i]=1
else:
x=[l1[j] for j in tree[i]]
if op[i]==1:
l1[i]=min(x)
else:
l1[i]=sum(x)
print(l-l1[0]+1)
``` | output | 1 | 80,877 | 13 | 161,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
oper = list(map(int, input().split())) # 0 - min, 1 - max
prev = [int(i) - 1 for i in input().split()]
graph = [[] for i in range(n)]
for i in range(n - 1):
graph[prev[i]].append(i + 1)
leafs = sum([len(graph[i]) == 0 for i in range(n)])
res = [0] * n
for u in range(n - 1, -1, -1):
if len(graph[u]) == 0:
res[u] = 1
else:
sons = [res[v] for v in graph[u]]
res[u] = (min(sons) if oper[u] == 1 else sum(sons))
print(leafs - res[0] + 1)
``` | instruction | 0 | 80,878 | 13 | 161,756 |
Yes | output | 1 | 80,878 | 13 | 161,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
INF = 10 ** 9
n = int(input())
a = [None] + list(map(int, input().split()))
p = [None, None] + list(map(int, input().split()))
g = [[] for i in range(n + 1)]
for i in range(n, 0, -1):
if g[i]:
c = 0
x, y = 0, INF
for cv, wv in g[i]:
c += cv
x += cv - wv + 1
y = min(y, cv - wv)
w = c - y if a[i] else c - x + 1
else:
c = w = 1
if i == 1:
print(w)
else:
g[p[i]].append((c, w))
``` | instruction | 0 | 80,879 | 13 | 161,758 |
Yes | output | 1 | 80,879 | 13 | 161,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
a = [None] + list(map(int, input().split()))
p = [None, None] + list(map(int, input().split()))
g = [[] for i in range(n + 1)]
for i in range(n, 0, -1):
if g[i]:
c = 0
x, y = 0, 10 ** 9
for cv, wv in g[i]:
c += cv
x += wv
y = min(y, wv)
w = y if a[i] else x
else:
c, w = 1, 1
if i == 1:
print(c - w + 1)
else:
g[p[i]].append((c, w))
``` | instruction | 0 | 80,880 | 13 | 161,760 |
Yes | output | 1 | 80,880 | 13 | 161,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
N = int(input())
a = list(map(int, input().split()))
f = list(map(int, input().split()))
G = [[] for i in range(N)]
INF = float('inf')
for i in range(1, N):
G[f[i - 1] - 1].append(i)
d = [0] * N
k = 0
for i in range(N - 1, -1, -1):
if len(G[i]) == 0:
d[i] = 1
k += 1
continue
if a[i] == 0:
d[i] = 0
for j in G[i]:
d[i] += d[j]
else:
d[i] = INF
for j in G[i]:
d[i] = min(d[i], d[j])
print(k - d[0] + 1)
``` | instruction | 0 | 80,881 | 13 | 161,762 |
Yes | output | 1 | 80,881 | 13 | 161,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
WEW = list(map(int, input().split()))
graph = {i: set() for i in range(1, n + 1)}
times = {i: [] for i in range(1, n + 1)}
for i in range(n - 1):
graph[WEW[i]].add(i + 2)
keks = n + 1
potomks = {}
def potomks_lists(v):
if graph[v] == set():
return 1
cnt = 0
for u in graph[v]:
z = potomks_lists(u)
potomks[u] = z
cnt += z
potomks[1] = cnt
return cnt
potomks_lists(1)
def DFS2(v):
global keks
keks = min(keks, potomks[v])
for u in graph[v]:
keks = min(keks, potomks[u])
if A[u - 1] == 1:
DFS2(u)
def solve(v223):
DFS2(v223)
return 1 + potomks[1] - keks
def kek(v):
if A[v - 1] == 1:
return solve(v)
else:
return len(graph[v])
print(kek(1))
``` | instruction | 0 | 80,882 | 13 | 161,764 |
No | output | 1 | 80,882 | 13 | 161,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
WEW = list(map(int, input().split()))
graph = {i: set() for i in range(1, n + 1)}
times = {i: [] for i in range(1, n + 1)}
for i in range(n - 1):
graph[WEW[i]].add(i + 2)
if A[0] == 0:
print(1)
exit(0)
time = 0
keks = n + 1
k = 0
potomks = {}
for i in graph:
if graph[i] == set():
k += 1
def potomks_lists(v):
if graph[v] == set():
return 1
cnt = 0
for u in graph[v]:
z = potomks_lists(u)
potomks[u] = z
cnt += z
potomks[1] = cnt
return cnt
def DFS2(v):
global keks
for u in graph[v]:
keks = min(keks, potomks[u])
if A[u - 1] == 1:
DFS2(u)
potomks_lists(1)
DFS2(1)
print(1 + k - keks)
``` | instruction | 0 | 80,883 | 13 | 161,766 |
No | output | 1 | 80,883 | 13 | 161,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
node = [0 for i in range(n)]
parent = [0 for i in range(n)]
node[:n] = map(int, input().split())
parent[1:n] = map(int, input().split())
treenode = [-1 for i in range(n)]
for i in range(n):
if (n-i) in parent:
if node[n - 1 - i] == 0:
if treenode[n - 1 - i] == -1:
treenode[n - 1 - i] = parent.count(n - i) - 1
else:
treenode[n - 1 - i] += parent.count(n - i) - 1
elif node[n - 1 - i] == 1:
if treenode[n - 1 - i] == -1:
treenode[n - 1 - i] = 0
if i < (n - 1) and node[parent[n - 1 - i] - 1] == 0:
if treenode[parent[n - 1 - i] - 1] == -1:
treenode[parent[n - 1 - i] - 1] = treenode[n - 1 - i]
else:
treenode[parent[n - 1 - i] - 1] += treenode[n - 1 - i]
elif i < (n - 1) and node[parent[n - 1 - i] - 1] == 1:
if treenode[parent[n - 1 - i] - 1] == -1:
treenode[parent[n - 1 - i] - 1] = treenode[n - 1 - i]
else:
treenode[parent[n - 1 - i] - 1] = min(treenode[parent[n - 1 - i] - 1], treenode[n - 1 - i])
else:
if i < (n - 1) and treenode[parent[n - 1 - i] - 1] == -1:
treenode[parent[n - 1 - i] - 1] = 0
print (treenode)
print (treenode.count(-1) - treenode[0])
``` | instruction | 0 | 80,884 | 13 | 161,768 |
No | output | 1 | 80,884 | 13 | 161,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Now Serval is a junior high school student in Japari Middle School, and he is still thrilled on math as before.
As a talented boy in mathematics, he likes to play with numbers. This time, he wants to play with numbers on a rooted tree.
A tree is a connected graph without cycles. A rooted tree has a special vertex called the root. A parent of a node v is the last different from v vertex on the path from the root to the vertex v. Children of vertex v are all nodes for which v is the parent. A vertex is a leaf if it has no children.
The rooted tree Serval owns has n nodes, node 1 is the root. Serval will write some numbers into all nodes of the tree. However, there are some restrictions. Each of the nodes except leaves has an operation max or min written in it, indicating that the number in this node should be equal to the maximum or minimum of all the numbers in its sons, respectively.
Assume that there are k leaves in the tree. Serval wants to put integers 1, 2, …, k to the k leaves (each number should be used exactly once). He loves large numbers, so he wants to maximize the number in the root. As his best friend, can you help him?
Input
The first line contains an integer n (2 ≤ n ≤ 3⋅ 10^5), the size of the tree.
The second line contains n integers, the i-th of them represents the operation in the node i. 0 represents min and 1 represents max. If the node is a leaf, there is still a number of 0 or 1, but you can ignore it.
The third line contains n-1 integers f_2, f_3, …, f_n (1 ≤ f_i ≤ i-1), where f_i represents the parent of the node i.
Output
Output one integer — the maximum possible number in the root of the tree.
Examples
Input
6
1 0 1 1 0 1
1 2 2 2 2
Output
1
Input
5
1 0 1 0 1
1 1 1 1
Output
4
Input
8
1 0 0 1 0 1 1 0
1 1 2 2 3 3 3
Output
4
Input
9
1 1 0 0 1 0 1 0 1
1 1 2 2 3 3 4 4
Output
5
Note
Pictures below explain the examples. The numbers written in the middle of the nodes are their indices, and the numbers written on the top are the numbers written in the nodes.
In the first example, no matter how you arrange the numbers, the answer is 1.
<image>
In the second example, no matter how you arrange the numbers, the answer is 4.
<image>
In the third example, one of the best solution to achieve 4 is to arrange 4 and 5 to nodes 4 and 5.
<image>
In the fourth example, the best solution is to arrange 5 to node 5.
<image>
Submitted Solution:
```
n = int(input())
node = [0 for i in range(n)]
parent = [0 for i in range(n)]
node[:n] = map(int, input().split())
parent[1:n] = map(int, input().split())
treenode = [-1 for i in range(n)]
for i in range(n):
if (n-i) in parent:
if i < (n - 1) and node[parent[n - 1 - i] - 1] == 0:
treenode[parent[n - 1 - i] - 1] += (1 + treenode[n - 1 - i])
elif i < (n - 1) and node[parent[n - 1 - i] - 1] == 1:
if treenode[parent[n - 1 - i] - 1] == -1:
treenode[parent[n - 1 - i] - 1] = treenode[n - 1 - i]
else:
treenode[parent[n - 1 - i] - 1] = min(treenode[parent[n - 1 - i] - 1], treenode[n - 1 - i])
else:
if i < (n - 1) and node[parent[n - 1 - i] - 1] == 0:
treenode[parent[n - 1 - i] - 1] += 1
elif i < (n - 1) and node[parent[n - 1 - i] - 1] == 1:
if i < (n - 1) and treenode[parent[n - 1 - i] - 1] == -1:
treenode[parent[n - 1 - i] - 1] = 0
else:
treenode[parent[n - 1 - i] - 1] = min(treenode[parent[n - 1 - i] - 1], treenode[n - 1 - i])
print (treenode.count(-1) - treenode[0])
``` | instruction | 0 | 80,885 | 13 | 161,770 |
No | output | 1 | 80,885 | 13 | 161,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image> | instruction | 0 | 80,975 | 13 | 161,950 |
Tags: constructive algorithms, dfs and similar, dp, math, trees
Correct Solution:
```
import os
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(int(3e5))
from collections import deque
from queue import PriorityQueue
import math
import copy
# list(map(int, input().split()))
#####################################################################################
class CF(object):
def __init__(self):
self.n = int(input())
self.g = [[] for _ in range(self.n)]
self.v = [[] for _ in range(self.n)]
self.r = [] # last order path
self.f = [-1] * self.n
self.vis = [0] * self.n
for _ in range(self.n-1):
x, y = list(map(int, input().split()))
x-=1
y-=1
self.v[x].append(y)
self.v[y].append(x)
pass
self.g = copy.deepcopy(self.v)
self.dp = [[0,0] for _ in range(self.n)]
self.leaf = [0] * self.n
for i in range(self.n):
if(len(self.g[i]) == 1):
self.leaf[i] = True
pass
def dfs(self, root=0): # last order path
s = [root]
v = [self.g[root]]
self.vis[root] = 1
while(len(s)> 0):
if(v[-1] == []):
v.pop()
self.r.append(s.pop())
else:
now = v[-1].pop()
if(not self.vis[now]):
self.vis[now] = 1
self.f[now] = s[-1]
s.append(now)
v.append(self.g[now])
pass
def update(self, temp, x):
temp.append(x)
for i in range(len(temp)-1)[::-1]:
if(temp[i+1]> temp[i]):
temp[i+1], temp[i] = temp[i], temp[i+1]
pass
return temp[:2]
def main(self):
self.dfs()
ans = 0
for now in self.r:
if(self.leaf[now]):
self.dp[now][1] = 1
self.dp[now][0] = 0
else:
temp = []
t2 = []
for to in self.v[now]:
if(to != self.f[now]):
#temp = max(temp, self.dp[to][0])
temp = self.update(temp, self.dp[to][0])
t2 = self.update(t2, max(self.dp[to][1], self.dp[to][0]))
#t2 = max(t2, max(self.dp[to][1], self.dp[to][0]))
pass
self.dp[now][1] = temp[0] + 1
self.dp[now][0] = t2[0] + len(self.v[now])-1-1
ans = max(ans, 1+sum(temp))
ans = max(ans, len(self.v[now]) - len(t2) + sum(t2))
pass
ar = []
for to in self.v[0]:
ar.append(self.dp[to][0])
ar.sort()
if(len(ar)>=2):
ans = max(ans, 1+ar[-1]+ar[-2])
else:
ans = max(ans, 1+ar[-1])
ar = []
for to in self.v[0]:
ar.append(max(self.dp[to][1], self.dp[to][0]))
ar.sort()
for i in range(len(ar)-2):
ar[i] = 1
ans = max(ans, sum(ar))
print(ans)
pass
# print(self.dp)
# print(self.leaf)
# print(self.r)
# print(self.f)
if __name__ == "__main__":
cf = CF()
cf.main()
pass
``` | output | 1 | 80,975 | 13 | 161,951 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image> | instruction | 0 | 80,976 | 13 | 161,952 |
Tags: constructive algorithms, dfs and similar, dp, math, trees
Correct Solution:
```
n=int(input())
tr=[[]for i in range(n+9)]
for i in range(n-1):
u,v=list(map(int,input().split()))
tr[u].append(v)
tr[v].append(u)
dp,ans=[[0,0]for i in range(n+9)],0
stk,tot=[(1,-1)],0
for i in range(n):
u,fa=stk[i]
for v in tr[u]:
if v!=fa:
stk.append((v,u))
tot+=1
for u,fa in reversed(stk):
cnt=len(tr[u])
for v in tr[u]:
if v!=fa:
ans=max(ans,dp[u][1]+dp[v][0]+1,dp[u][0]+cnt-2+max(dp[v]))
dp[u]=[max(dp[u][0],max(dp[v])),max(dp[u][1],dp[v][0])]
dp[u][0]+=max(cnt-2,0)
dp[u][1]+=1
ans=max(ans,max(dp[u]))
print(ans)
``` | output | 1 | 80,976 | 13 | 161,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image>
Submitted Solution:
```
from sys import stdin
input = stdin.readline
class N:
def __init__(self, i) -> None:
self.i = i + 1
self.b = 0
self.c = []
def __str__(self) -> str:
return str(self.i)
def cal_b(self, viz):
viz.add(self)
if self.b:
return self.b
if self.c:
l = list(filter(lambda o: o not in viz, self.c))
self.b = max(max(map(lambda x: x.cal_b(viz), l), default=0) + len(l) - 1, 1)
return self.b
if __name__ == '__main__':
n = int(input())
arr = [N(i) for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
arr[a - 1].c.append(arr[b - 1])
arr[b - 1].c.append(arr[a - 1])
arr.sort(key=lambda x: len(x.c), reverse=True)
root = arr[0]
print(root.cal_b(set()) + int(len(root.c) == 1))
``` | instruction | 0 | 80,977 | 13 | 161,954 |
No | output | 1 | 80,977 | 13 | 161,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image>
Submitted Solution:
```
import os
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(int(3e5))
from collections import deque
from queue import PriorityQueue
import math
import copy
# list(map(int, input().split()))
#####################################################################################
class CF(object):
def __init__(self):
self.n = int(input())
self.g = [[] for _ in range(self.n)]
self.v = [[] for _ in range(self.n)]
self.r = [] # last order path
self.f = [-1] * self.n
self.vis = [0] * self.n
for _ in range(self.n-1):
x, y = list(map(int, input().split()))
x-=1
y-=1
self.v[x].append(y)
self.v[y].append(x)
pass
self.g = copy.deepcopy(self.v)
self.dp = [[0,0] for _ in range(self.n)]
self.leaf = [0] * self.n
for i in range(self.n):
if(len(self.g[i]) == 1):
self.leaf[i] = True
pass
def dfs(self, root=0): # last order path
s = [root]
v = [self.g[root]]
self.vis[root] = 1
while(len(s)> 0):
if(v[-1] == []):
v.pop()
self.r.append(s.pop())
else:
now = v[-1].pop()
if(not self.vis[now]):
self.vis[now] = 1
self.f[now] = s[-1]
s.append(now)
v.append(self.g[now])
pass
def main(self):
self.dfs()
for now in self.r:
if(self.leaf[now]):
self.dp[now][1] = 1
self.dp[now][0] = 0
else:
temp = 0
t2 = 0
for to in self.v[now]:
if(to != self.f[now]):
temp = max(temp, self.dp[to][0])
t2 = max(t2, max(self.dp[to][1], self.dp[to][0]))
pass
self.dp[now][1] = temp + 1
self.dp[now][0] = t2 + len(self.v[now])-1-1
pass
ans = 0
ar = []
for to in self.v[0]:
ar.append(self.dp[to][0])
ar.sort()
if(len(ar)>=2):
ans = max(ans, 1+ar[-1]+ar[-2])
else:
ans = max(ans, 1+ar[-1])
ar = []
for to in self.v[0]:
ar.append(max(self.dp[to][1], self.dp[to][0]))
ar.sort()
for i in range(len(ar)-2):
ar[i] = 1
ans = max(ans, sum(ar))
print(ans)
pass
# print(self.dp)
# print(self.leaf)
# print(self.r)
# print(self.f)
if __name__ == "__main__":
cf = CF()
cf.main()
pass
``` | instruction | 0 | 80,978 | 13 | 161,956 |
No | output | 1 | 80,978 | 13 | 161,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image>
Submitted Solution:
```
import sys
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(x) for x in sys.stdin.readline().split()]
a -= 1
b -= 1
adj[a].append(b)
adj[b].append(a)
edge_to_value = {}
parent = [None]*n
parent[0] = -1
stack = [0]
toposort = []
while len(stack):
cur = stack.pop()
toposort.append(cur)
for nb in adj[cur]:
if parent[nb] == None:
parent[nb] = cur
stack.append(nb)
toposort = list(reversed(toposort))
done = [False]*n
for v in toposort:
done[v] = True
if v == 0:
continue
if len(adj[v]) == 1:
edge_to_value[(v, adj[v][0])] = 1
continue
res = len(adj[v]) - 2
res += max(edge_to_value[(x, v)] for x in adj[v] if done[x])
edge_to_value[(v, parent[v])] = res
# print(edge_to_value)
done = [False]*n
for v in reversed(toposort):
done[v] = True
if len(adj[v]) == 1:
edge_to_value[(v, adj[v][0])] = 1
continue
children = [x for x in adj[v] if not done[x]]
children2 = [x for x in adj[v] if parent[x] == v]
assert children == children2
if len(children) == 1:
edge_to_value[(v, children[0])] = edge_to_value[(parent[v], v)]
continue
mx = -1
mxi = -1
sndmx = -1
if v != 0:
mx = edge_to_value[(parent[v], v)]
mxi = parent[v]
for child in children:
val = edge_to_value[(child, v)]
if val > mx:
sndmx = mx
mx = val
mxi = child
elif val > sndmx:
sndmx = val
assert mx != -1
assert sndmx != -1
assert mxi != -1
for child in children:
if child == mxi:
edge_to_value[(v, child)] = sndmx + len(adj[v]) - 2
else:
edge_to_value[(v, child)] = mx + len(adj[v]) - 2
# print(edge_to_value)
# for a, b in edge_to_value:
# print(a+1, b+1, ":", edge_to_value[(a,b)])
res = 0
for v in range(n):
res = max(res, len(adj[v]) - 1 + max(edge_to_value[(nb, v)] for nb in adj[v]))
print(res)
``` | instruction | 0 | 80,979 | 13 | 161,958 |
No | output | 1 | 80,979 | 13 | 161,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a tree of n vertices. You are going to convert this tree into n rubber bands on infinitely large plane. Conversion rule follows:
* For every pair of vertices a and b, rubber bands a and b should intersect if and only if there is an edge exists between a and b in the tree.
* Shape of rubber bands must be a simple loop. In other words, rubber band is a loop which doesn't self-intersect.
Now let's define following things:
* Rubber band a includes rubber band b, if and only if rubber band b is in rubber band a's area, and they don't intersect each other.
* Sequence of rubber bands a_{1}, a_{2}, …, a_{k} (k ≥ 2) are nested, if and only if for all i (2 ≤ i ≤ k), a_{i-1} includes a_{i}.
<image> This is an example of conversion. Note that rubber bands 5 and 6 are nested.
It can be proved that is it possible to make a conversion and sequence of nested rubber bands under given constraints.
What is the maximum length of sequence of nested rubber bands can be obtained from given tree? Find and print it.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print the answer.
Examples
Input
6
1 3
2 3
3 4
4 5
4 6
Output
4
Input
4
1 2
2 3
3 4
Output
2
Note
In the first sample, you can obtain a nested sequence of 4 rubber bands(1, 2, 5, and 6) by the conversion shown below. Of course, there are other conversions exist to make a nested sequence of 4 rubber bands. However, you cannot make sequence of 5 or more nested rubber bands with given tree.
<image>
You can see one of the possible conversions for the second sample below.
<image>
Submitted Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
l = [[] for i in range(n)]
l2 = [[] for i in range(n)]
for _ in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
l[a].append(b)
l[b].append(a)
l2[a].append(b)
l2[b].append(a)
visited = [False] * n
using = [0] * n
notUsing = [0] * n
double = [0] * n
visited[0] = True
stack = [0]
while stack:
curr = stack[-1]
if l2[curr]:
nex = l2[curr].pop()
if not visited[nex]:
stack.append(nex)
visited[nex] = True
else:
usingN = [0, 0]
notUsingN = [0, 0]
for v in l[curr]:
usingN.append(using[v])
notUsingN.append(notUsing[v])
usingN.sort(reverse = True)
notUsingN.sort(reverse = True)
using[curr] = notUsingN[0]
notUsing[curr] = max(1 + usingN[0], using[curr])
double[curr] = notUsingN[0] + notUsingN[1]
stack.pop()
print(max(double + notUsing))
``` | instruction | 0 | 80,980 | 13 | 161,960 |
No | output | 1 | 80,980 | 13 | 161,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
You are given a tree — connected undirected graph without cycles. One vertex of the tree is special, and you have to find which one. You can ask questions in the following form: given an edge of the tree, which endpoint is closer to the special vertex, meaning which endpoint's shortest path to the special vertex contains fewer edges. You have to find the special vertex by asking the minimum number of questions in the worst case for a given tree.
Please note that the special vertex might not be fixed by the interactor in advance: it might change the vertex to any other one, with the requirement of being consistent with the previously given answers.
Input
You are given an integer n (2 ≤ n ≤ 100) — the number of vertices in a tree.
The folloiwing n-1 lines contain two integers each, u and v (1 ≤ u, v ≤ n), that denote an edge in the tree connecting u and v. It is guaranteed that the given edges form a tree.
Interaction
After reading the input data, one can start making queries. There are two possible queries:
1. "? u v" — to ask for an edge (u, v) (1 ≤ u, v ≤ n) which of the endpoints is closer to the special vertex. The answer to this query is one of the endpoints. Note that, u and v must be connected by an edge, and hence they can not have the same distance to the special vertex.
2. "! u" — to indicate that you found the special vertex. After the program does that, it must immediately terminate.
Do not forget to output the end of line and flush the output. Otherwise you will get Idleness limit exceeded verdict. To flush the output, you can use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* sys.stdout.flush() in Python;
* see documentation for other languages.
In case you ask more queries than needed in the worst case for a given tree, you will get verdict Wrong answer.
Examples
Input
5
1 2
2 3
3 4
4 5
3
2
1
Output
? 3 4
? 2 3
? 1 2
! 1
Input
5
2 1
3 1
4 1
5 1
1
1
4
Output
? 1 2
? 1 3
? 1 4
! 4
Note
Hacks are forbidden in this task.
Submitted Solution:
```
#!/usr/local/bin/python3
``` | instruction | 0 | 81,029 | 13 | 162,058 |
No | output | 1 | 81,029 | 13 | 162,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,030 | 13 | 162,060 |
Tags: binary search, data structures, greedy
Correct Solution:
```
MAX_H = int(2e5 + 20)
n, k = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
cur = 1
cur_sum = 0
cur_level = 0
flag_seen = 1
flag_sum = 0
ans = flag_level = int(MAX_H - 1) # less is enough?
lazy = [0] * MAX_H
while len(l) > 0 and cur_level + 2 < flag_level: # change with l
new_chain = l.pop()
cur -= 1
lazy[cur_level + 2] += 2
lazy[cur_level + 2 + (new_chain - 1) // 2] -= 1
lazy[cur_level + 2 + new_chain // 2] -= 1
flag_seen -= 1
flag_seen += min(flag_level, cur_level + 2 + (new_chain - 1) // 2) - (cur_level + 2)
flag_seen += min(flag_level, cur_level + 2 + new_chain // 2) - (cur_level + 2)
flag_sum += sum(x >= flag_level for x in [cur_level + 2 + (new_chain - 1) // 2, cur_level + 2 + new_chain // 2])
while cur == 0:
cur_level += 1
cur_sum += lazy[cur_level]
cur += cur_sum
while flag_seen >= k:
flag_seen -= flag_sum
flag_level -= 1
flag_sum -= lazy[flag_level]
ans = min(ans, flag_level)
print(-1 if ans == MAX_H - 1 else ans)
``` | output | 1 | 81,030 | 13 | 162,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,031 | 13 | 162,062 |
Tags: binary search, data structures, greedy
Correct Solution:
```
class RangeBIT:
def __init__(self,N,indexed):
self.bit1 = [0] * (N+2)
self.bit2 = [0] * (N+2)
self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
def add(self,l,r,w):
l = l + (1-self.mode)
r = r + (1-self.mode)
self.bitadd(l,-1*w*l,self.bit1)
self.bitadd(r,w*r,self.bit1)
self.bitadd(l,w,self.bit2)
self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):
l = l + (1-self.mode)
r = r + (1-self.mode)
ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)
ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)
return ret
def get(self,ind):
return self.sum(ind,ind+1)
for loop in range(1):
n,k = map(int,input().split())
L = sorted(list(map(int,input().split())))
B = RangeBIT(400000,0)
B.add(0,1,1)
ans = float("inf")
ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
while B.get(ind) == 0:
ind += 1
B.add(ind,ind+1,-1)
x = (L[-1]-1)//2
y = (L[-1]-1)-x
B.add(ind+2,ind+2+x,1)
B.add(ind+2,ind+2+y,1)
del L[-1]
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
if ans == float("inf"):
print (-1)
else:
print (ans)
``` | output | 1 | 81,031 | 13 | 162,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,032 | 13 | 162,064 |
Tags: binary search, data structures, greedy
Correct Solution:
```
def check(d, k):
pos, cur, P = 0, 1, 0
total = 1
for i, x in enumerate(L):
while cur == 0:
pos += 1
P += add[pos]
if pos + 1 >= d:
break
cur += P
cur -= 1
if pos + x//2 + 1 <= d:
total += x - 2
else:
total += (d-pos-1) * 2 - 1
if total >= k:
return True
return total >= k
n, k = list(map(int, input().split()))
L = list(map(int, input().split()))
L = sorted(L, key=lambda x:-x)
MAX = 2 * 10 ** 5
cnt = [0] * MAX
add = [0] * MAX
cnt[0] = 0
pos, cur, P = 0, 1, 0
total = 1
for i, x in enumerate(L):
while cur == 0:
pos += 1
P += add[pos]
cur += P
cur -= 1
nums = (x - 1) // 2
add[pos+2] += 2
add[pos+2+nums] -= 2
if x%2==0:
add[pos+2+nums] += 1
add[pos+3+nums] -= 1
total += x - 2
if total < k:
print(-1)
else:
l, r = 1, MAX
while r-l>1:
md=(l+r) // 2
if check(md, k) == True:
r=md
else:
l=md
print(r)
``` | output | 1 | 81,032 | 13 | 162,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,033 | 13 | 162,066 |
Tags: binary search, data structures, greedy
Correct Solution:
```
class RangeBIT:
def __init__(self,N,indexed):self.bit1 = [0] * (N+2);self.bit2 = [0] * (N+2);self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):bit[x] += w;x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0;x = a
while x > 0:ret += bit[x];x -= x & (-1 * x)
return ret
def add(self,l,r,w):l = l + (1-self.mode);r = r + (1-self.mode);self.bitadd(l,-1*w*l,self.bit1);self.bitadd(r,w*r,self.bit1);self.bitadd(l,w,self.bit2);self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):
l = l + (1-self.mode)
r = r + (1-self.mode)
ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)
ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)
return ret
def get(self,ind):
return self.sum(ind,ind+1)
for loop in range(1):
n,k = map(int,input().split())
L = sorted(list(map(int,input().split())))
B = RangeBIT(400000,0)
B.add(0,1,1)
ans = float("inf")
ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
while B.get(ind) == 0:
ind += 1
B.add(ind,ind+1,-1)
x = (L[-1]-1)//2
y = (L[-1]-1)-x
B.add(ind+2,ind+2+x,1)
B.add(ind+2,ind+2+y,1)
del L[-1]
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
if ans == float("inf"):
print (-1)
else:
print (ans)
``` | output | 1 | 81,033 | 13 | 162,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,034 | 13 | 162,068 |
Tags: binary search, data structures, greedy
Correct Solution:
```
MAX_H = int(2e5 + 20)
n, k = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
cur = 1
cur_sum = 0
cur_level = 0
flag_seen = 1
flag_sum = 0
ans = flag_level = int(MAX_H - 1)
lazy = [0] * MAX_H
while l and cur_level + 2 < flag_level:
new_chain = l.pop()
cur -= 1
lazy[cur_level + 2] += 2
lazy[cur_level + 2 + (new_chain - 1) // 2] -= 1
lazy[cur_level + 2 + new_chain // 2] -= 1
flag_seen -= 1
flag_seen += min(flag_level, cur_level + 2 + (new_chain - 1) // 2) - (cur_level + 2)
flag_seen += min(flag_level, cur_level + 2 + new_chain // 2) - (cur_level + 2)
flag_sum += sum(x >= flag_level for x in [cur_level + 2 + (new_chain - 1) // 2, cur_level + 2 + new_chain // 2])
while cur == 0:
cur_level += 1
cur_sum += lazy[cur_level]
cur += cur_sum
while flag_seen >= k:
flag_seen -= flag_sum
flag_level -= 1
flag_sum -= lazy[flag_level]
ans = min(ans, flag_level)
print(-1 if ans == MAX_H - 1 else ans)
``` | output | 1 | 81,034 | 13 | 162,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,035 | 13 | 162,070 |
Tags: binary search, data structures, greedy
Correct Solution:
```
class RangeBIT:
def __init__(self,N,indexed):self.bit1 = [0] * (N+2);self.bit2 = [0] * (N+2);self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):bit[x] += w;x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0;x = a
while x > 0:ret += bit[x];x -= x & (-1 * x)
return ret
def add(self,l,r,w):l = l + (1-self.mode);r = r + (1-self.mode);self.bitadd(l,-1*w*l,self.bit1);self.bitadd(r,w*r,self.bit1);self.bitadd(l,w,self.bit2);self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):l = l + (1-self.mode);r = r + (1-self.mode);ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2);ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2);return ret
def get(self,ind):return self.sum(ind,ind+1)
for loop in range(1):
n,k = map(int,input().split())
L = sorted(list(map(int,input().split())))
B = RangeBIT(400000,0)
B.add(0,1,1)
ans = float("inf")
ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
while B.get(ind) == 0:
ind += 1
B.add(ind,ind+1,-1)
x = (L[-1]-1)//2
y = (L[-1]-1)-x
B.add(ind+2,ind+2+x,1)
B.add(ind+2,ind+2+y,1)
del L[-1]
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
if ans == float("inf"):
print (-1)
else:
print (ans)
``` | output | 1 | 81,035 | 13 | 162,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,036 | 13 | 162,072 |
Tags: binary search, data structures, greedy
Correct Solution:
```
import sys
from sys import stdin
class RangeBIT:
def __init__(self,N,indexed):
self.bit1 = [0] * (N+2)
self.bit2 = [0] * (N+2)
self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
def add(self,l,r,w):
l = l + (1-self.mode)
r = r + (1-self.mode)
self.bitadd(l,-1*w*l,self.bit1)
self.bitadd(r,w*r,self.bit1)
self.bitadd(l,w,self.bit2)
self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):
l = l + (1-self.mode)
r = r + (1-self.mode)
ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)
ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)
return ret
def get(self,ind):
return self.sum(ind,ind+1)
tt = 1
for loop in range(tt):
n,k = map(int,stdin.readline().split())
L = list(map(int,stdin.readline().split()))
L.sort()
B = RangeBIT(400000,0)
B.add(0,1,1)
ans = float("inf")
ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
while B.get(ind) == 0:
ind += 1
B.add(ind,ind+1,-1)
x = (L[-1]-1)//2
y = (L[-1]-1)-x
#print (x,y)
B.add(ind+2,ind+2+x,1)
B.add(ind+2,ind+2+y,1)
del L[-1]
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
if ans == float("inf"):
print (-1)
else:
print (ans)
``` | output | 1 | 81,036 | 13 | 162,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example. | instruction | 0 | 81,037 | 13 | 162,074 |
Tags: binary search, data structures, greedy
Correct Solution:
```
MAX_H = int(4e5)
n, k = map(int, input().split())
l = list(map(int, input().split()))
l.sort()
cur = 1
cur_sum = 0
cur_level = 0
flag_seen = 1
flag_sum = 0
ans = flag_level = int(MAX_H - 1) # less is enough?
lazy = [0] * MAX_H
while len(l) > 0 and cur_level + 2 < flag_level: # change with l
new_chain = l.pop()
cur -= 1
lazy[cur_level + 2] += 2
lazy[cur_level + 2 + (new_chain - 1) // 2] -= 1
lazy[cur_level + 2 + new_chain // 2] -= 1
flag_seen -= 1
flag_seen += min(flag_level, cur_level + 2 + (new_chain - 1) // 2) - (cur_level + 2)
flag_seen += min(flag_level, cur_level + 2 + new_chain // 2) - (cur_level + 2)
flag_sum += sum(x >= flag_level for x in [cur_level + 2 + (new_chain - 1) // 2, cur_level + 2 + new_chain // 2])
while cur == 0:
cur_level += 1
cur_sum += lazy[cur_level]
cur += cur_sum
while flag_seen >= k:
flag_seen -= flag_sum
flag_level -= 1
flag_sum -= lazy[flag_level]
ans = min(ans, flag_level)
print(-1 if ans == MAX_H - 1 else ans)
``` | output | 1 | 81,037 | 13 | 162,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
class RangeBIT:
def __init__(self,N,indexed):self.bit1 = [0] * (N+2);self.bit2 = [0] * (N+2);self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):bit[x] += w;x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0;x = a
while x > 0:ret += bit[x];x -= x & (-1 * x)
return ret
def add(self,l,r,w):l = l + (1-self.mode);r = r + (1-self.mode);self.bitadd(l,-1*w*l,self.bit1);self.bitadd(r,w*r,self.bit1);self.bitadd(l,w,self.bit2);self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):l = l + (1-self.mode);r = r + (1-self.mode);ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2);ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2);return ret
def get(self,ind):return self.sum(ind,ind+1)
for loop in range(1):
n,k = map(int,input().split());L = sorted(list(map(int,input().split())));B = RangeBIT(400000,0);B.add(0,1,1);ans = float("inf");ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000;l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k: r = m
else: l = m
ans = min(ans,r)
while B.get(ind) == 0:ind += 1
B.add(ind,ind+1,-1);x = (L[-1]-1)//2;y = (L[-1]-1)-x;B.add(ind+2,ind+2+x,1);B.add(ind+2,ind+2+y,1);del L[-1]
if B.sum(0,300000) >= k:
r = 300000;l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k: r = m
else: l = m
ans = min(ans,r)
print (-1) if ans == float("inf") else print (ans)
``` | instruction | 0 | 81,038 | 13 | 162,076 |
Yes | output | 1 | 81,038 | 13 | 162,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
import sys
input = sys.stdin.readline
import math
n, k = map(int, input().split())
B = sorted(map(int, input().split()), reverse=True)
N = 5 * (n + max(B))
A = [0] * N
A[0] = 1
A[1] = -1
ans = float("inf")
total = 0
j = 0
for i in range(N - 1):
total += A[i]
A[i + 1] += A[i]
if total + A[i + 1] >= k:
ans = min(ans, i + 1)
while A[i] > 0 and j < n:
u = (B[j] - 1) // 2
v = B[j] - 1 - u
A[i + 2] += 1
A[i + 2 + u] -= 1
A[i + 2] += 1
A[i + 2 + v] -= 1
A[i] -= 1
total -= 1
j += 1
print(ans if ans < float("inf") else -1)
``` | instruction | 0 | 81,039 | 13 | 162,078 |
Yes | output | 1 | 81,039 | 13 | 162,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
import sys
from sys import stdin
class RangeBIT:
def __init__(self,N,indexed):
self.bit1 = [0] * (N+2)
self.bit2 = [0] * (N+2)
self.mode = indexed
def bitadd(self,a,w,bit):
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(self,a,bit):
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
def add(self,l,r,w):
l = l + (1-self.mode)
r = r + (1-self.mode)
self.bitadd(l,-1*w*l,self.bit1)
self.bitadd(r,w*r,self.bit1)
self.bitadd(l,w,self.bit2)
self.bitadd(r,-1*w,self.bit2)
def sum(self,l,r):
l = l + (1-self.mode)
r = r + (1-self.mode)
ret = self.bitsum(r,self.bit1) + r * self.bitsum(r,self.bit2)
ret -= self.bitsum(l,self.bit1) + l * self.bitsum(l,self.bit2)
return ret
def get(self,ind):
return self.sum(ind,ind+1)
tt = 1
for loop in range(tt):
n,k = map(int,input().split())
L = list(map(int,input().split()))
L.sort()
B = RangeBIT(400000,0)
B.add(0,1,1)
ans = float("inf")
ind = 0
for i in range(n):
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
while B.get(ind) == 0:
ind += 1
B.add(ind,ind+1,-1)
x = (L[-1]-1)//2
y = (L[-1]-1)-x
#print (x,y)
B.add(ind+2,ind+2+x,1)
B.add(ind+2,ind+2+y,1)
del L[-1]
if B.sum(0,300000) >= k:
r = 300000
l = 0
while r-l != 1:
m = (l+r)//2
if B.sum(0,m+1) >= k:
r = m
else:
l = m
ans = min(ans,r)
if ans == float("inf"):
print (-1)
else:
print (ans)
``` | instruction | 0 | 81,040 | 13 | 162,080 |
Yes | output | 1 | 81,040 | 13 | 162,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort(reverse=True)
rem=[1]
i=0
d=0
toad=[]
while i<n:
old=toad
toad=[]
d+=1
s=0
tor=[]
foo=len(rem)
for j in range(foo):
if i<n:
v=l[i]
i+=1
rem[j]-=1
if rem[j]==0:
tor.append(j)
s+=min(rem[j],3)
v1,v2=v//2,(v-1)//2
toad.append(v1)
toad.append(v2)
s+=min(4,v-1)
for x in old:
rem.append(x)
s+=min(x,3)
for j in range(len(tor)):
rem.pop(tor[-j-1])
if s>=k:
break
for x in toad:
rem.append(x)
rem.sort()
ln=len(rem)
cur=0
ans=-1
pr=0
for i in range(ln):
mx=cur+(ln-i)*(rem[i]-pr)
if mx<k:
cur=mx
pr=rem[i]
else:
k-=cur
ans=d+pr
mn=(k+ln-i-1)//(ln-i)
ans+=mn
break
print(ans)
``` | instruction | 0 | 81,041 | 13 | 162,082 |
No | output | 1 | 81,041 | 13 | 162,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
class ovo:
def __init__(this):
this.l = this.r = None
this.s = this.h = 0
def R(this, g):
return this.s + this.h * g
def S(this, g):
if this.l == None:
this.l = ovo()
if this.r == None:
this.r = ovo()
this.l.h += this.h
this.r.h += this.h
this.s = this.R(g)
this.h = 0
def P(this, lz, rz):
this.s = this.l.R(lz) + this.r.R(rz)
rt = ovo()
def pac(l, r, t):
if l == r:
return l
t.S(r - l + 1)
m = (l + r) // 2
if t.l.R(m - l + 1):
return pac(l, m, t.l)
else:
return pac(m + 1, r, t.r)
def sgs(sl, sr, vl, l, r, t):
if (l > sr or r < sl):
return
if (l >= sl and r <= sr):
t.h += vl
return
t.S(r - l + 1)
m = (l + r) // 2
sgs(sl, sr, vl, l, m, t.l)
sgs(sl, sr, vl, m + 1, r, t.r)
t.P(m - l + 1, r - m)
def pkm(k, l, r, t):
# print("[]", l, r, k)
if l == r:
return l
t.S(r - l + 1)
m = (l + r) // 2
if t.l.R(m - l + 1) >= k:
return pkm(k, l, m, t.l)
else:
return pkm(k - t.l.R(m - l + 1), m + 1, r, t.r)
m = 200005
m = 10
n, k = map(int, input().split())
a = input().split()
a = sorted([int(a[i]) for i in range(n)])
fp = -1
sgs(0, 0, 1, 0, m, rt)
for i in range(n - 1, -1, -1):
# print("[]", rt.R(m + 1))
j = pac(0, m, rt)
sgs(j, j, -1, 0, m, rt)
x = (a[i] - 1) // 2
sgs(j + 2, j + x + 1, 2, 0, m, rt)
if a[i] % 2 == 0:
sgs(j + x + 2, j + x + 2, 1, 0, m, rt)
if rt.R(m + 1) >= k:
tp = pkm(k, 0, m, rt)
if fp == -1:
fp = tp
else:
fp = min(fp, tp)
print(fp)
``` | instruction | 0 | 81,042 | 13 | 162,084 |
No | output | 1 | 81,042 | 13 | 162,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
print(n,k,l)
``` | instruction | 0 | 81,043 | 13 | 162,086 |
No | output | 1 | 81,043 | 13 | 162,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
// We decided to drop the legend about the power sockets but feel free to come up with your own :^)
Define a chain:
* a chain of length 1 is a single vertex;
* a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge.
You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.
* Each vertex of the tree is either white or black.
* The tree initially only has a white root vertex.
* All chains initially consist only of white vertices.
* You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black.
* Each chain can be used no more than once.
* Some chains can be left unused.
The distance between two vertices of the tree is the number of edges on the shortest path between them.
If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.
What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.
Input
The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.
The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.
Output
Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.
Examples
Input
1 2
3
Output
2
Input
3 3
4 3 3
Output
3
Input
3 5
4 3 4
Output
4
Input
2 10
5 7
Output
-1
Note
<image>
You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,k=map(int,input().split())
l=list(map(int,input().split()))
l.sort(reverse=True)
rem=[1]
i=0
d=0
toad=[]
while i<n:
old=toad
toad=[]
d+=1
s=0
tor=[]
foo=len(rem)
for j in range(foo):
if i<n:
v=l[i]
i+=1
rem[j]-=1
if rem[j]==0:
tor.append(j)
s+=min(rem[j],3)
v1,v2=v//2,(v-1)//2
toad.append(v1)
toad.append(v2)
s+=min(4,v-1)
for x in old:
rem.append(x)
s+=min(x,3)
for j in range(len(tor)):
rem.pop(tor[-j-1])
if s>=k:
break
k-=len(rem)
for i in range(len(rem)):
rem[i]-=1
for x in toad:
rem.append(x)
rem.sort()
#print(k,d,rem)
ln=len(rem)
cur=0
ans=-1
pr=0
for i in range(ln):
mx=cur+(ln-i)*(rem[i]-pr)
if mx<k:
cur=mx
pr=rem[i]
else:
k-=cur
ans=d+pr
mn=(k+ln-i-1)//(ln-i)
ans+=mn
break
print(ans)
``` | instruction | 0 | 81,044 | 13 | 162,088 |
No | output | 1 | 81,044 | 13 | 162,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,918 | 13 | 163,836 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
import sys
input = sys.stdin.buffer.readline
q = int(input())
INF = 10 ** 9
for _ in range(q):
n = int(input())
a = list(map(int, input().split())) + [-1]
res = [1]
cnt = 1
for i in range(1, n):
if a[i] < a[i + 1]:
cnt += 1
else:
res.append(cnt)
cnt = 1
idx = 0
pars = 1
ans = -1
while True:
# print(idx, pars)
if idx >= len(res):
break
val = 0
for i in range(idx, idx + pars):
if i < len(res):
val += res[i]
else:
break
idx = idx + pars
pars = val
ans += 1
print(ans)
``` | output | 1 | 81,918 | 13 | 163,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,919 | 13 | 163,838 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
import math
import bisect
# for _ in range(int(input())):
from collections import Counter
# sys.setrecursionlimit(10**6)
# dp=[[-1 for i in range(n+5)]for j in range(cap+5)]
# arr= list(map(int, input().split()))
# n,l= map(int, input().split())
# arr= list(map(int, input().split()))
# for _ in range(int(input())):
# n=int(input())
# for _ in range(int(input())):
import bisect
from heapq import *
from collections import defaultdict,deque
def okay(x,y):
if x<0 or x>=3 :
return False
if y<n and mat[x][y]!=".":
return False
if y+1<n and mat[x][y+1]!=".":
return False
if y+2<n and mat[x][y+2]!=".":
return False
return True
'''for i in range(int(input())):
n,m=map(int, input().split())
g=[[] for i in range(n+m)]
for i in range(n):
s=input()
for j,x in enumerate(s):
if x=="#":
g[i].append(n+j)
g[n+j].append(i)
q=deque([0])
dis=[10**9]*(n+m)
dis[0]=0
while q:
node=q.popleft()
for i in g[node]:
if dis[i]>dis[node]+1:
dis[i]=dis[node]+1
q.append(i)
print(-1 if dis[n-1]==10**9 else dis[n-1])'''
'''from collections import deque
t = int(input())
for _ in range(t):
q = deque([])
flag=False
n,k = map(int, input().split())
mat = [input() for i in range(3)]
vis=[[0 for i in range(105)]for j in range(3)]
for i in range(3):
if mat[i][0]=="s":
q.append((i,0))
while q:
x,y=q.popleft()
if y+1>=n:
flag=True
break
if vis[x][y]==1:
continue
vis[x][y]=1
if (y+1<n and mat[x][y+1]=='.' and okay(x-1,y+1)==True):
q.append((x-1,y+3))
if (y+1<n and mat[x][y+1]=='.' and okay(x,y+1)==True):
q.append((x,y+3))
if (y+1<n and mat[x][y+1]=='.' and okay(x+1,y+1)==True):
q.append((x+1,y+3))
if flag:
print("YES")
else:
print("NO")
#arr=sorted([i,j for i,j in enumerate(input().split())])
# ls=list(map(int, input().split()))
# d=defaultdict(list)'''
for _ in range(int(input())):
n=int(input())
#n,k= map(int, input().split())
ls=list(map(int, input().split()))
ans=1
node=[0]*n
node[0]=-1
var=0
for i in range(1,n):
if ls[i]>ls[i-1]:
continue
else:
if node[var]==-1:
ans+=1
var+=1
node[i-1]=-1
else:
var+=1
print(ans)
``` | output | 1 | 81,919 | 13 | 163,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,920 | 13 | 163,840 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
tests = int(input())
for test in range(tests):
n = int(input())
a = [int(i) for i in input().split()][1:]
b = [1]
for i in range(1, n - 1):
if a[i] > a[i - 1]:
b[-1] += 1
else:
b.append(1)
u = 0
c = 1
ans = 1
while u + c < len(b):
ans += 1
u, c = u + c, sum(b[u:u+c])
print(ans)
``` | output | 1 | 81,920 | 13 | 163,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,921 | 13 | 163,842 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
levels = [0]*n
index=0
for i in range(1, n):
if a[i]<a[i-1]:
index+=1
levels[i]=levels[index]+1
#print(levels)
print(levels[-1])
``` | output | 1 | 81,921 | 13 | 163,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,922 | 13 | 163,844 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
import sys
max_int = 1000000001 # 10^9+1
min_int = -max_int
t = int(input())
for _t in range(t):
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
if len(a) == 1:
print(0)
continue
cur_level = [0, 1]
next_level = [0, 0]
level = 1
for aa in a[1:]:
# print(cur_level, next_level, aa)
while cur_level[1]:
if aa > cur_level[0]:
cur_level[0] = aa
next_level[1] += 1
break
else:
cur_level[1] -= 1
cur_level[0] = 0
else:
level += 1
cur_level = [aa, next_level[1]]
next_level = [0, 1]
# print(cur_level, next_level)
print(level)
``` | output | 1 | 81,922 | 13 | 163,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,923 | 13 | 163,846 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
# Question: F - 1
# Assignment 10
# Daniel Perez, bd2255
# Based on the operation on how BFS works which essentially visits the
# levels of the tree first before moving on to the next level.
C = int(input())
for i in range(C):
SIZE = int(input())
L = list(map(int, input().split()))
HEIGHT = prev = curr = 1
for j in range(2,SIZE):
# tree doesnt step down a level
if L[j - 1] < L[j]:
prev += 1
# tree steps down a level because of how trees are structured
else:
curr -= 1
if curr == 0:
HEIGHT += 1
curr = prev
prev = 0
prev += 1
print(HEIGHT)
``` | output | 1 | 81,923 | 13 | 163,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,924 | 13 | 163,848 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
t = int(input())
for i in range(t):
n = int(input())
arr = [int(x) for x in input().split()]
visited = [(0, 0)]
vispointer = 0
for node in range(1, n):
if arr[node] > arr[node - 1]:
visited.append((arr[node], visited[vispointer][1] + 1))
else:
vispointer += 1
visited.append((arr[node], visited[vispointer][1] + 1))
print(visited[-1][1])
``` | output | 1 | 81,924 | 13 | 163,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image> | instruction | 0 | 81,925 | 13 | 163,850 |
Tags: graphs, greedy, shortest paths, trees
Correct Solution:
```
t = int(input())
for case in range(t):
n = int(input())
a = list(map(int, input().split()))
last = 1
prev_children = 1
children = 0
h = 1
for i in range(1, n):
cur = a[i]
if cur > last:
children += 1
else:
prev_children -= 1
if prev_children == 0:
h += 1
prev_children = children
children = 0
children += 1
last = cur
print(h)
``` | output | 1 | 81,925 | 13 | 163,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image>
Submitted Solution:
```
import os
from heapq import heapify, heappop, heappush
import sys
import sys,threading
import math
import operator
import bisect
from collections import defaultdict
from io import BytesIO, IOBase
sys.setrecursionlimit(10 ** 5)
#threading.stack_size(2**27)
"""def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)"""
"""def pw(a,b):
result=1
while(b>0):
if(b%2==1): result*=a
a*=a
b//=2
return result"""
def inpt():
return [int(k) for k in input().split()]
def main():
for _ in range(int(input())):
n=int(input())
ar=inpt()
count,toAdd,ans,prev=1,0,1,0
for i in range(n-1):
if(ar[i+1]>ar[i]):
toAdd+=1
else:
if(count==1):
ans+=1
prev=prev+toAdd
toAdd=0
count=prev
else:
count-=1
print(ans)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
#threading.Thread(target=main).start()
``` | instruction | 0 | 81,926 | 13 | 163,852 |
Yes | output | 1 | 81,926 | 13 | 163,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a tree which consisted of n vertices and was rooted at vertex 1. He decided to study BFS ([Breadth-first search](https://en.wikipedia.org/wiki/Breadth-first_search)), so he ran BFS on his tree, starting from the root. BFS can be described by the following pseudocode:
a = [] # the order in which vertices were processed
q = Queue()
q.put(1) # place the root at the end of the queue
while not q.empty():
k = q.pop() # retrieve the first vertex from the queue
a.append(k) # append k to the end of the sequence in which vertices were visited
for y in g[k]: # g[k] is the list of all children of vertex k, sorted in ascending order
q.put(y)
Monocarp was fascinated by BFS so much that, in the end, he lost his tree. Fortunately, he still has a sequence of vertices, in which order vertices were visited by the BFS algorithm (the array a from the pseudocode). Monocarp knows that each vertex was visited exactly once (since they were put and taken from the queue exactly once). Also, he knows that all children of each vertex were viewed in ascending order.
Monocarp knows that there are many trees (in the general case) with the same visiting order a, so he doesn't hope to restore his tree. Monocarp is okay with any tree that has minimum height.
The height of a tree is the maximum depth of the tree's vertices, and the depth of a vertex is the number of edges in the path from the root to it. For example, the depth of vertex 1 is 0, since it's the root, and the depth of all root's children are 1.
Help Monocarp to find any tree with given visiting order a and minimum height.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n; a_i ≠ a_j; a_1 = 1) — the order in which the vertices were visited by the BFS algorithm.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case print the minimum possible height of a tree with the given visiting order a.
Example
Input
3
4
1 4 3 2
2
1 2
3
1 2 3
Output
3
1
1
Note
In the first test case, there is only one tree with the given visiting order:
<image>
In the second test case, there is only one tree with the given visiting order as well:
<image>
In the third test case, an optimal tree with the given visiting order is shown below:
<image>
Submitted Solution:
```
from math import *
from bisect import *
from collections import *
from random import *
from decimal import *
from itertools import *
from heapq import *
import sys
input=sys.stdin.readline
def inp():
return int(input())
def st():
return input().rstrip('\n')
def lis():
return list(map(int,input().split()))
def ma():
return map(int,input().split())
t=inp()
while(t):
t-=1
n=inp()
a=lis()
if(n==1):
print(0)
continue
p=a[1]
co=0
v=[]
for i in range(1,n):
if(a[i]>=p):
p=a[i]
co+=1
continue
else:
if(co<=1):
v.append(0)
else:
v.append(co)
p=a[i]
co=1
if(co<=1):
v.append(0)
else:
v.append(co)
if(len(v)==1):
print(1)
continue
ss=v[0]
mh=1
j=1
while(1):
ss1=ss
ss=0
fl=0
for i in range(ss1):
if(j<len(v)):
fl=1
ss+=max(1,v[j])
j+=1
if(fl):
mh+=1
if(j>=len(v)):
break
if(ss1==0):
ss=v[j]
j+=1
mh+=1
print(mh)
``` | instruction | 0 | 81,927 | 13 | 163,854 |
Yes | output | 1 | 81,927 | 13 | 163,855 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.