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 |
|---|---|---|---|---|---|
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1 | instruction | 0 | 107,692 | 13 | 215,384 |
"Correct Solution:
```
# †全方位木DP†
import sys
input = lambda : sys.stdin.readline().strip()
n,m = map(int, input().split())
mod = m
G = [[] for i in range(n)]
for i in range(n-1):
a,b = map(int, input().split())
a,b = a-1,b-1
G[a].append(b)
G[b].append(a)
from collections import deque
def dfs(root):
que = deque()
que.append((root, -1))
order = []
while que:
cur,prev = que.popleft()
order.append(cur)
for to in G[cur]:
if to != prev:
que.append((to, cur))
return order
order = dfs(0)
child = set()
down = [1]*n
for cur in reversed(order):
tmp = 1
for to in G[cur]:
if to in child:
tmp *= (down[to]+1)
tmp %= mod
down[cur] = tmp
child.add(cur)
ans = [0]*n
que = deque()
que.append((0, -1, 1))
while que:
cur, prev, parent = que.popleft()
left = [1]
for to in G[cur]:
tmp = down[to]
if to == prev:
tmp = parent
left.append(left[-1]*(tmp+1)%mod)
right = [1]
for to in reversed(G[cur]):
tmp = down[to]
if to == prev:
tmp = parent
right.append(right[-1]*(tmp+1)%mod)
ans[cur] = left[-1]
m = len(G[cur])
for i, to in enumerate(G[cur]):
if to != prev:
que.append((to, cur, left[i]*right[m-i-1]))
print(*ans, sep="\n")
``` | output | 1 | 107,692 | 13 | 215,385 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1 | instruction | 0 | 107,693 | 13 | 215,386 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n, MOD = map(int,input().split())
if n == 1:
print(1)
return
E = [[] for _ in range(n)]
nv_to_idx = [{} for _ in range(n)]
for _ in range(n - 1):
u, v = map(int,input().split())
u -= 1; v -= 1
nv_to_idx[u][v] = len(E[u])
nv_to_idx[v][u] = len(E[v])
E[u].append(v)
E[v].append(u)
# topological sort
topological_sort = []
parent = [None] * n
stack = [(0, -1)]
while stack:
v, p = stack.pop()
parent[v] = p
topological_sort.append(v)
for nv in E[v]:
if nv == p:
continue
stack.append((nv, v))
topological_sort.reverse()
# tree DP
dp = [None] * n
for v in topological_sort:
res = 1
for nv in E[v]:
if nv == parent[v]:
continue
res = res * (dp[nv] + 1) % MOD
dp[v] = res
# rerooting
def rerooting(v, p):
# rerooting を先に済ませる
if p != -1 and v != -1:
idx = nv_to_idx[p][v]
p_res = 1
if idx > 0:
p_res *= cum_left[p][idx - 1]
if idx < len(E[p]) - 1:
p_res *= cum_right[p][idx + 1]
dp[p] = p_res % MOD
# monoid に対する cumulative sum を計算
if cum_left[v] is None:
left = [(dp[nv] + 1) % MOD for nv in E[v]]
right = [(dp[nv] + 1) % MOD for nv in E[v]]
k = len(E[v])
for i in range(k - 1):
left[i + 1] *= left[i]
left[i + 1] %= MOD
for i in range(k - 1, 0, -1):
right[i - 1] *= right[i]
right[i - 1] %= MOD
cum_left[v] = left
cum_right[v] = right
dp[v] = cum_left[v][-1]
ans = [None] * n
stack = [(~0, -1), (0, -1)]
cum_left = [None] * n
cum_right = [None] * n
while stack:
v, p = stack.pop()
if v >= 0:
rerooting(v, p)
ans[v] = dp[v]
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
rerooting(p, ~v)
print(*ans, sep = '\n')
resolve()
``` | output | 1 | 107,693 | 13 | 215,387 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
import sys
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[0] = -1
par[p] -1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
def topological_sort_tree(E, r):
Q = [r]
L = []
visited = set([r])
while Q:
vn = Q.pop()
L.append(vn)
for vf in E[vn]:
if vf not in visited:
visited.add(vf)
Q.append(vf)
return L
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N, M = map(int, input().split())
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, sys.stdin.readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
P = getpar(Edge, 0)
L = topological_sort_tree(Edge, 0)
C = getcld(P)
dp1 = [1]*N
for l in L[N-1:0:-1]:
p = P[l]
dp1[p] = (dp1[p]*(dp1[l]+1)) % M
dp2 = [1]*N
dp2[0] = dp1[0]
info = [0]*(N+1)
vidx = [0]*N
vmull = [None]*N
vmulr = [None]*N
for i in range(N):
Ci = C[i]
res = [1]
for j, c in enumerate(Ci, 1):
vidx[c] = j
res.append(res[-1] * (1+dp1[c]) % M)
vmulr[i] = res + [1]
res = [1]
for c in Ci[::-1]:
res.append(res[-1] * (1+dp1[c]) % M)
vmull[i] = [1] + res[::-1]
for l in L[1:]:
p = P[l]
pp = P[p]
vi = vidx[l]
res = vmulr[p][vi-1] * vmull[p][vi+1] % M
res = res*(1+info[pp]) % M
dp2[l] = dp1[l]*(res+1) % M
info[p] = res % M
print(*dp2, sep = '\n')
``` | instruction | 0 | 107,694 | 13 | 215,388 |
Yes | output | 1 | 107,694 | 13 | 215,389 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
INF = 10 ** 11
import sys
sys.setrecursionlimit(100000000)
N,M = map(int,input().split())
MOD = M
G = [[] for _ in range(N)]
for _ in range(N - 1):
x,y = map(int,input().split())
x -= 1
y -= 1
G[x].append(y)
G[y].append(x)
deg = [0] * N
dp = [None] * N
parents = [0] * N
ans = [0] * N
def dfs(v,p = -1):
deg[v] = len(G[v])
res = 1
dp[v] = [0] * deg[v]
for i,e in enumerate(G[v]):
if e == p:
parents[v] = i
continue
dp[v][i] = dfs(e,v)
res *= dp[v][i] + 1
res %= MOD
return res
def bfs(v,res_p = 0,p = -1):
if p != -1:
dp[v][parents[v]] = res_p
dpl = [1]*(deg[v] + 1)
dpr = [1]*(deg[v] + 1)
for i in range(deg[v]):
dpl[i + 1] = dpl[i]*(dp[v][i] + 1)%MOD
for i in range(deg[v] - 1,-1,-1):
dpr[i] = dpr[i + 1]*(dp[v][i] + 1)%MOD
ans[v] = dpr[0]
for i in range(deg[v]):
e = G[v][i]
if e == p:
continue
bfs(e,dpl[i]*dpr[i + 1]%MOD,v)
dfs(0)
bfs(0)
print('\n'.join(map(str,ans)))
``` | instruction | 0 | 107,695 | 13 | 215,390 |
Yes | output | 1 | 107,695 | 13 | 215,391 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
#!/usr/bin/env pypy3
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
#参考：https://qiita.com/Kiri8128/items/a011c90d25911bdb3ed3
#というかマルパクリ...
N,M=MI()
adj=[[]for _ in range(N)]
for i in range(N-1):
x,y=MI()
x-=1
y-=1
adj[x].append(y)
adj[y].append(x)
import queue
P=[-1]*N#親リスト
Q=queue.Queue()#BFSに使う
R=[]#BFSでトポソしたものを入れる
Q.put(0)#0を根とする
#トポソ########################
while not Q.empty():
v=Q.get()
R.append(v)
for nv in adj[v]:
if nv!=P[v]:
P[nv]=v
adj[nv].remove(v)#親につながるを消しておく
Q.put(nv)
#setting#############
#merge関数の単位元
unit=1
#子頂点を根とした木の結果をマージのための関数
merge=lambda a,b: (a*b)%M
#マージ後の調整用(bottom-up時)，今回，木の中の要素が全部白というパターンがあるので+1
adj_bu=lambda a,v:a+1
#マージ後の調整用(top-down時)
adj_td=lambda a,v,p:a+1
#マージ後の調整用(最終結果を求める時)，今回，全部白はダメなので，aをそのまま返す
adj_fin=lambda a,i:a
#今回の問題では，調整においてvやpは不要だが，必要な時もあるため，残している．
#Bottom-up#############
#merge関数を使ってMEを更新し，adjで調整してdpを埋める
#MEは親ノード以外の値を集約したようなもの
ME=[unit]*N
dp=[0]*N
for v in R[1:][::-1]:#根以外を後ろから
dp[v]=adj_bu(ME[v],v)#BU時の調整
p=P[v]
ME[p]=merge(ME[p],dp[v])#親に，子の情報を伝えている．ME[p]の初期値はunit
#print(v,p,dp[v],ME[p])
#最後だけ個別に考える
dp[R[0]]=adj_fin(ME[R[0]],R[0])
#print(ME)
#print(dp)
#Top-down##########
#TDは最終的に，Top-down時のdpを入れるが，途中においては左右累積和の左から累積させたものを入れておく
#メモリの省略のため
TD=[unit]*N
for v in R:
#左からDP（結果をTDに入れておく）
ac=TD[v]
for nv in adj[v]:
TD[nv]=ac
ac=merge(ac,dp[nv])
#右からDP(結果をacに入れて行きながら進めていく)
ac=unit
for nv in adj[v][::-1]:
TD[nv]=adj_td(merge(TD[nv],ac),nv,v)##TDときの調整
ac=merge(ac,dp[nv])
dp[nv]=adj_fin(merge(ME[nv],TD[nv]),nv)#最終調整
for i in range(N):
print(dp[i])
main()
``` | instruction | 0 | 107,696 | 13 | 215,392 |
Yes | output | 1 | 107,696 | 13 | 215,393 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
# -*- coding: utf-8 -*-
from collections import defaultdict
class ReRooting:
def __init__(self, f, g, merge, ie):
self.tree = defaultdict(list)
self.f = f
self.g = g
self.merge = merge
self.ie = ie
self.dp = defaultdict(dict)
def add_edge(self, u, v):
self.tree[u].append(v)
self.tree[v].append(u)
def __dfs1(self, u, p):
o = []
s = [(u, -1)]
while s:
u, p = s.pop()
o.append((u, p))
for v in self.tree[u]:
if v == p:
continue
s.append((v, u))
for u, p in reversed(o):
r = self.ie
for v in self.tree[u]:
if v == p:
continue
# ep(u_, v, self.dp)
r = self.merge(r, self.f(self.dp[u][v], v))
self.dp[p][u] = self.g(r, u)
def __dfs2(self, u, p, a):
s = [(u, p, a)]
while s:
u, p, a = s.pop()
self.dp[u][p] = a
pl = [0] * (len(self.tree[u]) + 1)
pl[0] = self.ie
for i, v in enumerate(self.tree[u]):
pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
pr = [0] * (len(self.tree[u]) + 1)
pr[-1] = self.ie
for i, v in reversed(list(enumerate(self.tree[u]))):
pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
for i, v in enumerate(self.tree[u]):
if v == p:
continue
r = self.merge(pl[i], pr[i+1])
s.append((v, u, self.g(r, v)))
# def __dfs1(self, u, p):
# r = self.ie
# for v in self.tree[u]:
# if v == p:
# continue
# self.dp[u][v] = self.__dfs1(v, u)
# r = self.merge(r, self.f(self.dp[u][v], v))
# return self.g(r, u)
# def __dfs2(self, u, p, a):
# for v in self.tree[u]:
# if v == p:
# self.dp[u][v] = a
# break
# pl = [0] * (len(self.tree[u]) + 1)
# pl[0] = self.ie
# for i, v in enumerate(self.tree[u]):
# pl[i+1] = self.merge(pl[i], self.f(self.dp[u][v], v))
# pr = [0] * (len(self.tree[u]) + 1)
# pr[-1] = self.ie
# for i, v in reversed(list(enumerate(self.tree[u]))):
# pr[i] = self.merge(pr[i+1], self.f(self.dp[u][v], v))
# for i, v in enumerate(self.tree[u]):
# if v == p:
# continue
# r = self.merge(pl[i], pr[i+1])
# self.__dfs2(v, u, self.g(r, v))
def build(self, root=1):
self.__dfs1(root, -1)
self.__dfs2(root, -1, self.ie)
def slv(self, u):
r = self.ie
for v in self.tree[u]:
r = self.merge(r, self.f(self.dp[u][v], v))
return self.g(r, u)
def atcoder_dp_dp_v():
# https://atcoder.jp/contests/dp/tasks/dp_v
N, M = map(int, input().split())
XY = [list(map(int, input().split())) for _ in range(N-1)]
f = lambda x, y: x
g = lambda x, y: x + 1
merge = lambda x, y: (x * y) % M
rr = ReRooting(f, g, merge, 1)
for x, y in XY:
rr.add_edge(x, y)
rr.build()
for u in range(1, N+1):
print(rr.slv(u)-1)
def atcoder_abc60_f():
N = int(input())
AB = [list(map(int, input().split())) for _ in range(N-1)]
M = 10**9+7
from functools import reduce
fact = [1]
for i in range(1, 10**6):
fact.append(fact[-1]*i % M)
def f(x, _):
c = x[0]
s = x[1]
c *= pow(fact[s], M-2, M)
c %= M
return (c, s)
def g(x, _):
c = x[0]
s = x[1]
c *= fact[s]
c %= M
return (c, s+1)
def merge(x, y):
return (x[0]*y[0]%M, x[1]+y[1])
rr = ReRooting(f, g, merge, (1, 0))
for a, b in AB:
rr.add_edge(a, b)
rr.build()
for u in range(1, N+1):
print(rr.slv(u)[0])
if __name__ == '__main__':
atcoder_dp_dp_v()
# atcoder_abc60_f()
``` | instruction | 0 | 107,697 | 13 | 215,394 |
Yes | output | 1 | 107,697 | 13 | 215,395 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
import sys
sys.setrecursionlimit(100000)
import queue
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(N-1):
x, y = map(int, input().split())
G[x-1].append(y-1)
G[y-1].append(x-1)
dp = {}
def rec(p, v):
C = set(G[v]) - set([p])
if len(C) == 0:
dp[(p, v)] = 1
return 1
res = 1
for u in C:
res *= (1+rec(v, u))
dp[(p, v)] = res
return dp[(p, v)]
r = 0
rec(-1, r)
q = queue.Queue()
q.put(r)
ans = [0]*N
ans[r] = dp[(-1, r)]
while not q.empty():
p = q.get()
for v in G[p]:
if ans[v] > 0: continue
ans[v] = int(dp[(p, v)]*(ans[p]/(1+dp[(p, v)])+1)) % M
q.put(v)
for a in ans:
print(a)
``` | instruction | 0 | 107,698 | 13 | 215,396 |
No | output | 1 | 107,698 | 13 | 215,397 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
N,mod=map(int,input().split())
EDGE=[list(map(int,input().split())) for i in range(N-1)]
#N=10**5
#mod=10**8
#import random
#EDGE=[[i,random.randint(1,i-1)] for i in range(2,N+1)]
EDGELIST=[[] for i in range(N+1)]
DPDICT=dict()
for x,y in EDGE:
EDGELIST[x].append(y)
EDGELIST[y].append(x)
for i in range(1,N+1):
if len(EDGELIST)==1:
DPDICT[(i,EDGELIST[i][0])]=2
def SCORE(point):
ANS=1
for to in EDGELIST[point]:
ANS=ANS*dp(to,point)%mod
return ANS
def dp(x,y):
if DPDICT.get((x,y))!=None:
return DPDICT[(x,y)]
ANS=1
for to in EDGELIST[x]:
if to==y:
continue
ANS=ANS*dp(to,x)%mod
DPDICT[(x,y)]=ANS+1
return ANS+1
for i in range(1,N+1):
print(SCORE(i))
``` | instruction | 0 | 107,699 | 13 | 215,398 |
No | output | 1 | 107,699 | 13 | 215,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
import sys,os,io
input = sys.stdin.readline
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
parent[start] = -1
while stack:
v = stack[-1]
marker = 0
for u in edge[v]:
if u==parent[v]:
continue
if parent[u]==N: #子へ降ろす
marker = 1
parent[u]=v
stack.append(u)
else: #子から吸い上げる
ans[v] *= ans[u]+1
if marker==0:
stack.pop()
ans[v]%=M
return
def dfs2(start):
stack = [start]
parent = [N]*N
parent[start] = -1
p_value = [0]*N
while stack:
v = stack.pop()
cum1 = [1]*(len(edge[v])+1)
cum2 = [1]*(len(edge[v])+1)
for i,u in enumerate(edge[v]):
if u==parent[v]:
cum1[i+1] = cum1[i]*(p_value[v]+1)
else:
cum1[i+1] = cum1[i]*(ans[u]+1)
cum1[i+1] %= M
for i,u in enumerate(edge[v][::-1]):
if u==parent[v]:
cum2[-i-2] = cum2[-i-1]*(p_value[v]+1)
else:
cum2[-i-2] = cum2[-i-1]*(ans[u]+1)
cum2[i+1]%=M
for i,u in enumerate(edge[v]):
if u==parent[v]:
continue
parent[u]=v
p_value[u] = cum1[i]*cum2[i+1]%M
ans[u] *= (p_value[u]+1)
ans[u] %= M
stack.append(u)
ans[v] %= M
return
ans = [1]*N
dfs(0)
dfs2(0)
print(*ans, sep='\n')
``` | instruction | 0 | 107,700 | 13 | 215,400 |
No | output | 1 | 107,700 | 13 | 215,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a tree with N vertices, numbered 1, 2, \ldots, N. For each i (1 \leq i \leq N - 1), the i-th edge connects Vertex x_i and y_i.
Taro has decided to paint each vertex in white or black, so that any black vertex can be reached from any other black vertex by passing through only black vertices.
You are given a positive integer M. For each v (1 \leq v \leq N), answer the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^5
* 2 \leq M \leq 10^9
* 1 \leq x_i, y_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N M
x_1 y_1
x_2 y_2
:
x_{N - 1} y_{N - 1}
Output
Print N lines. The v-th (1 \leq v \leq N) line should contain the answer to the following question:
* Assuming that Vertex v has to be black, find the number of ways in which the vertices can be painted, modulo M.
Examples
Input
3 100
1 2
2 3
Output
3
4
3
Input
4 100
1 2
1 3
1 4
Output
8
5
5
5
Input
1 100
Output
1
Input
10 2
8 5
10 8
6 5
1 5
4 8
2 10
3 6
9 2
1 7
Output
0
0
1
1
1
0
1
0
1
1
Submitted Solution:
```
import itertools
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N,MOD = map(int,input().split())
if N == 1:
print(1)
exit()
graph = [[] for _ in range(N+1)]
for _ in range(N-1):
x,y = map(int,input().split())
graph[x].append(y)
graph[y].append(x)
def dfs_1(v=1,parent=None):
# 子ごとに、そこを黒くして適切 or 完全白
# dp_1 + 1 の積
x = 1
for w in graph[v]:
if w == parent:
continue
x *= (dfs_1(w,v) + 1)
dp_1[v] = x
return x
dp_1 = [0] * (N+1) # 自分を黒く塗って、子側の部分木を適切に塗る方法
dfs_1()
def make_products(arr):
# 左右からの積を作る方法
f = lambda x,y: x*y%MOD
L = [1] + list(itertools.accumulate(arr[:-1], f))
R = list(itertools.accumulate(arr[::-1][:-1], f))[::-1] + [1]
return [f(x,y) for x,y in zip(L,R)]
def dfs_2(v=1,parent=None,x=1):
# それぞれの子以外の情報をマージして、子に渡さなければいけない
arr = [1 + dp_1[w] if w != parent else x for w in graph[v]]
products = make_products(arr)
dp[v] = arr[0] * products[0] % MOD
for w,p in zip(graph[v],products):
if w==parent:
continue
dfs_2(w,v,p+1)
dp = [0] * (N+1)
dfs_2()
print('\n'.join(map(str,dp[1:])))
``` | instruction | 0 | 107,701 | 13 | 215,402 |
No | output | 1 | 107,701 | 13 | 215,403 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,734 | 13 | 215,468 |
"Correct Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
#非再帰
def scc(Edge):
N = len(Edge)
Edgeinv = [[] for _ in range(N)]
for vn in range(N):
for vf in Edge[vn]:
Edgeinv[vf].append(vn)
used = [False]*N
dim = [len(Edge[i]) for i in range(N)]
order = []
for st in range(N):
if not used[st]:
stack = [st, 0]
while stack:
vn, i = stack[-2], stack[-1]
if not i and used[vn]:
stack.pop()
stack.pop()
else:
used[vn] = True
if i < dim[vn]:
stack[-1] += 1
stack.append(Edge[vn][i])
stack.append(0)
else:
stack.pop()
order.append(stack.pop())
res = [None]*N
used = [False]*N
cnt = -1
for st in order[::-1]:
if not used[st]:
cnt += 1
stack = [st]
res[st] = cnt
used[st] = True
while stack:
vn = stack.pop()
for vf in Edgeinv[vn]:
if not used[vf]:
used[vf] = True
res[vf] = cnt
stack.append(vf)
M = cnt+1
components = [[] for _ in range(M)]
for i in range(N):
components[res[i]].append(i)
tEdge = [[] for _ in range(M)]
teset = set()
for vn in range(N):
tn = res[vn]
for vf in Edge[vn]:
tf = res[vf]
if tn != tf and tn*M + tf not in teset:
teset.add(tn*M + tf)
tEdge[tn].append(tf)
return res, components, tEdge
N = int(readline())
P = list(map(lambda x: int(x)-1, readline().split()))
Edge = [[] for _ in range(N)]
for i in range(N):
Edge[P[i]].append(i)
R, Com, _ = scc(Edge)
Lord = list(chain(*Com[::-1]))
val = [None]*N
for vn in Lord:
if not R[vn]:
break
lvn = len(Edge[vn]) + 1
res = [0]*lvn
for vf in Edge[vn]:
if val[vf] < lvn:
res[val[vf]] += 1
for k in range(lvn):
if not res[k]:
val[vn] = k
break
st = Lord[-1]
lst = len(Edge[st]) + 2
res = [0]*lst
for vf in Edge[st]:
if val[vf] is None:
continue
if val[vf] < lst:
res[val[vf]] += 1
mc = []
for k in range(lst):
if not res[k]:
mc.append(k)
vn = st
Ls = []
while vn is not None:
for vf in Edge[vn]:
if R[vf]:
continue
if vf == st:
vn = None
else:
Ls.append(vf)
vn = vf
Ls.reverse()
ans = False
for idx in range(2):
vc = val[:]
vc[st] = mc[idx]
for vn in Ls:
lvn = len(Edge[vn])+1
res = [0]*lvn
for vf in Edge[vn]:
if vc[vf] < lvn:
res[vc[vf]] += 1
for k in range(lvn):
if not res[k]:
vc[vn] = k
break
for vn in range(N):
res = [False]*vc[vn]
for vf in Edge[vn]:
if vc[vn] == vc[vf]:
break
if vc[vf] < vc[vn]:
res[vc[vf]] = True
else:
if not all(res):
break
continue
break
else:
ans = True
if ans:
break
print('POSSIBLE' if ans else 'IMPOSSIBLE')
``` | output | 1 | 107,734 | 13 | 215,469 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,735 | 13 | 215,470 |
"Correct Solution:
```
from collections import deque
N=int(input())
IN=[[] for i in range(N)]
OUT=[-1 for i in range(N)]
p=list(map(int,input().split()))
for i in range(N):
IN[p[i]-1].append(i)
OUT[i]=p[i]-1
deg=[len(IN[i]) for i in range(N)]
deq=deque([v for v in range(N) if deg[v]==0])
res=[]
while deq:
v=deq.popleft()
res.append(v)
deg[OUT[v]]-=1
if deg[OUT[v]]==0:
deq.append(OUT[v])
if len(res)==N:
print("POSSIBLE")
exit()
start=-1
for i in range(N):
if deg[i]>0:
start=i
break
cycle=[start]
while True:
nv=OUT[cycle[-1]]
if nv!=start:
cycle.append(nv)
else:
break
dp=[-1]*N
for v in res:
mex=[False]*(len(IN[v])+1)
for pv in IN[v]:
if dp[pv]<=len(IN[v]):
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
dp[v]=i
break
m0=-1
m1=-1
mex=[False]*(len(IN[start])+2)
for pv in IN[start]:
if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
if m0==-1:
m0=i
else:
m1=i
break
#m0
dp[start]=m0
for i in range(1,len(cycle)):
v=cycle[i]
temp=-1
mex=[False]*(len(IN[v])+1)
for pv in IN[v]:
if dp[pv]<=len(IN[v]):
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
dp[v]=i
break
mex=[False]*(len(IN[start])+2)
for pv in IN[start]:
if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:
mex[dp[pv]]=True
check=-1
for i in range(len(mex)):
if not mex[i]:
check=i
break
if check==m0:
print("POSSIBLE")
exit()
for v in cycle:
dp[v]=-1
#m1
dp[start]=m1
for i in range(1,len(cycle)):
v=cycle[i]
temp=-1
mex=[False]*(len(IN[v])+1)
for pv in IN[v]:
if dp[pv]<=len(IN[v]):
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
dp[v]=i
break
mex=[False]*(len(IN[start])+2)
for pv in IN[start]:
if dp[pv]!=-1 and dp[pv]<=len(IN[start])+1:
mex[dp[pv]]=True
check=-1
for i in range(len(mex)):
if not mex[i]:
check=i
break
if check==m1:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
``` | output | 1 | 107,735 | 13 | 215,471 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,736 | 13 | 215,472 |
"Correct Solution:
```
from collections import defaultdict
import heapq as hq
def helper(n):
q = child_L[n]
del child_L[n]
hq.heapify(q)
i = 0
while q:
t = hq.heappop(q)
if i < t:
break
else:
i += (i == t)
j = i + 1
while q:
t = hq.heappop(q)
if j < t:
break
else:
j += (j == t)
return (i, j)
if __name__ == '__main__':
N = int(input())
P = list(map(lambda x: int(x) - 1, input().split()))
# D:出している辺の本数
D = [0] * N
for p in P:
D[p] += 1
# print(D)
child_L = defaultdict(list)
# S:辺を出してないものリスト
S = [p for p in range(N) if D[p] == 0]
L = [None] * N
while S:
# print(child_L)
n = S.pop()
q = child_L[n]
# print(q)
del child_L[n]
# listのqをヒープキューに変換
hq.heapify(q)
i = 0
while q:
t = hq.heappop(q)
if i < t:
break
else:
i += (i == t)
L[n] = i
# print(L)
m = P[n]
# print("m:" + str(m))
child_L[m].append(i)
D[m] -= 1
if D[m] == 0:
S.append(m)
# print(D)
# cycle check
try:
start = D.index(1)
except ValueError:
print('POSSIBLE')
exit()
s1, s2 = helper(start)
G = []
n = P[start]
while n != start:
G.append(helper(n))
n = P[n]
# del N, P, D, child_L, S, L
# 可能な初期値をそれぞれシミュレート
# 1
n = s1
for g in G:
if g[0] == n:
n = g[1]
else:
n = g[0]
if n != s1:
print('POSSIBLE')
exit()
# 2
n = s2
for g in G:
if g[0] == n:
n = g[1]
else:
n = g[0]
if n == s1:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
``` | output | 1 | 107,736 | 13 | 215,473 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,737 | 13 | 215,474 |
"Correct Solution:
```
# 結局は木+1辺
from collections import defaultdict
import heapq as hq
N = int(input())
P = list(map(lambda x:int(x)-1,input().split()))
D = [0]*N
for p in P:
D[p] += 1
child_L = defaultdict(list)
S = [p for p in range(N) if D[p] == 0]
L = [None]*N
while S:
n = S.pop()
q = child_L[n]
del child_L[n]
hq.heapify(q)
i = 0
while q:
t = hq.heappop(q)
if i < t:
break
else:
i += (i==t)
L[n] = i
m = P[n]
child_L[m].append(i)
D[m] -= 1
if D[m] == 0:
S.append(m)
# cycle check
try:
start = D.index(1)
except ValueError:
print('POSSIBLE')
exit()
def helper(n):
q = child_L[n]
del child_L[n]
hq.heapify(q)
i = 0
while q:
t = hq.heappop(q)
if i < t:
break
else:
i += (i==t)
j = i+1
while q:
t = hq.heappop(q)
if j < t:
break
else:
j += (j==t)
return (i,j)
s1,s2 = helper(start)
G = []
n = P[start]
while n != start:
G.append(helper(n))
n = P[n]
del N,P,D,child_L,S,L
# 可能な初期値をそれぞれシミュレート
# 1
n = s1
for g in G:
if g[0] == n:
n = g[1]
else:
n = g[0]
if n != s1:
print('POSSIBLE')
exit()
# 2
n = s2
for g in G:
if g[0] == n:
n = g[1]
else:
n = g[0]
if n == s1:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
``` | output | 1 | 107,737 | 13 | 215,475 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,738 | 13 | 215,476 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
"""
・pseudo-tree graph
・in_deg = 1が保証されているので、向きの揃ったcycleがある
・1箇所の2択を決めれば全部決まる
"""
N = int(readline())
parent = [0] + list(map(int,read().split()))
child = [[] for _ in range(N+1)]
for i,x in enumerate(parent):
child[x].append(i)
out_deg = [len(x) for x in child]
out_deg
G = [-1] * (N+1)
# とりあえず唯一のサイクル以外を処理：out_deg=0の頂点を捨てていく
stack = [i for i,x in enumerate(out_deg) if not x]
while stack:
x = stack.pop()
se = set(G[c] for c in child[x])
g = 0
while g in se:
g += 1
G[x] = g
p = parent[x]
out_deg[p] -= 1
if not out_deg[p]:
stack.append(p)
"""
・grundy数の候補は2種。
・片方決め打って計算。2周grundy数を計算してstableになっていればよい。
"""
for i,x in enumerate(out_deg[1:],1):
if x==1:
root = i
break
cycle_len = sum(out_deg[1:])
is_stable = False
x = root
for _ in range(cycle_len*2+10):
se = set(G[c] for c in child[x])
g = 0
while g in se:
g += 1
if g == G[x]:
is_stable = True
break
G[x] = g
x = parent[x]
answer = 'POSSIBLE' if is_stable else 'IMPOSSIBLE'
print(answer)
``` | output | 1 | 107,738 | 13 | 215,477 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE | instruction | 0 | 107,739 | 13 | 215,478 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**6)
n = int(input())
p = list(map(int, input().split()))
c = [[] for _ in range(n)]
is_leaf = [True for _ in range(n)]
for i in range(n):
p[i] -= 1
c[p[i]].append(i)
is_leaf[p[i]] = False
if sum(is_leaf) == 0:
if n%2 == 0:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
sys.exit()
for i in range(n):
if is_leaf[i]:
cur = i
break
visited_set = {cur}
visited_list = [cur]
while p[cur] not in visited_set:
visited_list.append(p[cur])
visited_set.add(p[cur])
cur = p[cur]
root = p[cur]
grundy = [-1 for _ in range(n)]
g_set = [set() for _ in range(n)]
def dfs(x):
res = 0
for v in c[x]:
dfs(v)
g_set[x].add(grundy[v])
while res in g_set[x]:
res += 1
grundy[x] = res
return res
loop = [False for _ in range(n)]
loop[root] = True
ind = len(visited_list)-1
while visited_list[ind] != root:
loop[visited_list[ind]] = True
ind -= 1
#print(loop)
for i in range(n):
if loop[i]:
for x in c[i]:
if not loop[x]:
dfs(x)
g_set[i].add(grundy[x])
cand = []
num = 0
while num in g_set[root]:
num += 1
cand.append(num)
num += 1
while num in g_set[root]:
num += 1
cand.append(num)
for x in cand:
cur = root
grundy[root] = x
while True:
num = 0
while num in g_set[p[cur]] or num == grundy[cur]:
num += 1
grundy[p[cur]] = num
if p[cur] == root:
break
cur = p[cur]
if grundy[root] == x:
#print(grundy)
print("POSSIBLE")
sys.exit()
print("IMPOSSIBLE")
``` | output | 1 | 107,739 | 13 | 215,479 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE
Submitted Solution:
```
from collections import deque
N=int(input())
IN=[[] for i in range(N)]
OUT=[-1 for i in range(N)]
p=list(map(int,input().split()))
for i in range(N):
IN[p[i]-1].append(i)
OUT[i]=p[i]-1
deg=[len(IN[i]) for i in range(N)]
deq=deque([v for v in range(N) if deg[v]==0])
res=[]
while deq:
v=deq.popleft()
res.append(v)
deg[OUT[v]]-=1
if deg[OUT[v]]==0:
deq.append(OUT[v])
if len(res)==N:
exit(print("POSSIBLE"))
start=-1
for i in range(N):
if deg[i]>0:
start=i
break
cycle=[start]
while True:
nv=OUT[cycle[-1]]
if nv!=start:
cycle.append(nv)
else:
break
dp=[-1]*N
for v in res:
mex=[False]*(len(IN[v])+1)
for pv in IN[v]:
if dp[pv]<=len(IN[v]):
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
dp[v]=i
break
m0=-1
m1=-1
mex=[False]*(len(IN[start])+2)
for pv in IN[start]:
if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
if m0==-1:
m0=i
else:
m1=i
break
#m0
dp[start]=m0
for i in range(1,len(cycle)):
v=cycle[i]
temp=-1
mex=[False]*(len(IN[v])+1)
for pv in IN[v]:
if dp[pv]<=len(IN[v]):
mex[dp[pv]]=True
for i in range(len(mex)):
if not mex[i]:
dp[v]=i
break
mex=[False]*(len(IN[start])+2)
for pv in IN[start]:
if dp[pv]!=-1 and dp[pv]<=len(IN[v])+1:
mex[dp[pv]]=True
check=-1
for i in range(len(mex)):
if not mex[i]:
check=i
break
if i==m0:
exit(print("POSSIBLE"))
``` | instruction | 0 | 107,740 | 13 | 215,480 |
No | output | 1 | 107,740 | 13 | 215,481 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE
Submitted Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
#非再帰
def scc(Edge):
N = len(Edge)
Edgeinv = [[] for _ in range(N)]
for vn in range(N):
for vf in Edge[vn]:
Edgeinv[vf].append(vn)
used = [False]*N
dim = [len(Edge[i]) for i in range(N)]
order = []
for st in range(N):
if not used[st]:
stack = [st, 0]
while stack:
vn, i = stack[-2], stack[-1]
if not i and used[vn]:
stack.pop()
stack.pop()
else:
used[vn] = True
if i < dim[vn]:
stack[-1] += 1
stack.append(Edge[vn][i])
stack.append(0)
else:
stack.pop()
order.append(stack.pop())
res = [None]*N
used = [False]*N
cnt = -1
for st in order[::-1]:
if not used[st]:
cnt += 1
stack = [st]
res[st] = cnt
used[st] = True
while stack:
vn = stack.pop()
for vf in Edgeinv[vn]:
if not used[vf]:
used[vf] = True
res[vf] = cnt
stack.append(vf)
M = cnt+1
components = [[] for _ in range(M)]
for i in range(N):
components[res[i]].append(i)
tEdge = [[] for _ in range(M)]
teset = set()
for vn in range(N):
tn = res[vn]
for vf in Edge[vn]:
tf = res[vf]
if tn != tf and tn*M + tf not in teset:
teset.add(tn*M + tf)
tEdge[tn].append(tf)
return res, components, tEdge
N = int(readline())
P = list(map(lambda x: int(x)-1, readline().split()))
Edge = [[] for _ in range(N)]
for i in range(N):
Edge[P[i]].append(i)
R, Com, _ = scc(Edge)
Lord = list(chain(*Com[::-1]))
val = [None]*N
for vn in Lord:
if not R[vn]:
break
lvn = len(Edge[vn]) + 1
res = [0]*lvn
for vf in Edge[vn]:
if val[vf] < lvn:
res[val[vf]] += 1
for k in range(lvn):
if not res[k]:
val[vn] = k
break
st = Lord[-1]
lst = len(Edge[st]) + 2
res = [0]*lst
for vf in Edge[st]:
if val[vf] is None:
continue
if val[vf] < lst:
res[val[vf]] += 1
mc = []
for k in range(lst):
if not res[k]:
mc.append(k)
vn = st
Ls = []
while vn is not None:
for vf in Edge[vn]:
if R[vf]:
continue
if vf == st:
vn = None
else:
Ls.append(vf)
vn = vf
Ls.reverse()
ans = False
for idx in range(2):
vc = val[:]
vc[st] = mc[idx]
for vn in Ls:
lvn = len(Edge[vn])+1
res = [0]*lvn
for vf in Edge[vn]:
if vc[vf] < lvn:
res[vc[vf]] += 1
for k in range(lvn):
if not res[k]:
vc[vn] = k
break
for vn in range(N):
assert vc[vn] is not None, 'Er'
for vf in Edge[vn]:
if vc[vn] == vc[vf]:
break
else:
continue
break
else:
ans = True
break
print('POSSIBLE' if ans else 'IMPOSSIBLE')
``` | instruction | 0 | 107,741 | 13 | 215,482 |
No | output | 1 | 107,741 | 13 | 215,483 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE
Submitted Solution:
```
# coding: utf-8
from collections import defaultdict
def II(): return int(input())
def ILI(): return list(map(int, input().split()))
def read():
N = II()
p = ILI()
return N, p
def solve(N, p):
ans = None
edges = defaultdict(list)
for i in range(N):
edges[p[i]].append(i + 1)
nodes_has_branch = []
for i in range(1, N + 1):
if len(edges[i]) == 2:
nodes_has_branch.append(i)
if len(nodes_has_branch) == 0:
if N % 2 == 0:
ans = "POSSIBLE"
else:
ans = "IMPOSSIBLE"
else:
first_node = nodes_has_branch[0]
edges_reverse = defaultdict(list)
for fro, to in edges.items():
for i in to:
edges_reverse[i].append(fro)
circles = []
next_node = edges_reverse[first_node]
while True:
if next_node[0] == first_node:
break
circles.append(next_node[0])
next_node = edges_reverse[next_node[0]]
circles = [first_node] + list(reversed(circles))
s_circles = set(circles)
s_branch = set(range(1, N + 1)) - s_circles
circles_depth = [0] * len(circles)
for i, node in enumerate(circles):
next_node = edges[node]
if len(next_node) == 1:
continue
else:
next_node = list((set(next_node) & s_branch))[0]
while True:
circles_depth[i] += 1
next_node = edges[next_node]
if len(next_node) == 0:
break
if not 0 in circles_depth:
ans = "IMPOSSIBLE"
else:
ans = "POSSIBLE"
return ans
def main():
params = read()
print(solve(*params))
if __name__ == "__main__":
main()
``` | instruction | 0 | 107,742 | 13 | 215,484 |
No | output | 1 | 107,742 | 13 | 215,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and N edges. The vertices are numbered 1, 2, ..., N.
The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and the graph is weakly connected. Here, an edge from Vertex u to Vertex v is denoted by (u, v), and a weakly connected graph is a graph which would be connected if each edge was bidirectional.
We would like to assign a value to each of the vertices in this graph so that the following conditions are satisfied. Here, a_i is the value assigned to Vertex i.
* Each a_i is a non-negative integer.
* For each edge (i, j), a_i \neq a_j holds.
* For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
Determine whether there exists such an assignment.
Constraints
* 2 ≤ N ≤ 200 000
* 1 ≤ p_i ≤ N
* p_i \neq i
* The graph is weakly connected.
Input
Input is given from Standard Input in the following format:
N
p_1 p_2 ... p_N
Output
If the assignment is possible, print `POSSIBLE`; otherwise, print `IMPOSSIBLE`.
Examples
Input
4
2 3 4 1
Output
POSSIBLE
Input
3
2 3 1
Output
IMPOSSIBLE
Input
4
2 3 1 1
Output
POSSIBLE
Input
6
4 5 6 5 6 4
Output
IMPOSSIBLE
Submitted Solution:
```
import sys
from itertools import chain
readline = sys.stdin.readline
#非再帰
def scc(Edge):
N = len(Edge)
Edgeinv = [[] for _ in range(N)]
for vn in range(N):
for vf in Edge[vn]:
Edgeinv[vf].append(vn)
used = [False]*N
dim = [len(Edge[i]) for i in range(N)]
order = []
for st in range(N):
if not used[st]:
stack = [st, 0]
while stack:
vn, i = stack[-2], stack[-1]
if not i and used[vn]:
stack.pop()
stack.pop()
else:
used[vn] = True
if i < dim[vn]:
stack[-1] += 1
stack.append(Edge[vn][i])
stack.append(0)
else:
stack.pop()
order.append(stack.pop())
res = [None]*N
used = [False]*N
cnt = -1
for st in order[::-1]:
if not used[st]:
cnt += 1
stack = [st]
res[st] = cnt
used[st] = True
while stack:
vn = stack.pop()
for vf in Edgeinv[vn]:
if not used[vf]:
used[vf] = True
res[vf] = cnt
stack.append(vf)
M = cnt+1
components = [[] for _ in range(M)]
for i in range(N):
components[res[i]].append(i)
tEdge = [[] for _ in range(M)]
teset = set()
for vn in range(N):
tn = res[vn]
for vf in Edge[vn]:
tf = res[vf]
if tn != tf and tn*M + tf not in teset:
teset.add(tn*M + tf)
tEdge[tn].append(tf)
return res, components, tEdge
N = int(readline())
P = list(map(lambda x: int(x)-1, readline().split()))
Edge = [[] for _ in range(N)]
for i in range(N):
Edge[P[i]].append(i)
R, Com, _ = scc(Edge)
assert len(Com[0]) > 1 ,''
Lord = list(chain(*Com[::-1]))
val = [None]*N
for vn in Lord:
if not R[vn]:
break
lvn = len(Edge[vn]) + 1
res = [0]*lvn
for vf in Edge[vn]:
if val[vf] < lvn:
res[val[vf]] += 1
for k in range(lvn):
if not res[k]:
val[vn] = k
break
st = Lord[-1]
lst = len(Edge[st]) + 2
res = [0]*lst
for vf in Edge[st]:
if val[vf] is None:
continue
if val[vf] < lst:
res[val[vf]] += 1
mc = []
for k in range(lst):
if not res[k]:
mc.append(k)
vn = st
Ls = []
while vn is not None:
for vf in Edge[vn]:
if R[vf]:
continue
if vf == st:
vn = None
else:
Ls.append(vf)
vn = vf
Ls.reverse()
ans = False
for idx in range(2):
vc = val[:]
vc[st] = mc[idx]
for vn in Ls:
lvn = len(Edge[vn])+1
res = [0]*lvn
for vf in Edge[vn]:
if vc[vf] < lvn:
res[vc[vf]] += 1
for k in range(lvn):
if not res[k]:
vc[vn] = k
break
for vn in range(N):
for vf in Edge[vn]:
if vc[vn] == vc[vf]:
break
else:
continue
break
else:
ans = True
break
print('POSSIBLE' if ans else 'IMPOSSIBLE')
``` | instruction | 0 | 107,743 | 13 | 215,486 |
No | output | 1 | 107,743 | 13 | 215,487 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,830 | 13 | 215,660 |
"Correct Solution:
```
class Node():
def __init__(self, id, key):
self.id = id
self.key = key
def setKeys(self, data):
length = len(data)
if ( self.id // 2 ) != 0:
self.pk = data[self.id // 2]
else :
self.pk = -1
if self.id * 2 < length:
self.lk = data[self.id * 2]
else :
self.lk = -1
if self.id * 2 + 1 < length:
self.rk = data[self.id * 2 + 1]
else :
self.rk = -1
def printInfo(self):
print( "node " + str(self.id) + ": key = " + str(self.key), end=", " )
if self.pk != -1:
print( "parent key = " + str(self.pk), end = ", ")
if self.lk != -1:
print( "left key = " + str(self.lk), end = ", ")
if self.rk != -1:
print( "right key = " + str(self.rk) , end=", ")
print()
def main():
n = int( input() )
inputs = input().split()
for tmp in inputs:
tmp = int(tmp)
data = [0]
data.extend(inputs)
Tree = []
for i in range(1, n+1):
Tree.append( Node(i, data[i]) )
for node in Tree:
node.setKeys( data )
node.printInfo()
if __name__ == '__main__':
main()
``` | output | 1 | 107,830 | 13 | 215,661 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,831 | 13 | 215,662 |
"Correct Solution:
```
H = int(input())
last_index = H + 1
keys = [None] + list(map(int, input().split()))
for i in range(1, last_index):
print('node {0}: '.format(i), end = '')
print('key = {0}, '.format(keys[i]), end = '')
if i != 1:
print('parent key = {0}, '.format(keys[i // 2]), end = '')
left_index = i * 2
if left_index < last_index:
print('left key = {0}, '.format(keys[left_index]), end = '')
right_index = left_index + 1
if right_index < last_index:
print('right key = {0}, '.format(keys[right_index]), end = '')
print('')
``` | output | 1 | 107,831 | 13 | 215,663 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,832 | 13 | 215,664 |
"Correct Solution:
```
def parent_id(id, H):
if 1 <= id // 2 and id // 2 <= H:
return id// 2
return None
def left_id(id, H):
if 1 <= id *2 and id * 2 <= H:
return id* 2
return None
def right_id(id, H):
if 1 <= (id * 2) + 1 and (id * 2) + 1 <= H:
return (id * 2) + 1
return None
H = int(input())
A = list(map(int, input().split()))
T = [{} for _ in range(H)]
for i in range(H):
T[i]["id"] = i + 1
T[i]["key"] = A[i]
T[i]["parent_id"] = parent_id(T[i]["id"], H)
T[i]["left_id"] = left_id(T[i]["id"], H)
T[i]["right_id"] = right_id(T[i]["id"], H)
for i in range(H):
parent_str, left_str, right_str = "", "", ""
node_str = "node {}: ".format(T[i]["id"])
key_str = "key = {}, ".format(T[i]["key"])
if T[i]["parent_id"] != None:
parent_str = "parent key = {}, ".format(T[int(T[i]["parent_id"])-1]["key"])
if T[i]["left_id"] != None:
left_str = "left key = {}, ".format(T[int(T[i]["left_id"])-1]["key"])
if T[i]["right_id"] != None:
right_str = "right key = {}, ".format(T[int(T[i]["right_id"])-1]["key"])
print(node_str + key_str + parent_str + left_str + right_str)
``` | output | 1 | 107,832 | 13 | 215,665 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,833 | 13 | 215,666 |
"Correct Solution:
```
N = int(input())
*A, = map(int, input().split())
for i in range(N):
R = ["node %d: key = %d," % (i+1, A[i])]
l = 2*i+1; r = 2*i+2
if i:
R.append("parent key = %d," % A[(i-1)//2])
if l < N:
R.append("left key = %d," % A[l])
if r < N:
R.append("right key = %d," % A[r])
print(*R, "")
``` | output | 1 | 107,833 | 13 | 215,667 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,834 | 13 | 215,668 |
"Correct Solution:
```
from math import ceil
N = int(input())
H = list(map(int, input().split()))
for i in range(len(H)):
res = "node {}: key = {}, ".format(i+1, H[i])
parent = ceil(i/2) - 1
left = 2*i + 1
right = 2*i + 2
if parent >= 0:
res += "parent key = {}, ".format(H[parent])
if left < N:
res += "left key = {}, ".format(H[left])
if right < N:
res += "right key = {}, ".format(H[right])
print(res)
``` | output | 1 | 107,834 | 13 | 215,669 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,835 | 13 | 215,670 |
"Correct Solution:
```
#! /usr/bin/env python
def print_heap (heap, i):
ret = "node {0}: key = {1}, ".format(i + 1, heap[i])
p = get_parent_node(i)
if p is not None:
ret += "parent key = {0}, ".format(heap[p])
len_heap = len(heap)
l = get_left_node(i)
r = get_right_node(i)
if l < len_heap:
ret += "left key = {0}, ".format(heap[l])
if r < len_heap:
ret += "right key = {0}, ".format(heap[r])
print(ret)
return
def get_parent_node (i):
p = (i - 1) // 2
if p < 0:
return None
else:
return p
def get_left_node (i):
l = (i + 1) * 2 - 1
return l
def get_right_node (i):
r = (i + 1) * 2
return r
def proc_inputs ():
num_inputs = int(input())
inputs = [i for i in input().split()]
return num_inputs, inputs
def main ():
num_inputs, inputs = proc_inputs()
heap = [None] * num_inputs
for i, node in enumerate(inputs):
heap[i] = node
for i, node in enumerate(inputs):
print_heap(heap, i)
# print(heap)
exit(0)
if __name__ == "__main__":
main()
``` | output | 1 | 107,835 | 13 | 215,671 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,836 | 13 | 215,672 |
"Correct Solution:
```
if __name__ == '__main__':
N = input()
heap_array = [int(i) for i in input().split()]
for i in range(len(heap_array)):
print("node {}: key = {}, ".format(i+1, heap_array[i]), end='')
if (i-1)//2 != -1 :
print("parent key = {}, ".format(heap_array[(i-1)//2]), end='')
if 2*i+1 < len(heap_array):
print("left key = {}, ".format(heap_array[2*i+1]), end='')
if 2*i+2 < len(heap_array):
print("right key = {}, ".format(heap_array[2*i+2]), end='')
print('')
``` | output | 1 | 107,836 | 13 | 215,673 |
Provide a correct Python 3 solution for this coding contest problem.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8, | instruction | 0 | 107,837 | 13 | 215,674 |
"Correct Solution:
```
def main():
""" ????????? """
H = int(input().strip())
hkeys = list(map(int,(input().split())))
for i in range(H):
txts = []
id = i + 1
txts.append("node {}: key = {},".format(id, hkeys[i]))
parent = int(id / 2)
if parent != 0:
txts.append("parent key = {},".format(hkeys[parent-1]))
left = id * 2
if left > 0 and left <= H:
txts.append("left key = {},".format(hkeys[left-1]))
right = left + 1
if right > 0 and right <= H:
txts.append("right key = {},".format(hkeys[right-1]))
print("{} ".format(" ".join(txts)))
if __name__ == '__main__':
main()
``` | output | 1 | 107,837 | 13 | 215,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n = int(input())
klist = list(map(int,input().split()))
plist = []
i = 0
k = 1
a = 2**i-1
while 1:
if klist[a:a+2**i] != []:
plist.append(klist[a:a + 2**i])
else: break
a += 2**i
i += 1
for i in range(len(plist)):
for j in range(len(plist[i])):
try:
if i==0:
print("node "+str(k)+": key = "+str(plist[0][0])+
", left key = "+str(plist[1][0])+
", right key = "+str(plist[1][1])+", ")
else :
l = int(j/2)
print("node "+str(k)+": key = "+str(plist[i][j])+
", parent key = "+str(plist[i-1][l])+", left key = "+
str(plist[i+1][2*j]),end="")
try:
print(", right key = "+str(plist[i+1][2*j+1])+", ")
except:
print(", ")
except:
l = int(j/2)
print("node "+str(k)+": key = "+str(plist[i][j])+
", parent key = "+str(plist[i-1][l])+", ")
k += 1
``` | instruction | 0 | 107,838 | 13 | 215,676 |
Yes | output | 1 | 107,838 | 13 | 215,677 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n = int(input())
Arr = [0] + list(map(int, input().split()))
for i in range(1, n + 1):
print(f'node {i}: key = {Arr[i]}, ', end = '')
if i > 1:
print(f'parent key = {Arr[i//2]}, ', end = '')
if i*2 <= n:
print(F'left key = {Arr[i*2]}, ', end = '')
if i*2 + 1 <= n:
print(f'right key = {Arr[i*2 + 1]}, ', end = '')
print()
``` | instruction | 0 | 107,839 | 13 | 215,678 |
Yes | output | 1 | 107,839 | 13 | 215,679 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
def has_child(data, n):
data_len = len(data) - 1 # [0]????????????????????§?????£?????????????????°???-1??????
if data_len < n * 2:
return 0
else:
if data_len >= (n * 2) + 1:
return 2
else:
return 1
if __name__ == '__main__':
# ??????????????\???
num_of_data = int(input())
data = [int(x) for x in input().split(' ')]
# ???????????????
data.insert(0, None) # ?????????????????????????????????[0]????????????????????\??????
# ???????????????
for i in range(1, num_of_data+1):
print('node {0}: key = {1}, '.format(i, data[i]), end='')
if i > 1:
print('parent key = {0}, '.format(data[i//2]), end='')
child = has_child(data, i)
if child == 1:
print('left key = {0}, '.format(data[i*2]), end='')
if child == 2:
print('left key = {0}, right key = {1}, '.format(data[i*2], data[i*2+1]), end='')
print('')
``` | instruction | 0 | 107,840 | 13 | 215,680 |
Yes | output | 1 | 107,840 | 13 | 215,681 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n=int(input())
nums=list(map(int,input().split()))
tree={}
def show(tree,i,number):
if tree[number][2]==None:
if tree[number][1]==None:
if tree[number][0]==None:
print("node "+str(i+1)+": key = "+str(number)+", ")
else:
print("node "+str(i+1)+": key = "+str(number)+", left key = "+str(tree[number][0])+", ")
else:
print("node "+str(i+1)+": key = "+str(number)+", left key = "+str(tree[number][0])+", right key = "+str(tree[number][1])+", ")
else:
if tree[number][1]==None:
if tree[number][0]==None:
print("node "+str(i+1)+": key = "+str(number)+", parent key = "+str(tree[number][2])+", ")
else:
print("node "+str(i+1)+": key = "+str(number)+", parent key = "+str(tree[number][2])+", left key = "+str(tree[number][0])+", ")
else:
print("node "+str(i+1)+": key = "+str(number)+", parent key = "+str(tree[number][2])+", left key = "+str(tree[number][0])+", right key = "+str(tree[number][1])+", ")
for i in range(n):
number=nums[i]
tree[number]=[None,None,None]
if i==0:
if i+2<=n:
tree[number]=[nums[i+1],nums[i+2],None]
elif i+1<=n:
tree[number]=[nums[i+1],None,None]
show(tree,i,number)
else:
tree[number][2]=nums[int((i+1)/2)-1]
if 2*(i+1)<n+1:
if 2*(i+1)+1<n+1:
tree[number][0]=nums[2*(i+1)-1]
tree[number][1]=nums[2*(i+1)]
else:
tree[number][0]=nums[2*(i+1)-1]
show(tree,i,number)
``` | instruction | 0 | 107,841 | 13 | 215,682 |
Yes | output | 1 | 107,841 | 13 | 215,683 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_9_A
#????????????17:15~
def decode_heap(target_list):
for i, key in enumerate(target_list):
node_index = i + 1
parent_index = int(node_index / 2) - 1
parent = ""
if not parent_index < 0:
parent = " parent key = " + str(target_list[parent_index]) + ", "
left_index = node_index * 2 - 1
right_index = node_index * 2
leaf = ""
if left_index < len(target_list) and right_index < len(target_list):
leaf = " left key ={}, right key = {}, ".format(target_list[left_index], target_list[right_index])
print("node {}: key = {},{}{}".format(node_index, key, parent, leaf))
def main():
n_nodes = int(input())
target_list = [int(a) for a in input().split()]
decode_heap(target_list)
if __name__ == "__main__":
main()
``` | instruction | 0 | 107,842 | 13 | 215,684 |
No | output | 1 | 107,842 | 13 | 215,685 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n = int(input())
xs = [int(i) for i in input().split()]
for i in range(n):
ind = i + 1
ret = "node" + str(ind) + ":key = " + str(xs[ind - 1])
if ind != 1:
parent = ind // 2 - 1
ret += ", parent key = " + str(xs[parent])
if n > 2 * i + 1:
ret += ", left key = " + str(xs[2 * i + 1])
if n > 2 * i + 2:
ret += ", right key = " + str(xs[2*i + 2])
ret += ","
print(ret)
``` | instruction | 0 | 107,843 | 13 | 215,686 |
No | output | 1 | 107,843 | 13 | 215,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n = int(input())
keys = list(map(int, input().split()))
#n=5
#heap_keys = [7,8,1,2,3]
heap = []
for i,x in enumerate(heap_keys):
node = i+1
key = x
parent_key = heap_keys[int(node/2)-1] if i > 0 else None
left_key = heap_keys[2*node-1] if 2*node-1 <len(heap_keys) else None
right_key = heap_keys[2*node] if 2*node <len(heap_keys) else None
heap.append({"node":node, "key":x, "parent_key":parent_key, "left_key":left_key, "right_key":right_key})
for h in heap:
out_str = "node %s: key = %s, " % (h["node"],h["key"])
if h["parent_key"]:out_str += "parent key = %s, " % h["parent_key"]
if h["left_key"]:out_str += "left key = %s, " % h["left_key"]
if h["right_key"]:out_str += "right key = %s, " % h["right_key"]
print(out_str)
``` | instruction | 0 | 107,844 | 13 | 215,688 |
No | output | 1 | 107,844 | 13 | 215,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A complete binary tree is a binary tree in which every internal node has two children and all leaves have the same depth. A binary tree in which if last level is not completely filled but all nodes (leaves) are pushed across to the left, is also (nearly) a complete binary tree.
A binary heap data structure is an array that can be viewed as a nearly complete binary tree as shown in the following figure.
<image>
Each node of a nearly complete binary tree corresponds to an element of the array that stores the value in the node. An array $A$ that represents a binary heap has the heap size $H$, the number of elements in the heap, and each element of the binary heap is stored into $A[1...H]$ respectively. The root of the tree is $A[1]$, and given the index $i$ of a node, the indices of its parent $parent(i)$, left child $left(i)$, right child $right(i)$ can be computed simply by $\lfloor i / 2 \rfloor$, $2 \times i$ and $2 \times i + 1$ respectively.
Write a program which reads a binary heap represented by a nearly complete binary tree, and prints properties of nodes of the binary heap in the following format:
node $id$: key = $k$, parent key = $pk$, left key = $lk$, right key = $rk$,
$id$, $k$, $pk$, $lk$ and $rk$ represent id (index) of the node, value of the node, value of its parent, value of its left child and value of its right child respectively. Print these properties in this order. If there are no appropriate nodes, print nothing.
Constraints
* $H \leq 250$
* $-2,000,000,000 \leq$ value of a node $\leq 2,000,000,000$
Input
In the first line, an integer $H$, the size of the binary heap, is given. In the second line, $H$ integers which correspond to values assigned to nodes of the binary heap are given in order of node id (from $1$ to $H$).
Output
Print the properties of the binary heap in the above format from node $1$ to $H$ in order. Note that, the last character of each line is a single space character.
Example
Input
5
7 8 1 2 3
Output
node 1: key = 7, left key = 8, right key = 1,
node 2: key = 8, parent key = 7, left key = 2, right key = 3,
node 3: key = 1, parent key = 7,
node 4: key = 2, parent key = 8,
node 5: key = 3, parent key = 8,
Submitted Solution:
```
n = int(input())
numbers = list(map(int,input().split()))
for i in range(n):
print("node {}: key = {},".format(i+1,numbers[i]),end='')
if int((i+1)/2) >=1:
print(" parent key = {},".format(numbers[int((i+1)/2)-1]),end='')
if 2*(i+1) <=n:
print(" left key = {},".format(numbers[int(2*(i+1))-1]),end='')
if 2*(i+1)+1 <=n:
print(" right key = {},".format(numbers[int(2*(i+1))]),end='')
print("")
``` | instruction | 0 | 107,845 | 13 | 215,690 |
No | output | 1 | 107,845 | 13 | 215,691 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,986 | 13 | 215,972 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
from collections import deque
input = sys.stdin.buffer.readline
N = int(input())
A = [10**10]
BC = [0]
for _ in range(N):
a, b, c = map(int, input().split())
A.append(a)
BC.append(b-c)
adj = [[] for _ in range(N+1)]
for _ in range(N-1):
a, b = map(int, input().split())
adj[a].append(b)
adj[b].append(a)
que = deque()
que.append(1)
seen = [-1] * (N+1)
seen[1] = 0
par = [0] * (N+1)
child = [[] for _ in range(N+1)]
seq = []
while que:
v = que.popleft()
seq.append(v)
for u in adj[v]:
if seen[u] == -1:
seen[u] = seen[v] + 1
par[u] = v
child[v].append(u)
que.append(u)
A[u] = min(A[u], A[v])
seq.reverse()
pos = [0] * (N+1)
neg = [0] * (N+1)
ans = 0
for v in seq:
if BC[v] == 1:
pos[v] += 1
elif BC[v] == -1:
neg[v] += 1
for u in child[v]:
pos[v] += pos[u]
neg[v] += neg[u]
k = min(pos[v], neg[v])
ans += A[v] * k * 2
pos[v] -= k
neg[v] -= k
if pos[1] == neg[1] == 0:
print(ans)
else:
print(-1)
if __name__ == '__main__':
main()
``` | output | 1 | 107,986 | 13 | 215,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,987 | 13 | 215,974 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from types import GeneratorType
def bootstrap(func, stack=[]):
def wrapped_function(*args, **kwargs):
if stack:
return func(*args, **kwargs)
else:
call = func(*args, **kwargs)
while True:
if type(call) is GeneratorType:
stack.append(call)
call = next(call)
else:
stack.pop()
if not stack:
break
call = stack[-1].send(call)
return call
return wrapped_function
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
cost = 0
@bootstrap
def dfs(cur,par,cho):
global cost
w = 0
b = 0
for child in g[cur]:
if child == par : continue
cnt = (0,0)
if c[child] > c[cur] :
c[child] = c[cur]
cnt = yield dfs(child,cur,0)
else:
cnt = yield dfs(child,cur,1)
w+=cnt[0]
b+=cnt[1]
if ini[cur] != fin[cur]:
if fin[cur] == 1:
b+=1
else:
w+=1
minn = 0
if cho == 1:
minn = min(b,w)
cost += minn*2*c[cur]
yield (w-minn,b-minn)
n = int(ri())
c = [0]*(n+1)
ini = [0]*(n+1)
fin = [0]*(n+1)
for i in range(1,n+1):
c[i],ini[i],fin[i] = Ri()
g = [[ ] for i in range(n+1)]
for i in range(n-1):
a,b = Ri()
g[a].append(b)
g[b].append(a)
ans = dfs(1,-1,1)
# flag = dfs1(1fasdfasdf,-1)
# dfas
if ans[0] != ans[1]:
print(-1)
else:
#asddjflaksjdf;lkj
print(cost)
``` | output | 1 | 107,987 | 13 | 215,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,988 | 13 | 215,976 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
n = int(input())
cbc = [list(map(int,input().split())) for i in range(n)]
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
if n == 1:
if cbc[0][1] != cbc[0][2]:
print(-1)
else:
print(0)
exit()
deg = [0]*(n+1)
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
deg[a] += 1
deg[b] += 1
deg[1] += 1
stack = [1]
par = [0]*(n+1)
par[1] = -1
leaf = []
while stack:
x = stack.pop()
if x != 1 and len(graph[x]) == 1:
leaf.append(x)
for y in graph[x]:
if par[y]:
continue
par[y] = x
cbc[y-1][0] = min(cbc[y-1][0],cbc[x-1][0])
stack.append(y)
dp = [[0,0] for i in range(n+1)]
ans = 0
while leaf:
x = leaf.pop()
p = par[x]
if cbc[x-1][1] != cbc[x-1][2]:
if cbc[x-1][1] == 1:
dp[x][0] += 1
else:
dp[x][1] += 1
if min(dp[x][0],dp[x][1]):
if dp[x][0] > dp[x][1]:
dp[x][0] -= dp[x][1]
ans += cbc[x-1][0]*dp[x][1]*2
dp[x][1] = 0
else:
dp[x][1] -= dp[x][0]
ans += cbc[x-1][0]*dp[x][0]*2
dp[x][0] = 0
dp[p][0] += dp[x][0]
dp[p][1] += dp[x][1]
deg[p] -= 1
if deg[p] == 1:
leaf.append(p)
if dp[1][0] != dp[1][1]:
print(-1)
else:
print(ans)
``` | output | 1 | 107,988 | 13 | 215,977 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,989 | 13 | 215,978 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
f = open('q1.input', 'r')
except IOError:
f = sys.stdin
if 'xrange' in dir(__builtins__):
range = xrange
# print(f.readline())
def print_case_iterable(case_num, iterable):
print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))
def print_case_number(case_num, iterable):
print("Case #{}: {}".format(case_num,iterable))
def print_iterable(A):
print (' '.join(A))
def read_int():
return int(f.readline().strip())
def read_int_array():
return [int(x) for x in f.readline().strip().split(" ")]
def rns():
a = [x for x in f.readline().split(" ")]
return int(a[0]), a[1].strip()
def read_string():
return list(f.readline().strip())
def bi(x):
return bin(x)[2:]
from collections import deque
import math
from collections import deque, defaultdict
import heapq
from sys import stdout
# a=cost, b=written, c=wanted
import threading
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
# sys.setrecursionlimit(2*10**5+2)
# # sys.setrecursionlimit(10**6)
# threading.stack_size(10**8)
@bootstrap
def dfs(v,adj,curr_min,visited,data,res):
visited[v] = True
curr_min = min(curr_min,data[v][0])
balance = data[v][2]-data[v][1]
total = abs(balance)
for u in adj[v]:
if visited[u]:
continue
zeros = yield dfs(u,adj,curr_min,visited,data,res)
balance += zeros
total += abs(zeros)
res[0] += curr_min * (total-abs(balance))
yield balance
def solution(n,data,adj):
#dfs, correct as much as possible with minimum up to know, propogate up.
visited = [False]*(n+1)
res = [0]
balance = dfs(1,adj,10**10,visited,data,res)
if balance == 0:
return res[0]
return -1
def main():
T = 1
for i in range(T):
n = read_int()
adj = defaultdict(list)
data = [0]
for j in range(n):
data.append(read_int_array())
for j in range(n-1):
u,v = read_int_array()
adj[u].append(v)
adj[v].append(u)
x = solution(n,data,adj)
if 'xrange' not in dir(__builtins__):
print(x)
else:
print >>output,str(x)# "Case #"+str(i+1)+':',
if 'xrange' in dir(__builtins__):
print(output.getvalue())
output.close()
stdout.flush()
if 'xrange' in dir(__builtins__):
import cStringIO
output = cStringIO.StringIO()
#example usage:
# for l in res:
# print >>output, str(len(l)) + ' ' + ' '.join(l)
threading.stack_size(10**8)
if __name__ == '__main__':
main()
``` | output | 1 | 107,989 | 13 | 215,979 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,990 | 13 | 215,980 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
data = [list(map(int, line.rstrip().split())) for line in sys.stdin.readlines()]
n = data[0][0]
dic = [[] for _ in range(n+1)]
dic[1].append(0)
for u,v in data[n+1:]:
dic[u].append(v)
dic[v].append(u)
cost = [0]*(n+1)
cost[1] = 1000000001
father = [0]*(n+1)
now = [1]
leaf = []
gress = [0]*(n+1)
while now:
node = now.pop()
gress[node] = len(dic[node])
if gress[node]==1:
leaf.append(node)
c = min(cost[node],data[node][0])
for child in dic[node]:
if child!=father[node]:
father[child]=node
cost[child] = c
now.append(child)
res = 0
count = [[0,0] for _ in range(n+1)]
while leaf:
node = leaf.pop()
if data[node][1]==0 and data[node][2]==1:
count[node][0]+=1
elif data[node][1]==1 and data[node][2]==0:
count[node][1]+=1
if data[node][0]<cost[node]:
t = min(count[node])
res+=t*data[node][0]*2
count[node][0]-=t
count[node][1]-=t
f = father[node]
count[f][0]+=count[node][0]
count[f][1]+=count[node][1]
gress[f]-=1
if gress[f]==1:
leaf.append(f)
if count[0]==[0,0]:
print(res)
else:
print(-1)
``` | output | 1 | 107,990 | 13 | 215,981 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,991 | 13 | 215,982 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
from collections import deque
N = int(sys.stdin.readline())
A, B, C = [], [], []
bd, cd = 0, 0
for i in range(N):
a, b, c = [int(_) for _ in sys.stdin.readline().split()]
A.append(a)
B.append(b)
C.append(c)
if b == 0 and c == 1:
bd += 1
elif c == 0 and b == 1:
cd += 1
edges = [[] for _ in range(N)]
for i in range(N-1):
u, v = [int(_) for _ in sys.stdin.readline().split()]
edges[u-1].append(v-1)
edges[v-1].append(u-1)
if bd != cd:
print(-1)
sys.exit(0)
costs = [-1] * N
parents = [None] * N
D = [0] * N
nodes_per_dist = [[] for _ in range(N)]
def dfs(costs, edges, node, curr, dist):
costs[node] = min(curr, A[node])
nodes_per_dist[dist].append(node)
for neighbour in edges[node]:
if costs[neighbour] == -1:
parents[neighbour] = node
dfs(costs, edges, neighbour, costs[node], dist+1)
def bfs(costs, edges, node, ordered_nodes):
Q = deque()
Q.append(node)
D = [0] * len(edges)
nodes_per_dist[0].append(node)
while Q:
el = Q.popleft()
ordered_nodes.append(el)
if parents[el] is not None:
costs[el] = min(A[el], costs[parents[el]])
else:
costs[el] = A[el]
for n in edges[el]:
if costs[n] == -1:
Q.append(n)
D[n] = D[el] + 1
nodes_per_dist[D[n]].append(n)
parents[n] = el
# dfs(costs, edges, 0, math.inf, 0)
ordered_nodes = []
bfs(costs, edges, 0, ordered_nodes)
ninfos = [(0, 0) for _ in range(N)]
answer = 0
# print('parents', parents)
for i in range(len(ordered_nodes)-1, -1, -1):
leaf = ordered_nodes[i]
ninfo = ninfos[leaf]
if B[leaf] == 0 and C[leaf] == 1:
ninfos[leaf] = (ninfo[0] + 1, ninfo[1])
elif B[leaf] == 1 and C[leaf] == 0:
ninfos[leaf] = (ninfo[0], ninfo[1] + 1)
# print('leaf', leaf, ninfos)
swap = min(ninfos[leaf][0], ninfos[leaf][1])
answer += swap * 2 * costs[leaf]
# if swap:
# print('new answer', answer)
parent = parents[leaf]
if parent is not None:
ninfos[parent] = (ninfos[parent][0] + ninfos[leaf][0] - swap,
ninfos[parent][1] + ninfos[leaf][1] - swap)
# print('ninfos parent', ninfos[parent])
# print(ninfos)
print(answer)
``` | output | 1 | 107,991 | 13 | 215,983 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,992 | 13 | 215,984 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
import math
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().strip().split()))
def from_file(f):
return f.readline
def dfs(s, parent, min_parent, A, B, C, edges):
cost, zeros, ones = 0, 0, 0
if B[s] != C[s]:
if B[s] == 1:
ones += 1
else:
zeros += 1
for v in edges[s]:
if v == parent:
continue
cc, cz, co = dfs(v, s, min(A[s], min_parent), A, B, C, edges)
cost += cc
zeros += cz
ones += co
can_swap = min(ones,zeros)
if can_swap > 0 and A[s] < min_parent:
cost += 2 * A[s] * can_swap
ones -= can_swap
zeros -= can_swap
return cost, zeros, ones
def dfs_iter(A, B, C, edges):
stack = [(0, -1, float('inf'))]
states = [None] * len(A)
while stack:
cur = stack.pop()
s, s_par, s_min_par = cur
if states[s] is None:
# all children were computed
ones, zeros = 0, 0
if B[s] != C[s]:
if B[s] == 1:
ones += 1
else:
zeros += 1
states[s] = [0, zeros, ones]
stack.append(cur)
for v in edges[s]:
if v == s_par:
continue
stack.append((v, s, min(A[s], s_min_par)))
else:
cost, zeros, ones = states[s]
for v in edges[s]:
if v == s_par:
continue
cc, cz, co = states[v]
cost += cc
zeros += cz
ones += co
can_swap = min(ones,zeros)
if can_swap > 0 and A[s] < s_min_par:
cost += 2 * A[s] * can_swap
ones -= can_swap
zeros -= can_swap
states[s] = [cost, zeros, ones]
return states[0]
def solution(A, B, C, edges):
cost, ones, zeros = dfs_iter(A, B, C, edges)
if ones > 0 or zeros > 0:
return -1
return cost
# with open('4.txt') as f:
# input = from_file(f)
n = inp()
A = []
B = []
C = []
edges = [[] for _ in range(n)]
for i in range(n):
ai, bi, ci = invr()
A.append(ai)
B.append(bi)
C.append(ci)
for _ in range(n-1):
u, v = invr()
edges[u-1].append(v-1)
edges[v-1].append(u-1)
print(solution(A, B, C, edges))
``` | output | 1 | 107,992 | 13 | 215,985 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,993 | 13 | 215,986 |
Tags: dfs and similar, dp, greedy, trees
Correct Solution:
```
import sys
def main(x):
for i in v[x]:
d[i-1][-1] = min(d[x-1][-1], d[i-1][-1])
def main2(x):
for i in v[x]:
d[x-1][0] += d[i-1][0]
d[x-1][1] += d[i-1][1]
d[x-1][2] += d[i-1][2]
delta = min(d[x-1][0], d[x-1][1])
d[x-1][0] -= delta
d[x-1][1] -= delta
d[x-1][2] += 2*d[x-1][-1]*delta
n = int(input())
b = 0
c = 0
d = []
g = dict()
v = dict()
have_glub = dict()
for i in range(n):
(a1, b1, c1) = map(int, sys.stdin.readline().split())
if b1 == 0 and c1 == 1:
d.append([1, 0, 0, a1])
b += 1
elif b1 == 1 and c1 == 0:
d.append([0, 1, 0, a1])
c += 1
else:
d.append([0, 0, 0, a1])
v[i+1] = set()
g[i+1] = 0
have_glub[i] = set()
have_glub[n] = set()
for i in range(n-1):
(x, y) = map(int, sys.stdin.readline().split())
v[x].add(y)
v[y].add(x)
if b != c:
print(-1)
exit(0)
x = 1
gl = 0
sosed = set()
sosed.add(x)
while len(sosed) > 0:
sosed2 = set()
for j in sosed:
g[j] = gl
for i in v[j]:
v[i].discard(j)
for i in v[j]:
sosed2.add(i)
sosed = sosed2.copy()
gl += 1
for i in range(1, n+1):
have_glub[g[i]].add(i)
for i in range(n+1):
for j in have_glub[i]:
main(j)
for i in range(n, -1, -1):
for j in have_glub[i]:
main2(j)
print(d[0][2])
``` | output | 1 | 107,993 | 13 | 215,987 |
Provide tags and a correct Python 2 solution for this coding contest problem.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially. | instruction | 0 | 107,994 | 13 | 215,988 |
Tags: 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
mod=10**9+7
def ni():
return int(raw_input())
def li():
return map(int,raw_input().split())
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return map(int,stdin.read().split())
range = xrange # not for python 3.0+
n=input()
d=[[] for i in range(n)]
l=[]
for i in range(n):
l.append(li())
for i in range(n-1):
u,v=li()
d[u-1].append(v-1)
d[v-1].append(u-1)
q=[0]
vis=[0]*n
vis[0]=1
p=[0]*n
stk=[]
while q:
x=q.pop()
stk.append(x)
for i in d[x]:
if not vis[i]:
vis[i]=1
p[i]=x
l[i][0]=min(l[i][0],l[x][0])
q.append(i)
ans=0
dp=[[0,0] for i in range(n)]
while stk:
x=stk.pop()
if l[x][1]!=l[x][2]:
if l[x][1]:
dp[x][0]+=1
else:
dp[x][1]+=1
temp=min(dp[x])
ans+=(2*min(dp[x])*l[x][0])
dp[x][0]-=temp
dp[x][1]-=temp
dp[p[x]][0]+=dp[x][0]
dp[p[x]][1]+=dp[x][1]
if dp[0][0]!=dp[0][1]:
print -1
else:
print ans
``` | output | 1 | 107,994 | 13 | 215,989 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys, threading
import os
from io import BytesIO, IOBase
from types import GeneratorType
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
##############################################################
adj = {}
label = []
target = []
cost = []
data = []
def merge(a, b):
# node number, zero number, one number, correct, need zero, need one
tmp = [a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3], a[4] + b[4], a[5] + b[5]]
return tmp
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
to = f(*args, **kwargs)
if stack:
return to
else:
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
return to
to = stack[-1].send(to)
return wrappedfunc
@bootstrap
def dfs1(u, p):
global data, label, target, adj, cost
now = [
1,
1 if label[u] == 0 and label[u] != target[u] else 0,
1 if label[u] == 1 and label[u] != target[u] else 0,
1 if label[u] == target[u] else 0,
1 if target[u] == 0 and label[u] != target[u] else 0,
1 if target[u] == 1 and label[u] != target[u] else 0
]
if p != -1:
cost[u] = min(cost[u], cost[p])
if u in adj:
for v in adj[u]:
if v != p:
tmp = yield dfs1(v, u)
now = merge(now, tmp)
data[u] = now
yield now
res = 0
@bootstrap
def call(u, p):
global data, label, target, adj, cost, res
f_0, f_1 = 0, 0
if u in adj:
for v in adj[u]:
if v != p:
n_0, n_1 = yield call(v, u)
f_0 += n_0
f_1 += n_1
now = data[u]
can_be_fixed_zero = min(now[4], now[1]) - f_0
can_be_fixed_one = min(now[5], now[2]) - f_1
not_fixed = can_be_fixed_zero + can_be_fixed_one
res += not_fixed * cost[u]
yield f_0 + can_be_fixed_zero, f_1 + can_be_fixed_one
def main():
global data, label, target, adj, cost
n = input1()
data = [0 for _ in range(n+4)]
label = [0 for _ in range(n+4)]
target = [0 for _ in range(n+4)]
cost = [0 for _ in range(n+4)]
z, o, tz, to = 0, 0, 0, 0
for i in range(1, n+1):
cost[i], label[i], target[i] = input3()
z += (label[i] == 0)
o += (label[i] == 1)
tz += (target[i] == 0)
to += (target[i] == 1)
adj = {}
for i in range(n-1):
u, v = input2()
if u not in adj:
adj[u] = []
if v not in adj:
adj[v] = []
adj[u].append(v)
adj[v].append(u)
if (tz != z or o != to):
print(-1)
exit()
dfs1(1, -1)
# for i in range(1, n+1):
# print(data[i], cost[i])
global res
res = 0
call(1, -1)
print(res)
pass
if __name__ == '__main__':
# sys.setrecursionlimit(2**32//2-1)
# threading.stack_size(1 << 27)
# thread = threading.Thread(target=main)
# thread.start()
# thread.join()
# sys.setrecursionlimit(200004)
# READ('in.txt')
main()
``` | instruction | 0 | 107,995 | 13 | 215,990 |
Yes | output | 1 | 107,995 | 13 | 215,991 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
data = [list(map(int, line.rstrip().split())) for line in sys.stdin.readlines()]
# n = N()
# data = [[n]]+[RLL() for _ in range(n*2-1)]
n = data[0][0]
dic = [[] for _ in range(n+1)]
dic[1].append(0)
for u,v in data[n+1:]:
dic[u].append(v)
dic[v].append(u)
cost = [0]*(n+1)
cost[1] = 1000000001
father = [0]*(n+1)
now = [1]
leaf = []
gress = [0]*(n+1)
while now:
node = now.pop()
gress[node] = len(dic[node])
if gress[node]==1:
leaf.append(node)
c = min(cost[node],data[node][0])
for child in dic[node]:
if child!=father[node]:
father[child]=node
cost[child] = c
now.append(child)
res = 0
count = [[0,0] for _ in range(n+1)]
while leaf:
node = leaf.pop()
if data[node][1:]==[0,1]:
count[node][0]+=1
elif data[node][1:]==[1,0]:
count[node][1]+=1
if data[node][0]<cost[node]:
t = min(count[node])
res+=t*data[node][0]*2
count[node][0]-=t
count[node][1]-=t
f = father[node]
count[f][0]+=count[node][0]
count[f][1]+=count[node][1]
gress[f]-=1
if gress[f]==1:
leaf.append(f)
if count[0]==[0,0]:
print(res)
else:
print(-1)
``` | instruction | 0 | 107,996 | 13 | 215,992 |
Yes | output | 1 | 107,996 | 13 | 215,993 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
to = f(*args, **kwargs)
if stack:
return to
else:
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
return to
to = stack[-1].send(to)
return wrappedfunc
import sys
input=sys.stdin.readline
#sys.setrecursionlimit(500000)
from collections import defaultdict as dd
@bootstrap
def dfs(cur,prev,d,typ,val,ans):
if(prev!=0):
#print(cur,prev,val[cur],val[prev])
val[cur]=min(val[cur],val[prev])
for i in d[cur]:
if(i!=prev):
yield dfs(i,cur,d,typ,val,ans)
for i in d[cur]:
if(i!=prev):
#print(typ)
typ[cur][0]+=typ[i][0]
typ[cur][1]+=typ[i][1]
mi=min(typ[cur][0],typ[cur][1])
ans[0]+=val[cur]*mi*2
#print(mi)
typ[cur][0]-=mi
typ[cur][1]-=mi
yield
n=int(input())
typ=[[0]*2 for i in range(n+1)]
val=[0]*(n+1)
co1=0
co2=0
for i in range(1,n+1):
va,a,b=map(int,input().split())
if(a<b):
typ[i][0]=1
co1+=1
elif(a>b):
typ[i][1]=1
co2+=1
val[i]=va
d=dd(list)
for i in range(n-1):
u,v=map(int,input().split())
d[u].append(v)
d[v].append(u)
ans=[0]
dfs(1,0,d,typ,val,ans)
#print(val)
if(co1!=co2):
print(-1)
else:
print(ans[0])
``` | instruction | 0 | 107,997 | 13 | 215,994 |
Yes | output | 1 | 107,997 | 13 | 215,995 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
from sys import stdin, gettrace
from collections import deque
if gettrace():
inputi = input
else:
def input():
return next(stdin)[:-1]
def inputi():
return stdin.buffer.readline()
def readTree(n):
adj = [set() for _ in range(n)]
for _ in range(n-1):
u,v = map(int, inputi().split())
adj[u-1].add(v-1)
adj[v-1].add(u-1)
return adj
def treeOrderByDepth(n, adj, root=0):
parent = [-2] + [-1]*(n-1)
ordered = []
q = deque()
q.append(root)
while q:
c =q.popleft()
ordered.append(c)
for a in adj[c]:
if parent[a] == -1:
parent[a] = c
q.append(a)
return (ordered, parent)
def main():
n = int(inputi())
aa = []
bb = []
cc = []
for _ in range(n):
a,b,c = map(int, inputi().split())
aa.append(a)
bb.append(b)
cc.append(c)
adj = readTree(n)
if sum(bb) != sum(cc):
print(-1)
return
diff =[b-c for b,c in zip(bb,cc)]
dc = [abs(b-c) for b,c in zip(bb, cc)]
ordered, parent = treeOrderByDepth(n, adj, 0)
hb = [0] * n
move = [0] * n
for i in ordered[:0:-1]:
diff[parent[i]] += diff[i]
dc[parent[i]] += dc[i]
move[0] = dc[0]
for i in ordered[1:]:
aa[i] = min(aa[i], aa[parent[i]])
move[i] = dc[i] - abs(diff[i])
move[parent[i]] -= move[i]
res = sum((aa[i] * move[i] for i in range(n)))
print(res)
if __name__ == "__main__":
main()
``` | instruction | 0 | 107,998 | 13 | 215,996 |
Yes | output | 1 | 107,998 | 13 | 215,997 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish has a tree consisting of n nodes numbered 1 to n rooted at node 1. The i-th node in the tree has a cost a_i, and binary digit b_i is written in it. He wants to have binary digit c_i written in the i-th node in the end.
To achieve this, he can perform the following operation any number of times:
* Select any k nodes from the subtree of any node u, and shuffle the digits in these nodes as he wishes, incurring a cost of k ⋅ a_u. Here, he can choose k ranging from 1 to the size of the subtree of u.
He wants to perform the operations in such a way that every node finally has the digit corresponding to its target.
Help him find the minimum total cost he needs to spend so that after all the operations, every node u has digit c_u written in it, or determine that it is impossible.
Input
First line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) denoting the number of nodes in the tree.
i-th line of the next n lines contains 3 space-separated integers a_i, b_i, c_i (1 ≤ a_i ≤ 10^9, 0 ≤ b_i, c_i ≤ 1) — the cost of the i-th node, its initial digit and its goal digit.
Each of the next n - 1 lines contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v in the tree.
Output
Print the minimum total cost to make every node reach its target digit, and -1 if it is impossible.
Examples
Input
5
1 0 1
20 1 0
300 0 1
4000 0 0
50000 1 0
1 2
2 3
2 4
1 5
Output
4
Input
5
10000 0 1
2000 1 0
300 0 1
40 0 0
1 1 0
1 2
2 3
2 4
1 5
Output
24000
Input
2
109 0 1
205 0 1
1 2
Output
-1
Note
The tree corresponding to samples 1 and 2 are:
<image>
In sample 1, we can choose node 1 and k = 4 for a cost of 4 ⋅ 1 = 4 and select nodes {1, 2, 3, 5}, shuffle their digits and get the desired digits in every node.
In sample 2, we can choose node 1 and k = 2 for a cost of 10000 ⋅ 2, select nodes {1, 5} and exchange their digits, and similarly, choose node 2 and k = 2 for a cost of 2000 ⋅ 2, select nodes {2, 3} and exchange their digits to get the desired digits in every node.
In sample 3, it is impossible to get the desired digits, because there is no node with digit 1 initially.
Submitted Solution:
```
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque
from types import GeneratorType
def bootstrap(func, stack=[]):
def wrapped_function(*args, **kwargs):
if stack:
return func(*args, **kwargs)
else:
call = func(*args, **kwargs)
while True:
if type(call) is GeneratorType:
stack.append(call)
call = next(call)
else:
stack.pop()
if not stack:
break
call = stack[-1].send(call)
return call
return wrapped_function
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
cost = 0
@bootstrap
def dfs(cur,par,cho):
global cost
w = 0
b = 0
for child in g[cur]:
if child == par : continue
cnt = (0,0)
if c[child] > c[cur] :
cnt = yield dfs(child,cur,0)
else:
cnt = yield dfs(child,cur,1)
w+=cnt[0]
b+=cnt[1]
if ini[cur] != fin[cur]:
if fin[cur] == 1:
b+=1
else:
w+=1
minn = 0
if cho == 1:
minn = min(b,w)
cost += minn*2*c[cur]
yield (w-minn,b-minn)
# @bootstrap
# def dfs1(cur,par):
# global cost
# w = 0
# b = 0
# for child in g[cur]:
# if child == par : continue
# cnt = (0,0)
# cnt = yield dfs1(child,cur)
# cnt = yield dfs1(child,cur)
# w+=cnt[0]
# b+=cnt[1]
# if ini[cur] != fin[cur]:
# if fin[cur] == 1:
# b+=1
# else:
# w+=1
# yield (w,b)
n = int(ri())
c = [0]*(n+1)
ini = [0]*(n+1)
fin = [0]*(n+1)
for i in range(1,n+1):
c[i],ini[i],fin[i] = Ri()
g = [[ ] for i in range(n+1)]
for i in range(n-1):
a,b = Ri()
g[a].append(b)
g[b].append(a)
ans = dfs(1,-1,1)
# flag = dfs1(1,-1)
if ans[0] != ans[1]:
print(-1)
else:
# cost += ans[0]*2*c[1]
print(cost)
``` | instruction | 0 | 107,999 | 13 | 215,998 |
No | output | 1 | 107,999 | 13 | 215,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.