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.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264 | instruction | 0 | 95,860 | 13 | 191,720 |
"Correct Solution:
```
n = int(input())
al = list(map(int, input().split()))
bl = [0]*(n+1)
acc = [0]*(n+2)
for i in range(n+1):
acc[i+1] = al[i]+acc[i]
res = 0
for d in range(n+1):
if d==0:
res += 1
bl[0] = 1 - al[0]
else:
r1 = 2*bl[d-1] - al[d]
r2 = acc[-1] - acc[d+1]
bl[d] = min(r1,r2)
res += al[d]+bl[d]
if bl[d]<0:
print(-1)
exit()
print(res)
``` | output | 1 | 95,860 | 13 | 191,721 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264 | instruction | 0 | 95,861 | 13 | 191,722 |
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
b = [0] * (N+1)
b[0] = 1
flag = True
for i in range(N):
if A[i] > b[i]:
flag = False
b[i+1] = (b[i] - A[i]) * 2
if A[N] > b[N]:
flag = False
ans = 0
l = 0
for i in range(N, -1, -1):
l += A[i]
ans += min(l, b[i])
if flag:
print(ans)
else:
print(-1)
``` | output | 1 | 95,861 | 13 | 191,723 |
Provide a correct Python 3 solution for this coding contest problem.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264 | instruction | 0 | 95,862 | 13 | 191,724 |
"Correct Solution:
```
N = int(input())
A = list(map(int, input().split()))
isOK = True
B = [0]*(N+1)
B[0] = 1-A[0]
M = 1
i = 1
while i <= N:
B[i] = B[i-1]*2-A[i]
i += 1
if B[-1] < 0 or N > 0 and A[-1] == 0:
isOK = False
B[-1] = A[-1]
i = N-1
while i >= 0:
if B[i] < 1 or i > 0 and B[i] > B[i-1]*2:
isOK = False
break
else:
B[i] = min(B[i], B[i+1])+A[i]
i -= 1
print(-1 if not isOK else sum(B))
``` | output | 1 | 95,862 | 13 | 191,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
import sys
n=int(input())
a=input()
a=[int(s)for s in a.split()]
M=1
Q=1
m=sum(a)
if a[0]>=1:
if a[0]==1 and n==0:
print(1)
sys.exit()
else:
print(-1)
sys.exit()
for i in range(n):
M=2*M-a[i+1]
if M<0:
print(-1)
sys.exit()
M1=M+a[i+1]
m=m-a[i]
Q=Q+min(M1,m)
print(Q)
``` | instruction | 0 | 95,863 | 13 | 191,726 |
Yes | output | 1 | 95,863 | 13 | 191,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
N = int(input())
A = list(map(int, input().split()))
s = sum(A)
e = 1
ans = 1
flag = 1
if N == 0:
if s >= 2:
flag = 0
else:
ans = 1
else:
for i in range(N):
e = (e - A[i]) * 2
if e < A[i+1]:
flag = 0
break
tmp = min(e, s)
s -= A[i+1]
ans += tmp
if flag == 0:
print(-1)
else:
print(ans)
``` | instruction | 0 | 95,864 | 13 | 191,728 |
Yes | output | 1 | 95,864 | 13 | 191,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
n = int(input())
al = list(map(int,input().split()))
sum_a = sum(al)
potential = 1
ans = 0
for a in al:
ans += min(sum_a, potential)
sum_a -= a
potential = 2 * (potential - a)
if potential < 0:
print(-1)
exit()
print(ans)
``` | instruction | 0 | 95,865 | 13 | 191,730 |
Yes | output | 1 | 95,865 | 13 | 191,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
if n == 0 and a[0] != 1:
print(-1)
exit(0)
b = [0] * (n + 2)
for i in range(n, 0, -1):
b[i - 1] = b[i] + a[i]
t = 1 - a[0]
ans = 1
for i in range(n):
m = min(t * 2, b[i])
if m < a[i + 1]:
print(-1)
exit(0)
ans += m
t = m - a[i + 1]
print(ans)
``` | instruction | 0 | 95,866 | 13 | 191,732 |
Yes | output | 1 | 95,866 | 13 | 191,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
import numpy as np
# import math
# import copy
# from collections import deque
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10000)
def main():
N = int(input())
A = list(map(int,input().split()))
A = np.array(A)
if (N != 0) & (A[0] != 0):
print(-1)
sys.exit()
M = np.sum(A)
already = 1
end = 0
now = 1
res = 1
for d in range(1,N+1):
temp = min(2*now-now,M-already)
now += temp
# print(now)
res += now
# print(d,now,res)
already += temp
end += A[d]
now -= A[d]
# print(d,res)
if (d != N) & (now <= 0):
res = -1
break
print(res)
main()
``` | instruction | 0 | 95,867 | 13 | 191,734 |
No | output | 1 | 95,867 | 13 | 191,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
n = int(input())
a_li = list(map(int, input().split()))
ans = 0
li = [0]*(n+1)
for i,a in enumerate(a_li):
ans += (i+1)*a
for i,a in enumerate(a_li[::-1]):
if i >= 1:
li[i] = li[i-1]+a
else:
li[i] = a
li = li[::-1]
#print(li)
#print(ans)
flag = True
ne = 0.5
for i in range(n+1):
if li[i] > 2*ne:
ans -= li[i] -2*ne
#print(li[i] -2*ne)
ne = 2*ne - a_li[i]
#print(ne)
if ne < 0:
flag = False
if flag:
print(int(ans))
else:
print(-1)
``` | instruction | 0 | 95,868 | 13 | 191,736 |
No | output | 1 | 95,868 | 13 | 191,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
# import sys
# readline = sys.stdin.readline
# generator = (readline().strip() for _ in range(N))
# N, M = map(int, input().split())
# As = list(map(int, input().split()))
# queries = (input() for _ in range(N))
def solve():
N = int(input())
As = list(map(int, input().split()))
if As[0] > 0:
return -1
vertices = [1] * (N+1)
previous = 0
for i, a in enumerate(As[:0:-1]):
max_n_vert = a + previous
previous = max_n_vert
vertices[N-i] = max_n_vert
n_not_leaves_prev = 1
for i, a in enumerate(As):
if i == 0:
continue
max_n_vert = 2 * n_not_leaves_prev
vertices[i] = min(vertices[i], max_n_vert)
n_not_leaves_prev = vertices[i] - a
if max_n_vert < a:
return -1
return sum(vertices)
def main():
print(solve())
if __name__ == "__main__":
main()
``` | instruction | 0 | 95,869 | 13 | 191,738 |
No | output | 1 | 95,869 | 13 | 191,739 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.
Constraints
* 0 \leq N \leq 10^5
* 0 \leq A_i \leq 10^{8} (0 \leq i \leq N)
* A_N \geq 1
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_0 A_1 A_2 \cdots A_N
Output
Print the answer as an integer.
Examples
Input
3
0 1 1 2
Output
7
Input
4
0 0 1 0 2
Output
10
Input
2
0 3 1
Output
-1
Input
1
1 1
Output
-1
Input
10
0 0 1 1 2 3 5 8 13 21 34
Output
264
Submitted Solution:
```
depth = int(input())
vertex = input().split(' ')
vertex = [int(x) for x in vertex]
if vertex[0] == 1:
if depth == 0:
print(1)
else:
print(-1)
else:
is_error = False
for i in range(depth + 1):
if vertex[i] > 2**i:
is_error = True
break
if is_error:
print(-1)
else:
maxs = []
i = 1
for v in vertex:
i -= v
maxs.append(i)
i *= 2
output = 0
for i in range(depth, -1, -1):
if i == depth:
output += vertex[i]
next_v = vertex[i]
else:
next_v = min([maxs[i], next_v]) + vertex[i]
output += next_v
print(output)
``` | instruction | 0 | 95,870 | 13 | 191,740 |
No | output | 1 | 95,870 | 13 | 191,741 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,871 | 13 | 191,742 |
"Correct Solution:
```
from collections import defaultdict
from heapq import heappop, heappush
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To,cost))
def get_nodes(self):
return self.graph.keys()
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda:float('inf'))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q,(self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q,(alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N = int(input())
g = Graph()
d = {}
for i in range(N-1):
a,b = map(int,input().split())
a -= 1
b -= 1
d[(min(a,b),max(a,b))] = i
g.add_edge(a,b)
g.add_edge(b,a)
M = int(input())
l = [0]*M
for i in range(M):
u,v = map(int,input().split())
u -= 1
v -= 1
dij = Dijkstra(g,u)
path = dij.shortest_path(v)
for j in range(len(path)-1):
a,b = path[j],path[j+1]
l[i] += 2**d[(min(a,b),max(a,b))]
c = [0]*(M+1)
p2 = [2**i for i in range(50)]
for n in range(2**M):
cnt = 0
x = 0
for i in range(M):
if n&p2[i]==p2[i]:
cnt += 1
x |= l[i]
y = 0
for i in range(N-1):
if x&p2[i]==p2[i]:
y += 1
c[cnt] += p2[N-1-y]
ans = 0
for i in range(M+1):
if i%2==0:
ans += c[i]
else:
ans -= c[i]
print(ans)
``` | output | 1 | 95,871 | 13 | 191,743 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,872 | 13 | 191,744 |
"Correct Solution:
```
def resolve():
def dfs(u, v, parent):
if u == v:
return True
for (to, idx) in G[u]:
if to == parent:
continue
if dfs(to, v, u):
path.append(idx)
return True
return False
N = int(input())
G = [[] for _ in range(N)]
for i in range(N-1):
a, b = map(lambda x:int(x)-1, input().split())
G[a].append((b, i))
G[b].append((a, i))
path = []
M = int(input())
cons = [0]*M
# 制約ごとに、白くなる辺を入れておく
for i in range(M):
u, v = map(lambda x: int(x) - 1, input().split())
path = []
dfs(u, v, -1)
for idx in path:
cons[i] |= 1<<idx
# 包除原理
ans = 0
for bit in range(1<<M):
eset = 0
for i in range(M):
if bit>>i & 1:
eset |= cons[i]
white = bin(eset).count("1") # 白くなるべき辺の数
num = 1<<(N-1-white)
if bin(bit).count("1") % 2 == 0:
ans += num
else:
ans -= num
print(ans)
if __name__ == "__main__":
resolve()
``` | output | 1 | 95,872 | 13 | 191,745 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,873 | 13 | 191,746 |
"Correct Solution:
```
N = int(input())
from collections import defaultdict
G = defaultdict(list)
EdaNum = {}
Ki = [[float('inf')]*(N+1) for i in range(N+1)]
for i in range(N-1):
a,b = map(int,input().split())
G[a].append(b)
G[b].append(a)
EdaNum[(min(a,b),max(a,b))] = i
Ki[a][b] = 1
Ki[b][a] = 1
Next = [[-1]*(N+1) for i in range(N+1)]
for i in range(1,N+1):
for j in range(1,N+1):
Next[i][j] = j
for k in range(1,N+1):
for i in range(1,N+1):
for j in range(1,N+1):
if Ki[i][k] + Ki[k][j] < Ki[i][j]:
Ki[i][j] = Ki[i][k] + Ki[k][j]
Next[i][j] = Next[i][k]
M = int(input())
MM = [set() for i in range(M)]
#print(EdaNum)
#print(Next)
for i in range(M):
u,v = map(int,input().split())
now = u
while now != v:
nex = Next[now][v]
MM[i].add(EdaNum[(min(now,nex),max(now,nex))])
now = nex
#print(MM)
import itertools
zero1 = [0,1]
ans = 0
for i in itertools.product(zero1,repeat = M):
#print(ans)
count = 0
root = set()
for j in range(M):
if i[j] == 0:
count += 1
else:
root |= MM[j]
#print(i,len(root),count)
if (M-count)%2 ==0:
ans += pow(2,N-1-len(root))
else:
ans -= pow(2,N-1-len(root))
print(ans)
``` | output | 1 | 95,873 | 13 | 191,747 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,874 | 13 | 191,748 |
"Correct Solution:
```
n = int(input())
info = [list(map(int, input().split())) for i in range(n - 1)]
m = int(input())
path = [list(map(int, input().split())) for i in range(m)]
tree = [[] for i in range(n)]
memo = {}
for i in range(n - 1):
a, b = info[i]
a -= 1
b -= 1
tree[a].append(b)
tree[b].append(a)
memo[(min(a, b), max(a, b))] = i
def dfs(par, pos, goal):
if pos == goal:
return True
for child in tree[pos]:
if child == par:
continue
if dfs(pos, child, goal):
res.append((min(pos, child), max(pos, child)))
return True
return False
li_path = [0] * m
for i in range(m):
res = []
s, g = path[i]
s -= 1
g -= 1
dfs(-1, s, g)
tmp = 0
for j in res:
tmp += (1 << memo[j])
li_path[i] = tmp
ans = 0
for bit_state in range(1 << m):
mask = 0
cnt = 0
for i in range(m):
if bit_state & (1 << i):
cnt += 1
mask |= li_path[i]
num_n = bin(mask).count("1")
if cnt % 2 == 0:
ans += 2 ** (n - 1 - num_n)
else:
ans -= 2 ** (n - 1 - num_n)
print(ans)
``` | output | 1 | 95,874 | 13 | 191,749 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,875 | 13 | 191,750 |
"Correct Solution:
```
def popcount(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
def main():
import sys
import collections
input = sys.stdin.readline
N = int(input())
G = [[-1]*N for i in range(N)]
ans = 2**(N-1)
for i in range(N-1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a][b] = i
G[b][a] = i
ans = 0
g = [[0]*N for i in range(N)]
for i in range(N):
q = collections.deque()
q.append((i, 0))
r = [True]*N
r[i] = False
while(q):
x, s = q.popleft()
for y in range(N):
if G[x][y] >= 0 and r[y]:
g[i][y] = s | 1 << G[x][y]
q.append((y, g[i][y]))
r[y] = False
M = int(input())
s = [0 for i in range(M)]
for i in range(M):
u, v = map(int, input().split())
u -= 1
v -= 1
s[i] = g[u][v]
# print(s)
for i in range(2**M):
tmp = 2**(N-1) - 1
c = 0
for j in range(M):
if (i >> j) % 2 == 1:
tmp &= ~s[j]
c += 1
ans += ((-1)**(c))*(1 << popcount(tmp))
print(ans)
main()
``` | output | 1 | 95,875 | 13 | 191,751 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,876 | 13 | 191,752 |
"Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
def main(n,ki,uv):
# n: 頂点数
# ki: 木
# Euler Tour の構築
S=[] # Euler Tour
F=[0]*n # F[v]:vにはじめて訪れるステップ
depth=[0]*n # 0を根としたときの深さ
def dfs(v,pare,d):
F[v]=len(S)
depth[v]=d
S.append(v)
for i,w in ki[v]:
if w==pare:continue
dfs(w,v,d+1)
S.append(v)
dfs(0,-1,0)
# Sをセグメント木に乗せる
# u,vのLCAを求める:S[F[u]:F[v]+1]のなかでdepthが最小の頂点を探せば良い
# F[u]:uに初めてたどるつくステップ
# S[F[u]:F[v]+1]:はじめてuにたどり着いてつぎにvにたどるつくまでに訪れる頂点
# 存在しない範囲は深さが他よりも大きくなるようにする
INF = (n, None)
# LCAを計算するクエリの前計算
M = 2*n
M0 = 2**(M-1).bit_length() # M以上で最小の2のべき乗
data = [INF]*(2*M0)
for i, v in enumerate(S):
data[M0-1+i] = (depth[v], i)
for i in range(M0-2, -1, -1):
data[i] = min(data[2*i+1], data[2*i+2])
# LCAの計算 (generatorで最小値を求める)
def _query(a, b):
yield INF
a += M0; b += M0
while a < b:
if b & 1:
b -= 1
yield data[b-1]
if a & 1:
yield data[a-1]
a += 1
a >>= 1; b >>= 1
# LCAの計算 (外から呼び出す関数)
def query(u, v):
fu = F[u]; fv = F[v]
if fu > fv:
fu, fv = fv, fu
return S[min(_query(fu, fv+1))[1]]
todo=[[0,[]]]
path=[[]]*n
mi=[1]*n
while todo:
v,ary=todo.pop()
path[v]=ary
mi[v]=0
for i,nv in ki[v]:
if mi[nv]==1:
todo.append([nv,ary+[i]])
mi[nv]=1
for i in range(n):
path[i]=set(path[i])
memo=[set(())]*m
for c in range(m):
u,v=uv[c]
dd=query(u,v)
tmp=path[u]|path[v]
tmp-=path[dd]
memo[c]=tmp
ans=0
for i in range(2**m):
chk=set(())
for j in range(m):
if (i>>j)&1:
chk.add(j)
must_w=set(())
for c in chk:
tmp=memo[c]
must_w|=tmp
t=n-1-len(must_w)
if len(chk)%2==1:
ans-=pow(2,t)
else:
ans+=pow(2,t)
print(ans)
if __name__=='__main__':
n=int(input())
ki=[[] for _ in range(n)]
for i in range(n-1):
u,v=map(int,input().split())
u,v=u-1,v-1
ki[u].append([i,v])
ki[v].append([i,u])
m=int(input())
uv=[]
for _ in range(m):
u,v=map(int,input().split())
u,v=u-1,v-1
uv.append([u,v])
main(n,ki,uv)
``` | output | 1 | 95,876 | 13 | 191,753 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,877 | 13 | 191,754 |
"Correct Solution:
```
N = int(input())
E = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
E[a-1].append(b-1)
E[b-1].append(a-1)
parent = [None]*N
depth = [0]*N
d = 0
queue = [0]
while queue:
d += 1
queue_new = []
for q in queue:
for e in E[q]:
if e==parent[q]: continue
parent[e] = q
depth[e] = d
queue_new.append(e)
queue = queue_new
ancestor = [[None]*N for _ in range(N)]
for a in range(N):
for b in range(a, N):
_a = a
_b = b
while _a!=_b:
if depth[_a] < depth[_b]: _b = parent[_b]
else: _a = parent[_a]
ancestor[a][b] = ancestor[b][a] = _a
M = int(input())
P = []
for _ in range(M):
u, v = map(int, input().split())
u -= 1
v -= 1
w = ancestor[u][v]
path = set()
while u!=w:
_u = parent[u]
#path.add((u, _u))
path.add(u*N+_u)
u = _u
while v!=w:
_v = parent[v]
#path.add((v, _v))
path.add(v*N+_v)
v = _v
P.append(path)
ans = 0
n1 = N-1
for k in range(2**M):
path = set()
n = 0
for i, p in enumerate(P):
if (k>>i)&1:
path |= p
n += 1
if n==0: continue
sign = +1 if n&1 else -1
ans += sign * pow(2, n1-len(path))
print(pow(2, N-1) - ans)
``` | output | 1 | 95,877 | 13 | 191,755 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62 | instruction | 0 | 95,878 | 13 | 191,756 |
"Correct Solution:
```
N = int(input())
ab = [tuple(map(int,input().split())) for _ in range(N - 1)]
M = int(input())
uv = [tuple(map(int,input().split())) for _ in range(M)]
route = [[] for _ in range(N)]
for i, (a, b) in enumerate(ab):
a -= 1
b -= 1
route[a].append((b, i))
route[b].append((a, i))
path = [0] * M
for i, (u, v) in enumerate(uv):
u -= 1
v -= 1
stack = [u]
visited = [0] * N
visited[u] = 1
dire = [[] for _ in range(N)]
while True:
s = stack.pop()
for g, j in route[s]:
if visited[g]:
continue
stack.append(g)
dire[g].append((s, j))
visited[g] = 1
if visited[v]:
break
s = v
while True:
g, num = dire[s][0]
path[i] |= (1 << num)
if g == u:
break
s = g
data = [0] * (1 << M)
ans = 2 ** (N - 1)
for i in range(1, 1 << M):
k = len(bin(i)) - 3
data[i] = data[i - (2 ** k)] | path[k]
power = bin(data[i]).count("1")
judge = bin(i).count("1")
ans += (-2 ** (N - 1 - power) if judge % 2 else 2 ** (N - 1 - power))
print(ans)
``` | output | 1 | 95,878 | 13 | 191,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
input = sys.stdin.readline
def main():
n = int(input())
T = [[] for _ in range(n)]
D = {}
for i in range(n-1):
a, b = map(int, input().split())
a -= 1
b -= 1
T[a].append(b)
T[b].append(a)
D[(a, b)] = 1<<i
D[(b, a)] = 1<<i
m = int(input())
def dfs(u, v):
parent = [-1]*n
seen = [False]*n
stack = [u]
seen[u] = True
while stack:
nv = stack[-1]
if nv == v:
return stack
for i in T[nv]:
if seen[i]:
continue
stack.append(i)
seen[i] = True
break
else:
stack.pop()
def popcount(n):
c = (n & 0x5555555555555555) + ((n>>1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c>>2) & 0x3333333333333333)
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c>>4) & 0x0f0f0f0f0f0f0f0f)
c = (c & 0x00ff00ff00ff00ff) + ((c>>8) & 0x00ff00ff00ff00ff)
c = (c & 0x0000ffff0000ffff) + ((c>>16) & 0x0000ffff0000ffff)
c = (c & 0x00000000ffffffff) + ((c>>32) & 0x00000000ffffffff)
return c
E = [0]*m
for i in range(m):
u, v = map(int, input().split())
u -= 1
v -= 1
edge = dfs(u, v)
for j in range(len(edge)-1):
E[i] |= D[(edge[j], edge[j+1])]
ans = 0
for i in range(2**m):
s = 0
for j in range(m):
if i>>j & 1:
s |= E[j]
cnt = popcount(i) % 2
ans += (-1)**cnt * 2**(n-1-popcount(s))
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 95,879 | 13 | 191,758 |
Yes | output | 1 | 95,879 | 13 | 191,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
def main():
input = sys.stdin.readline
N = int(input())
E = [[] for _ in range(N)]
for i in range(N-1):
a, b = map(int, input().split())
a, b = a-1, b-1
E[a].append((b,i))
E[b].append((a,i))
def dfs(s, g):
par = [(-1,-1)] * N
par[s] = (s,-1)
stack = [s]
while stack:
v = stack.pop()
for to, i in E[v]:
if par[to][0] >= 0: continue
par[to] = (v, i)
if to == g: break
stack.append(to)
r = 0
v = g
while v != s:
v, i = par[v]
r |= 1 << i
return r
M = int(input())
path = [0] * M
for i in range(M):
u, v = map(int, input().split())
u, v = u-1, v-1
path[i] = dfs(u, v)
def calc(s): return 1<<(N-1-bin(s).count('1'))
i_ans = 0
for p in range(1, 1<<M):
is_odd = 0
s = 0
for i in range(M):
if p&1:
s |= path[i]
is_odd ^= 1
p >>= 1
if is_odd: i_ans += calc(s)
else: i_ans -= calc(s)
print((1<<(N-1)) - i_ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 95,880 | 13 | 191,760 |
Yes | output | 1 | 95,880 | 13 | 191,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
n = int(input())
graph = [[] for _ in range(n)] #[(v_to, edge_idx)]
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
graph[a].append((b, i))
graph[b].append((a, i))
def dfs(v, v_p, target):
if v == target:
return True, 0
for v_next, edge_idx in graph[v]:
if v_next == v_p:
continue
is_target, path = dfs(v_next, v, target)
if is_target:
return is_target, path | (1 << edge_idx)
return False, 0
m = int(input())
cond = []
for _ in range(m):
u, v = map(int, input().split())
u -= 1
v -= 1
_, path = dfs(u, -1, v)
# print(u, v, bin(path))
cond.append((u, v, path))
ans = 1 << (n - 1)
for bit in range(1, 1 << m):
l = 0
path = 0
for i, (u, v, path_i) in enumerate(cond):
if (bit >> i) & 1:
l += 1
path = path | path_i
c = n - 1 - bin(path).count('1')
ans += ((-1)**(l % 2)) * (1 << c)
print(ans)
``` | instruction | 0 | 95,881 | 13 | 191,762 |
Yes | output | 1 | 95,881 | 13 | 191,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from collections import defaultdict
n = int(input())
ns = defaultdict(set)
uv2e = {}
for i in range(n-1):
u,v = map(int, input().split())
ns[u-1].add(v-1)
ns[v-1].add(u-1)
uv2e[u-1,v-1] = i
uv2e[v-1,u-1] = i
m = int(input())
uvs = [None]*m
for i in range(m):
u,v = map(int, input().split())
u -= 1
v -= 1
uvs[i] = (u,v)
from queue import deque
def bfs(start):
q = deque([start])
seen = [None] * n
seen[start] = 0
while q:
u = q.pop()
d = seen[u]
for v in ns[u]:
if seen[v] is None:
seen[v] = u
q.appendleft(v)
return seen
paths = [None]*m
for i,(u,v) in enumerate(uvs):
seen = bfs(u)
ss = set()
z = v
while z!=u:
z1 = seen[z]
ss.add(uv2e[z,z1])
z = z1
paths[i] = ss
ans = 0
def dfs(l, s):
if len(l)==m:
global ans
val = pow(2, n-1-len(s)) * pow(-1, sum(l))
ans += val
# print(val, sum(l), ans)
return
dfs(l + [0], s)
i = len(l)
p = paths[i]
dfs(l + [1], s|p)
dfs([], set())
# ans = pow(2,n-1) - ans
print(ans)
``` | instruction | 0 | 95,882 | 13 | 191,764 |
Yes | output | 1 | 95,882 | 13 | 191,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dijkstra(s):
d = [float("inf")]*n
p = [s]*n
d[s] = 0
q = [(0,s)]
while q:
dx,x = heappop(q)
nd = dx+1
for y in v[x]:
if nd < d[y]:
d[y] = nd
p[y] = x
heappush(q,(nd,y))
path = [[i] for i in range(n)]
for i in range(1,n):
pre = path[i][-1]
while pre != s:
path[i].append(p[pre])
pre = path[i][-1]
path[i] = path[i][::-1]
return d,path
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
d = [[0]*n for i in range(n)]
path = [[None]*n for i in range(n)]
for i in range(n):
D,p = dijkstra(i)
d[i] = [j for j in D]
path[i] = [j for j in p]
m = I()
l = LIR(m)
for i in range(m):
l[i][0] -= 1
l[i][1] -= 1
ans = 0
fa = 0
fb = 0
for b in range(1,1<<m):
f = bin(b).count("1")
p = [0]*n
for j in range(m):
x,y = l[j]
if b&(1<<j):
for k in path[x][y]:
p[k] = 1
s = 0
for j in p:
s += j
f &= 1
k = 1<<(n-s)
if f:
ans += k
else:
ans -= k
print((1<<(n-1))-ans)
return
#Solve
if __name__ == "__main__":
solve()
``` | instruction | 0 | 95,883 | 13 | 191,766 |
No | output | 1 | 95,883 | 13 | 191,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
sys.setrecursionlimit(10 ** 7)
def dfs(G, p, pre, t, edge, x):
for nxt in G[p]:
if nxt == pre:
continue
a, b = p, nxt
if b < a:
a, b = b, a
if nxt == t:
edge[(a, b)] += x
return True
if dfs(G, nxt, p, t, edge, x):
edge[(a, b)] += x
return True
return False
def main():
n = int(input())
G = [[] for _ in range(n)]
edge = {}
for _ in range(n-1):
a, b = map(int, input().split())
a, b = a-1, b-1
G[a].append(b)
G[b].append(a)
if b < a:
a, b = b, a
edge[(a, b)] = 0
m = int(input())
for i in range(m):
u, v = map(int, input().split())
u, v = u-1, v-1
x = 1<<i
dfs(G, u, -1, v, edge, x)
ans = 2**(n-1)
for i in range(1, 2**m):
bit_cnt = 0
for j in range(m):
if (i & (1<<j)) != 0:
bit_cnt += 1
cnt = 0
for v in edge.values():
if (v & i) != 0:
cnt += 1
x = 2**(n-1 - cnt)
if bit_cnt % 2 == 0:
ans += x
else:
ans -= x
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 95,884 | 13 | 191,768 |
No | output | 1 | 95,884 | 13 | 191,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
def all_bit_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
n = int(readline())
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = map(int,readline().split())
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
m = int(readline())
c = []
for i in range(m):
u, v = map(int,readline().split())
u -= 1
v -= 1
que = deque()
que.append((u,1<<u))
chk = [False]*n
chk[u] = True
while que:
now,L = que.popleft()
if now == v:
c.append(L)
break
for i in g[now]:
if not chk[i]:
chk[i] = True
que.append((i,L|1<<i))
import itertools
ans = 1<<(n-1)
for i in range(1,m+1):
for j in itertools.combinations(c,i):
K = 0
l = 0
for k in j:
p = all_bit_count(K)
f = all_bit_count(k)
K |= k
B = all_bit_count(K)
if f+p == B:
l += f-1
else:
l = B-1
ans += pow(-1,i)*pow(2,n-1-l)
print(ans)
``` | instruction | 0 | 95,885 | 13 | 191,770 |
No | output | 1 | 95,885 | 13 | 191,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i.
Consider painting each of these edges white or black. There are 2^{N-1} such ways to paint the edges. Among them, how many satisfy all of the following M restrictions?
* The i-th (1 \leq i \leq M) restriction is represented by two integers u_i and v_i, which mean that the path connecting Vertex u_i and Vertex v_i must contain at least one edge painted black.
Constraints
* 2 \leq N \leq 50
* 1 \leq a_i,b_i \leq N
* The graph given in input is a tree.
* 1 \leq M \leq \min(20,\frac{N(N-1)}{2})
* 1 \leq u_i < v_i \leq N
* If i \not= j, either u_i \not=u_j or v_i\not=v_j
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
M
u_1 v_1
:
u_M v_M
Output
Print the number of ways to paint the edges that satisfy all of the M conditions.
Examples
Input
3
1 2
2 3
1
1 3
Output
3
Input
2
1 2
1
1 2
Output
1
Input
5
1 2
3 2
3 4
5 3
3
1 3
2 4
2 5
Output
9
Input
8
1 2
2 3
4 3
2 5
6 3
6 7
8 6
5
2 7
3 5
1 6
2 8
7 8
Output
62
Submitted Solution:
```
from itertools import combinations
def cal(tree, v, bit, pre_node, now_node):
for node in tree[now_node]:
new_bit = bit | (1 << node)
if node == v:
return new_bit
if node == pre_node:
continue
new_bit = cal(tree, v, new_bit, now_node, node)
if new_bit:
return new_bit
return False
def run():
N = int(input())
tree = {}
for n in range(1, N):
a, b = map(int, input().split())
tree.setdefault(a, []).append(b)
tree.setdefault(b, []).append(a)
#print(tree)
M = int(input())
uv = [0]*M
for m in range(M):
u, v = map(int, input().split())
bit = 1 << u
uv[m] = cal(tree, v, bit, -1, u)
#print(bin(uv[m]))
ans = 2**(N-1)
for m in range(1, M+1):
total = 0
#print(m)
for units in combinations(uv, m):
#print(units)
temp = 0
white = 0
for bit in units:
white += bin(bit).count('1')-1
dup = temp & bit
n_dup = bin(dup).count('1')
if n_dup >= 2:
white -= n_dup-1
temp |= bit
#print(bin(temp))
#white = bin(temp).count('1')
black = N-white-1
#print(black)
total += 2**black
if m%2 == 0:
#print('m'+str(m))
ans += total
else:
ans -= total
print(ans)
if __name__ == '__main__':
run()
``` | instruction | 0 | 95,886 | 13 | 191,772 |
No | output | 1 | 95,886 | 13 | 191,773 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices numbered 1 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21 | instruction | 0 | 95,925 | 13 | 191,850 |
"Correct Solution:
```
"""
https://atcoder.jp/contests/arc097/tasks/arc097_d
始点と終点関係ある？
→逆にしても問題はない
黒い葉は完全に無視できる(落とせる)
よって、葉はすべて白
葉以外は白黒どっちもあり得る
すべての葉をめぐる最短経路？
ある葉からスタートするのは自明っぽい？
ある白からスタートするのはそう
→自分を塗ってからdfsする
→全方位木dp?
行きのみで帰らない場所が1つ存在するはず
→始点と終点のパスとそこから生える木って感じのイメージ
足踏み(停止)の回数を極力少なくしたい
→始点でも終点でもない場合、 e本の辺がつながってたらe回訪問は確定
e^colorが黒でない場合は+1
→つまり、各頂点で消費する回数は始点・終点でない限り常に一定？
終点はまず葉→始点も葉でおｋ
始点は足踏みなので1秒つかう 終点も1秒使う
パス上の点は、e-1回訪問(ここが根本的に違う！)
つまり、あるパスがあって その長さがL(両端除く)の時、最大でL減る
ただし、パス上にあっても回数が減らない点もある
B=0 W=1とするか
(color^E) == 1 の点は、E-1回訪問になると足踏みがいらないから2減る
つまり、そのような点が最大数あるパスを求めればいい
"""
import sys
sys.setrecursionlimit(200000)
from collections import deque
MM = 0
def dfs(v,p):
global MM
if v != p and linknum[v] == 1:
return 0
cl = []
for nex in lis[v]:
if nex != p and exist[nex]:
tmp = dfs(nex,v)
cl.append(tmp)
cl.sort()
cl.reverse()
if len(cl) == 1:
MM = max(MM , cl[0])
else:
if (linknum[v]+c[v])%2 == 1:
MM = max(MM , cl[0] + cl[1] + 2)
else:
MM = max(MM , cl[0] + cl[1])
if (linknum[v]+c[v]) % 2 == 1:
return cl[0]+ 2
else:
return cl[0]
N = int(input())
lis = [ [] for i in range(N) ]
linknum = [0] * N
for i in range(N-1):
u,v = map(int,input().split())
u -= 1
v -= 1
lis[u].append(v)
lis[v].append(u)
linknum[u] += 1
linknum[v] += 1
ctmp = input()
c = []
for i in ctmp:
if i == "B":
c.append(0)
else:
c.append(1)
exist = [True] * N
q = deque([])
for i in range(N):
if linknum[i] <= 1 and c[i] == 0:
q.append(i)
while len(q) > 0:
now = q.popleft()
exist[now] = False
linknum[now] = 0
for nex in lis[now]:
linknum[nex] -= 1
if linknum[nex] == 1 and c[nex] == 0:
q.append(nex)
#print (exist)
start = None
for i in range(N):
if exist[i]:
start = i
break
else:
print (0)
sys.exit()
if linknum[start] == 0:
print (1)
sys.exit()
ans = 0
#print (linknum)
for i in range(N):
if exist[i]:
if (linknum[i] + c[i]) % 2 == 0:
ans += linknum[i]
else:
ans += linknum[i] + 1
MM = 0
pick = dfs(start,start)
print (ans - MM)
``` | output | 1 | 95,925 | 13 | 191,851 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices numbered 1 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21 | instruction | 0 | 95,926 | 13 | 191,852 |
"Correct Solution:
```
from collections import deque
def first_cut(links, colors):
tmp_links = links.copy()
for v, neighbors in tmp_links.items():
while len(neighbors) == 1 and colors[v]:
del links[v]
par = neighbors.pop()
links[par].remove(v)
v = par
neighbors = links[par]
return links
def diameter(links, flags):
def dfs(s):
fs = flags[s]
d, v = 0, 0
q = deque(sorted((fs + flags[v], v, s) for v in links[s]))
while q:
d, v, a = q.popleft()
for u in links[v]:
if u == a:
continue
fu = flags[u]
if fu:
q.append((d + 1, u, v))
else:
q.appendleft((d, u, v))
return d, v
s = next(iter(links))
_, t = dfs(s)
d, _ = dfs(t)
return d
def solve(links, colors):
if all(colors):
return 0
links = first_cut(links, colors)
k = len(links)
if k == 1:
return 1
flags = {v: colors[v] ^ (len(link) % 2 == 0) for v, link in links.items()}
euler_tour = 2 * (k - 1) + sum(flags.values())
return euler_tour - 2 * diameter(links, flags)
n = int(input())
links = {i: set() for i in range(n)}
for _ in range(n - 1):
x, y = map(int, input().split())
x -= 1
y -= 1
links[x].add(y)
links[y].add(x)
colors = [c == 'B' for c in input()]
print(solve(links, colors))
``` | output | 1 | 95,926 | 13 | 191,853 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices numbered 1 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21 | instruction | 0 | 95,927 | 13 | 191,854 |
"Correct Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
data = read().split()
m = map(int,data[:-1])
XY = zip(m,m)
C = [0] + [1 * (x == ord('W')) for x in data[-1]]
graph = [set() for _ in range(N+1)]
for x,y in XY:
graph[x].add(y)
graph[y].add(x)
deg = [len(x) for x in graph]
b_leaf = [i for i in range(N+1) if deg[i] == 1 and not C[i]]
while b_leaf:
x = b_leaf.pop()
for y in graph[x]:
graph[y].remove(x)
deg[y] -= 1
if deg[y] == 1 and not C[y]:
b_leaf.append(y)
deg[x] = 0
graph[x].clear()
V = set(i for i,E in enumerate(graph) if E)
if len(V) <= 2:
print(sum(C))
exit()
root = None
for v in V:
if deg[v] > 1:
root = v
break
parent = [0] * (N+1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
"""
・Euler tourの状態から、パスをひとつ除く
・葉と葉を結ぶとしてよい。通ると2コスト安くなる点がある
"""
for i in range(N+1):
C[i] ^= (1°[i])
cost_full = sum(deg) + sum(C)
# C[i] == 1 となる i を最もたくさん含むパスを探す
opt = 0
dp = [0] * (N+1)
for v in order[::-1]:
if deg[v] == 1:
continue
arr = sorted((dp[w] for w in graph[v] if w != parent[v]),reverse = True) + [0]
x = arr[0] + arr[1] + C[v]
if opt < x:
opt = x
dp[v] = arr[0] + C[v]
answer = cost_full - 2 * opt
print(answer)
``` | output | 1 | 95,927 | 13 | 191,855 |
Provide a correct Python 3 solution for this coding contest problem.
There is a tree with N vertices numbered 1 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21 | instruction | 0 | 95,928 | 13 | 191,856 |
"Correct Solution:
```
import sys
from collections import deque
input=sys.stdin.readline
N=int(input())
edge=[[] for i in range(N)]
for i in range(N-1):
x,y=map(int,input().split())
edge[x-1].append(y-1)
edge[y-1].append(x-1)
c=input()[:N]
deg=[len(edge[i]) for i in range(N)]
leaf=set([])
for i in range(N):
if deg[i]==1 and c[i]=="B":
leaf.add(i)
ban=set([])
while leaf:
v=leaf.pop()
ban.add(v)
deg[v]=0
for nv in edge[v]:
deg[nv]-=1
if deg[nv]==1 and c[nv]=="B":
leaf.add(nv)
for i in range(N):
edge[i]=[nv for nv in edge[i] if nv not in ban]
root=-1
for i in range(N):
if i not in ban:
root=i
parent=[-2]*N
deq=deque([(root,-1)])
node=[]
while deq:
v,pv=deq.popleft()
parent[v]=pv
node.append(v)
for nv in edge[v]:
if nv!=pv:
deq.append((nv,v))
node=node[::-1]
for i in range(N):
edge[i]=[nv for nv in edge[i] if nv!=parent[i]]
check=True
for i in range(N):
check&=(deg[i]<=0)
if check:
print(int(c[root]=="W"))
exit()
cond=[0]*N
for v in range(N):
if (deg[v]%2==1 and c[v]=="B") or (deg[v]%2==0 and c[v]=="W"):
cond[v]+=1
else:
cond[v]-=1
lower=[0]*N
for v in node:
res=0
for nv in edge[v]:
res=max(res,lower[nv])
res+=1+cond[v]
lower[v]=res
upper=[0]*N
node=node[::-1]
for v in node:
n=len(edge[v])
if n>1:
left=[0]*n
right=[0]*n
for i in range(n-1):
nv=edge[v][i]
left[i]=max(left[i-1],lower[nv]+2+cond[v])
nv=edge[v][-1]
upper[nv]=left[n-2]+cond[nv]
right[n-1]=lower[nv]+2+cond[v]
for i in range(n-2,0,-1):
nv=edge[v][i]
upper[nv]=max(left[i-1],right[i+1])+cond[nv]
right[i]=max(right[i+1],lower[nv]+2+cond[v])
if edge[v][0]!=pv:
nv=edge[v][0]
upper[nv]=right[1]+cond[nv]
if v!=root:
for nv in edge[v]:
upper[nv]=max(upper[nv],upper[v]+1+cond[nv])
base=sum(deg[i] for i in range(N))+sum(cond[i]==1 for i in range(N))
#print(deg)
#print(base)
#print(lower)
#print(upper)
#print(base)
print(base-max(max(upper),max(lower)))
``` | output | 1 | 95,928 | 13 | 191,857 |
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 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21
Submitted Solution:
```
import sys
from collections import deque
input=sys.stdin.readline
N=int(input())
edge=[[] for i in range(N)]
for i in range(N-1):
x,y=map(int,input().split())
edge[x-1].append(y-1)
edge[y-1].append(x-1)
c=input()[:N]
deg=[len(edge[i]) for i in range(N)]
leaf=set([])
for i in range(N):
if deg[i]==1 and c[i]=="B":
leaf.add(i)
ban=set([])
while leaf:
v=leaf.pop()
ban.add(v)
deg[v]=0
for nv in edge[v]:
deg[nv]-=1
if deg[nv]==1 and c[nv]=="B":
leaf.add(nv)
for i in range(N):
edge[i]=[nv for nv in edge[i] if nv not in ban]
root=-1
for i in range(N):
if i not in ban:
root=i
parent=[-2]*N
deq=deque([(root,-1)])
node=[]
while deq:
v,pv=deq.popleft()
parent[v]=pv
node.append(v)
for nv in edge[v]:
if nv!=pv:
deq.append((nv,v))
node=node[::-1]
for i in range(N):
edge[i]=[nv for nv in edge[i] if nv!=parent[i]]
check=True
for i in range(N):
check&=(deg[i]<=0)
if check:
print(int(c[root]=="W"))
exit()
cond=[0]*N
for v in range(N):
if (deg[v]%2==1 and c[v]=="B") or (deg[v]%2==0 and c[v]=="W"):
cond[v]+=1
else:
cond[v]-=1
lower=[0]*N
for v in node:
res=0
for nv in edge[v]:
res=max(res,lower[nv])
res+=1+cond[v]
lower[v]=res
upper=[0]*N
for v in node:
n=len(edge[v])
if n>1:
left=[0]*n
right=[0]*n
for i in range(n-1):
nv=edge[v][i]
left[i]=max(left[i-1],lower[nv]+2+cond[v])
nv=edge[v][-1]
upper[nv]=left[n-2]+cond[nv]
right[n-1]=lower[nv]+2+cond[v]
for i in range(n-2,0,-1):
nv=edge[v][i]
upper[nv]=max(left[i-1],right[i+1])+cond[nv]
right[i]=max(right[i+1],lower[nv]+2+cond[v])
if edge[v][0]!=pv:
nv=edge[v][0]
upper[nv]=right[1]+cond[nv]
if v!=root:
for nv in edge[v]:
upper[nv]=max(upper[nv],upper[v]+1+cond[nv])
base=sum(deg[i] for i in range(N))+sum(cond[i]==1 for i in range(N))
#print(deg)
#print(base)
#print(lower)
#print(upper)
#print(base)
print(base-max(max(upper),max(lower)))
``` | instruction | 0 | 95,929 | 13 | 191,858 |
No | output | 1 | 95,929 | 13 | 191,859 |
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 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21
Submitted Solution:
```
"""
https://atcoder.jp/contests/arc097/tasks/arc097_d
始点と終点関係ある？
→逆にしても問題はない
黒い葉は完全に無視できる(落とせる)
よって、葉はすべて白
葉以外は白黒どっちもあり得る
すべての葉をめぐる最短経路？
ある葉からスタートするのは自明っぽい？
ある白からスタートするのはそう
→自分を塗ってからdfsする
→全方位木dp?
行きのみで帰らない場所が1つ存在するはず
→始点と終点のパスとそこから生える木って感じのイメージ
足踏み(停止)の回数を極力少なくしたい
→始点でも終点でもない場合、 e本の辺がつながってたらe回訪問は確定
e^colorが黒でない場合は+1
→つまり、各頂点で消費する回数は始点・終点でない限り常に一定？
終点はまず葉→始点も葉でおｋ
始点は足踏みなので1秒つかう 終点も1秒使う
パス上の点は、e-1回訪問(ここが根本的に違う！)
つまり、あるパスがあって その長さがL(両端除く)の時、最大でL減る
ただし、パス上にあっても回数が減らない点もある
B=0 W=1とするか
(color^E) == 1 の点は、E-1回訪問になると足踏みがいらないから2減る
つまり、そのような点が最大数あるパスを求めればいい
"""
import sys
sys.setrecursionlimit(200000)
from collections import deque
MM = 0
def dfs(v,p):
global MM
if v != p and linknum[v] == 1:
return 0
cl = []
for nex in lis[v]:
if nex != p and exist[nex]:
tmp = dfs(nex,v)
cl.append(tmp)
cl.sort()
cl.reverse()
if len(cl) == 1:
MM = max(MM , cl[0])
else:
if (linknum[v]+c[v])%2 == 1:
MM = max(MM , cl[0] + cl[1] + 2)
else:
MM = max(MM , cl[0] + cl[1])
if (linknum[v]+c[v]) % 2 == 1:
return cl[0]+ 2
else:
return cl[0]
N = int(input())
lis = [ [] for i in range(N) ]
linknum = [0] * N
for i in range(N-1):
u,v = map(int,input().split())
u -= 1
v -= 1
lis[u].append(v)
lis[v].append(u)
linknum[u] += 1
linknum[v] += 1
ctmp = input()
c = []
for i in ctmp:
if i == "B":
c.append(0)
else:
c.append(1)
exist = [True] * N
q = deque([])
for i in range(N):
if linknum[i] <= 1 and c[i] == 0:
q.append(i)
while len(q) > 0:
now = q.popleft()
exist[now] = False
linknum[now] = 0
for nex in lis[now]:
linknum[nex] -= 1
if linknum[nex] == 1 and c[nex] == 0:
q.append(nex)
#print (exist)
start = None
for i in range(N):
if exist[i]:
start = i
break
else:
print (0)
sys.exit()
if linknum[start] == 0:
print (1)
sys.exit()
ans = 0
#print (linknum)
for i in range(N):
if exist[i]:
if (linknum[i] + c[i]) % 2 == 0:
ans += linknum[i]
else:
ans += linknum[i] + 1
MM = 0
pick = dfs(start,start)
print (ans - MM)
``` | instruction | 0 | 95,930 | 13 | 191,860 |
No | output | 1 | 95,930 | 13 | 191,861 |
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 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21
Submitted Solution:
```
from collections import deque
def first_cut(links, colors):
tmp_links = links.copy()
for v, neighbors in tmp_links.items():
while len(neighbors) == 1 and colors[v]:
del links[v]
par = neighbors.pop()
links[par].remove(v)
v = par
neighbors = links[par]
return links
def diameter(links):
flags = {v: colors[v] ^ (len(link) % 2 == 0) for v, link in links.items()}
s = next(iter(links))
fs = flags[s]
v, d = 0, 0
q = deque(sorted((fs + flags[v], v, s) for v in links[s]))
while q:
d, v, a = q.popleft()
for u in links[v]:
if u == a:
continue
fu = flags[u]
if fu:
q.append((d + 1, u, v))
else:
q.appendleft((d, u, v))
t = v
ft = flags[t]
q = deque(sorted((ft + flags[v], v, t) for v in links[s]))
while q:
d, v, a = q.popleft()
for u in links[v]:
if u == a:
continue
fu = flags[u]
if fu:
q.append((d + 1, u, v))
else:
q.appendleft((d, u, v))
return d
def solve(links, colors):
if all(colors):
return 0
if sum(colors) == len(colors) - 1:
return 1
links = first_cut(links, colors)
k = len(links)
euler_tour = 2 * (k - 1) + sum(colors[v] ^ (len(link) % 2 == 0) for v, link in links.items())
return euler_tour - 2 * diameter(links)
n = int(input())
links = {i: set() for i in range(n)}
for _ in range(n - 1):
x, y = map(int, input().split())
x -= 1
y -= 1
links[x].add(y)
links[y].add(x)
colors = [c == 'B' for c in input()]
print(solve(links, colors))
``` | instruction | 0 | 95,931 | 13 | 191,862 |
No | output | 1 | 95,931 | 13 | 191,863 |
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 through N. The i-th edge connects Vertex x_i and y_i. Each vertex is painted white or black. The initial color of Vertex i is represented by a letter c_i. c_i = `W` represents the vertex is white; c_i = `B` represents the vertex is black.
A cat will walk along this tree. More specifically, she performs one of the following in one second repeatedly:
* Choose a vertex that is adjacent to the vertex where she is currently, and move to that vertex. Then, invert the color of the destination vertex.
* Invert the color of the vertex where she is currently.
The cat's objective is to paint all the vertices black. She may start and end performing actions at any vertex. At least how many seconds does it takes for the cat to achieve her objective?
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ x_i,y_i ≤ N (1 ≤ i ≤ N-1)
* The given graph is a tree.
* c_i = `W` or c_i = `B`.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_{N-1} y_{N-1}
c_1c_2..c_N
Output
Print the minimum number of seconds required to achieve the objective.
Examples
Input
5
1 2
2 3
2 4
4 5
WBBWW
Output
5
Input
6
3 1
4 5
2 6
6 1
3 4
WWBWBB
Output
7
Input
1
B
Output
0
Input
20
2 19
5 13
6 4
15 6
12 19
13 19
3 11
8 3
3 20
16 13
7 14
3 17
7 8
10 20
11 9
8 18
8 2
10 1
6 13
WBWBWBBWWWBBWWBBBBBW
Output
21
Submitted Solution:
```
input = __import__('sys').stdin.readline
MIS = lambda: map(int,input().split())
n = int(input())
adj = [set() for i in range(n+1)]
white = [False]
for i in range(n-1):
a, b = MIS()
adj[a].add(b); adj[b].add(a)
s = input().rstrip()
for i in range(n): white.append(s[i] == 'W')
# Corner cases
if sum(white) <= 1: print(sum(white)); exit()
# Remove black leaves
stack = [i for i in range(1,n+1) if len(adj[i]) == 1 and not white[i]]
while stack:
p = stack.pop()
pa = min(adj[p])
adj[pa].remove(p); adj[p].clear()
if len(adj[pa]) == 1 and not white[pa]: stack.append(pa)
# Simulate Euler tour
root = 1
while not adj[root]: root+= 1
tadj = [[] for i in range(n+1)]
vis = [False]*(n+1); vis[root] = True
stack = [root]
while stack:
p = stack.pop()
for q in adj[p]:
if vis[q]: continue
vis[q] = True; tadj[p].append(q)
stack.append(q)
for i in range(1, n+1):
if adj[i] and len(tadj[i])%2 == 0: white[i] = not white[i]
white[root] = not white[root]
# Diameter
def bfs(v):
stack = [v]
dist = [-1]*(n+1); dist[v] = white[v]
while stack:
p = stack.pop()
for q in adj[p]:
if dist[q] != -1: continue
dist[q] = dist[p] + white[q]
stack.append(q)
return dist
numedge = sum(map(len, adj))
d1 = bfs(root)
u = d1.index(max(d1))
d2 = bfs(u)
diam = max(d2)
print(numedge - diam)
``` | instruction | 0 | 95,932 | 13 | 191,864 |
No | output | 1 | 95,932 | 13 | 191,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,308 | 13 | 192,616 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
# begin FastIntegerInput;
import sys
_ord, inp, num, neg, _Index = lambda x: x, [], 0, False, 0
i, s = 0, sys.stdin.buffer.read()
try:
while True:
if s[i] >= b"0"[0]:num = 10 * num + _ord(s[i]) - 48
elif s[i] == b"-"[0]:neg = True
elif s[i] != b"\r"[0]:
inp.append(-num if neg else num)
num, neg = 0, False
i += 1
except IndexError:
pass
if s and s[-1] >= b"0"[0]: inp.append(-num if neg else num)
def fin(size=None):
global _Index
if size==None:
ni=_Index;_Index+=1
return inp[ni]
else:
ni=_Index;_Index+=size
return inp[ni:ni+size]
# end FastIntegerInput;
mod=1000000007
def DFS(gr,cost):
n=len(gr)
vis=[False for i in range(n)]
fin=[False for i in range(n)]
dp=[None for i in range(n)]
ans=0
def dfs(node):
stack=[node]
while(stack):
node=stack[-1]
if not vis[node]:
vis[node]=True
for i in gr[node]:
if not vis[i]:
stack.append(i)
else:
stack.pop()
dp[node]=1
for i in gr[node]:
if fin[i]:
dp[node]+=dp[i]
cost.append(dp[i]*(n-1-dp[i]))
fin[node]=True
return dp[node]
for i in range(n):
if not vis[i]:
ans+=dfs(i)
return ans
_T_=fin()
for _t_ in range(_T_):
n=fin()
gr=[[] for i in range(n+1)]
childs=[1 for i in range(n+1)]
cost=[]
for _ in range(n-1):
u,v=fin(2)
gr[u].append(v)
gr[v].append(u)
m=fin()
cm=fin(m)
cm.sort()
DFS(gr,cost)
cost.sort()
ll=len(cost)
if ll>=m:
cm=[1 for i in range(ll-m)]+cm
else:
while(len(cm)!=ll):
cm[-2]*=cm[-1]
cm[-2]%=mod
cm.pop()
s=0
for i in range(ll):
s+=((cm[i]%mod)*(cost[i]%mod))%mod
s%=mod
print(s)
``` | output | 1 | 96,308 | 13 | 192,617 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,309 | 13 | 192,618 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
t = int(input())
for _ in range(t):
n = int(input())
adj_lis = []
adj_cnt = []
for _ in range(n):
adj_lis.append([])
adj_cnt.append(0)
adj_cnt[0] = 1
par = [-1] * n
des_cnt = [1] * n
leaf_q = []
edgeNumber = []
for _ in range(n - 1):
p, q = map(int, input().split())
adj_lis[p - 1].append(q - 1)
adj_lis[q - 1].append(p - 1)
adj_cnt[p - 1] += 1
adj_cnt[q - 1] += 1
treeStack = [(0, -1)]
while treeStack:
v, par_v = treeStack.pop()
par[v] = par_v
for x in adj_lis[v]:
if x != par_v:
treeStack.append((x, v))
if adj_cnt[v] == 1:
leaf_q.append(v)
while leaf_q:
x = leaf_q.pop()
if x == 0:
continue
edgeNumber.append(des_cnt[x] * (n - des_cnt[x]))
des_cnt[par[x]] += des_cnt[x]
adj_cnt[par[x]] -= 1
if adj_cnt[par[x]] == 1:
leaf_q.append(par[x])
edgeNumber.sort()
m = int(input())
edgeWeight = []
primeList = list(map(int, input().split()))
primeList.sort()
if n - 1 < m:
for i in range(n - 1):
edgeWeight.append(primeList[i])
for i in range(n - 1, m):
edgeWeight[n - 2] *= primeList[i]
edgeWeight[n - 2] %= MOD
else:
for i in range(n - 1 - m):
edgeWeight.append(1)
for i in range(m):
edgeWeight.append(primeList[i])
ans = 0
for i in range(n - 1):
ans += edgeNumber[i] * edgeWeight[i]
ans %= MOD
print(ans)
``` | output | 1 | 96,309 | 13 | 192,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,310 | 13 | 192,620 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
import sys
input=sys.stdin.buffer.readline
inin=lambda: int(input())
inar=lambda: list(map(int,input().split()))
inst=lambda: input().decode().rstrip('\n\r')
#INF=float('inf'); from math import gcd
#from collections import deque as que, defaultdict as vector, Counter
#from bisect import bisect
#from heapq import heapify, heappush as hpush, heappop as hpop
from types import GeneratorType
def recursive(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
gr=[]
childs=[]
n=0
cost=[]
@recursive
def dfs(node,par):
global gr,cost,n,childs
su=1
for i in gr[node]:
if i!=par:
su +=yield dfs(i,node)
if node!=par : cost.append(su*(n-su))
yield su
mod=1000000007
_T_=inin()
for _t_ in range(_T_):
#print(_t_)
n=inin()
gr=[[] for i in range(n)]
cost=[]
for _ in range(n-1):
u,v=inar()
u-=1;v-=1
gr[u].append(v)
gr[v].append(u)
dfs(0,0)
cost.sort()
m=inin()
ps=inar()
ps.sort()
mult=[1 for i in range(n-1)]
st=max(0,n-1-m)
res=0
for i in range(m):
j=min(n-2,i+st)
mult[j]=(mult[j]*ps[i])%mod
for i in range(n-1):
res+=((cost[i]%mod)*mult[i])%mod
res%=mod
print(res)
``` | output | 1 | 96,310 | 13 | 192,621 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,311 | 13 | 192,622 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
from collections import defaultdict
import sys
from types import GeneratorType
MOD = (10 ** 9) + 7
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
def rl():
return [int(w) for w in sys.stdin.readline().split()]
@bootstrap
def number_of_nodes(s, e):
counts[s] = 1
for u in edges[s]:
if u == e:
continue
yield number_of_nodes(u, s)
counts[s] += counts[u]
yield
for _ in range(rl()[0]):
(n,) = rl()
edges = defaultdict(set)
for _ in range(n - 1):
u, v = rl()
edges[u - 1].add(v - 1)
edges[v - 1].add(u - 1)
(m,) = rl()
p = rl()
p.sort(reverse=True)
counts = [0] * n
number_of_nodes(0, -1)
edge_frequency = []
for i in range(1, n):
edge_frequency.append(counts[i] * (n - counts[i]))
edge_frequency.sort(reverse=True)
while m < n - 1:
p.append(1)
m += 1
if m > n - 1:
d = m - (n - 1) + 1
a = 1
for i in range(d):
a *= p[i]
a %= MOD
p = [a] + p[d:]
# print(n - 1, len(p))
f = 0
for i in range(n - 1):
f = (f + edge_frequency[i] * p[i]) % MOD
print(f)
``` | output | 1 | 96,311 | 13 | 192,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,312 | 13 | 192,624 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
tests = int(input())
for t in range(tests):
n = int(input())
node_dict = {}
for _ in range(n-1):
u, v = list(map(int, input().split()))
if u in node_dict:
node_dict[u][0] += 1
node_dict[u][1].add(v)
else:
node_dict[u] = [1,set([v])]
if v in node_dict:
node_dict[v][0] += 1
node_dict[v][1].add(u)
else:
node_dict[v] = [1, set([u])]
num_primes = int(input())
prime_ls = sorted(list(map(int, input().split())))
edge_weight = []
visit_node = [True for _ in range(0, n+1)]
other_node = list(node_dict[1][1])[0]
stack = [[1, 0], [other_node,0]]
visit_node[1] = True
node_dict[1][0] -= 1
node_dict[1][1].remove(other_node)
node_dict[other_node][0] -= 1
node_dict[other_node][1].remove(1)
while stack:
curr, excess = stack[-1]
visit_node[curr] = False
if node_dict[curr][0] == 0:
stack.pop()
if stack:
edge_weight.append((n-excess-1)*(excess+1))
stack[-1][1] += 1 + excess
else:
new_node = node_dict[curr][1].pop()
node_dict[curr][0] -= 1
while (node_dict[curr][0] != 0) and (not visit_node[new_node]) :
new_node = node_dict[curr][1].pop()
node_dict[curr][0] -= 1
if visit_node[new_node]:
stack.append([new_node, 0])
edge_weight = sorted(edge_weight)
res = 0
if num_primes > (n-1):
prod = 1
for idx in range(num_primes-1,n-3,-1):
prod *= prime_ls[idx]
prod = prod % (1000000007)
prime_ls[n-2] = prod
for idx in range(n-1):
res += (edge_weight[idx] * prime_ls[idx]) % (1000000007)
res = res % (1000000007)
else:
start_idx = n-2
for idx in range(num_primes-1, -1, -1):
res += edge_weight[start_idx] * prime_ls[idx]
res = res % (1000000007)
start_idx -= 1
for idx in range(start_idx+1):
res += edge_weight[idx]
res = res % (1000000007)
print(res % (1000000007))
``` | output | 1 | 96,312 | 13 | 192,625 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,313 | 13 | 192,626 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
mod = int(1e9)+7
ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
# DEFAULT-DICT as DD
def addEdge(a,b):
graph[a].append(b)
graph[b].append(a)
def Bfs(src):
q = deque([])
q.append(src)
visited[src] = True
dist[src] = 0
while(q):
node = q.popleft()
for neighbour in graph[node]:
if(not visited[neighbour]):
q.append(neighbour)
visited[neighbour]= True
dist[neighbour] = dist[node]+1
parent[neighbour] = node
level[dist[neighbour]].append(neighbour)
def Bfs2(src):
global total
q = deque([])
q.append(src)
visited[src] = True
while(q):
node = q.popleft()
for neighbour in graph[node]:
if(not visited[neighbour]):
q.append(neighbour)
visited[neighbour]= True
left = ct[neighbour]
right = total-left
times = left*right
a,b = node,neighbour
if a>b:
a,b = b,a
dic[(a,b)] = times
t = ip()
for _ in range(t):
n = ip()
total = n
graph = [[] for i in range(n)]
dist = [0]*n
parent = [-1]*n
visited = [False]*n
ct = [0]*n
dic = {}
for i in range(n-1):
a,b = inp()
a,b = a-1,b-1
addEdge(a,b)
if a>b:
a,b = b,a
dic[(a,b)] = 0
m = ip()
prime = list(inp())
level = dd(list)
Bfs(0)
ch = sorted(list(level.keys()),reverse = True)
visited = [False]*n
ct[0] += 1
for i in ch:
for j in level[i]:
ct[j] += 1
par = parent[j]
ct[par] += ct[j]
Bfs2(0)
prime.sort()
if len(prime)<=n-1:
prime = [1]*(n-1-len(prime))+prime
else:
ct = len(prime)
while ct != n-1:
val = prime.pop()
prime[-1] = (prime[-1]*val)%mod
ct -= 1
temp = sorted(list(dic.values()))
ans = 0
for i in range(n-1):
ans += ((temp[i]%mod)*(prime[i]%mod))%mod
ans %= mod
print(ans)
``` | output | 1 | 96,313 | 13 | 192,627 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,314 | 13 | 192,628 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
import sys
import threading
from sys import stdin, stdout
sys.setrecursionlimit(10**9)
threading.stack_size(16*2048*2048)
def maximum_distributed_tree(n, uv_dic, p_a, edg):
MOD = 10**9 + 7
dfs(n, uv_dic, 1, -1, edg)
edg.sort(reverse=True)
p_a.sort(reverse=True)
res = 0
if len(p_a) - n + 1 > 0:
for i in range(1, len(p_a) - n + 2):
p_a[i] *= p_a[i-1]
p_a[i] %= MOD
del p_a[:(len(p_a) - n + 1)]
for i in range(len(p_a)):
res += edg[i]*p_a[i]
res %= MOD
for i in range(len(p_a), n-1):
res += edg[i]
res %= MOD
return res
def dfs(n, uv_dic, node, parent, edg):
cnt = 1
nxt_a = uv_dic[node]
for nxt in nxt_a:
if nxt[1] != parent:
nxtCnt = dfs(n, uv_dic, nxt[1], node, edg)
edg[nxt[0]] = nxtCnt * (n - nxtCnt)
cnt += nxtCnt
return cnt
def solve():
try:
t = int(stdin.readline())
for _ in range(t):
n = int(stdin.readline())
uv_dic = {}
edg = [0 for _ in range(n-1)]
for i in range(n-1):
u, v = map(int, stdin.readline().split())
if u not in uv_dic:
uv_dic[u] = []
if v not in uv_dic:
uv_dic[v] = []
uv_dic[u].append([i, v])
uv_dic[v].append([i, u])
m = int(stdin.readline())
p_a = list(map(int, stdin.readline().split()))
ans = maximum_distributed_tree(n, uv_dic, p_a, edg)
stdout.write(str(ans) + '\n')
except Exception as e:
print("".join(str(e).split()))
threading.Thread(target=solve).start()
``` | output | 1 | 96,314 | 13 | 192,629 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18. | instruction | 0 | 96,315 | 13 | 192,630 |
Tags: dfs and similar, dp, greedy, implementation, math, number theory, sortings, trees
Correct Solution:
```
#!/usr/bin/env python3
import sys
import collections
input=sys.stdin.readline
mod=10**9+7
t=int(input())
for _ in range(t):
n=int(input())
g=[[] for _ in range(n+1)]
for _ in range(n-1):
a,b=map(int,input().split())
g[a].append(b)
g[b].append(a)
q=collections.deque()
q.append(1)
checked=set()
tracking=[]
while len(q)!=0:
v=q.popleft()
tracking.append(v)
checked.add(v)
for u in g[v]:
if u not in checked:
q.append(u)
child=[1]*(n+1)
checked=set()
edge_counts=[]
for v in tracking[::-1]:
checked.add(v)
for u in g[v]:
if u not in checked:
child[u]+=child[v]
edge_counts.append(child[v]*(n-child[v]))
edge_counts=sorted(edge_counts,reverse=True)
m=int(input())
primes=list(map(int,input().split()))
primes=sorted(primes,reverse=True)
if m>=n:
tmp=1
for i in range(m-n+2):
tmp*=primes[i]
tmp%=mod
tmp=[tmp]
for i in range(m-n+2,m):
tmp.append(primes[i])
primes=tmp
else:
for i in range(n-1-m):
primes.append(1)
ans=0
for i in range(n-1):
ans+=edge_counts[i]*primes[i]
ans%=mod
print(ans)
``` | output | 1 | 96,315 | 13 | 192,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
import io,os
from collections import deque
import bisect
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
RL = lambda : list(map(int, input().split(' ')))
#Level or height
def Levels(graph, V): #graph or tree
level = [None]*V
dfs = [] #required for dfs
st = [0] #stack
while st:
node = st.pop()
dfs.append(node)
for child in graph[node]:
if child==par[node]:
continue
par[child]=node
st.append(child)
return dfs
##########################
m = 10**9+7
def addEdge(a, b):
global adj
adj[a].append(b)
adj[b].append(a)
T = int(input())
for _ in range(T):
N = int(input())
count1 = [1] * (N)
par = [-1]*N
adj = [[] for i in range(N)]
for i in range(N-1):
x, y = map(int,input().split())
addEdge(x-1,y-1)
pp = int(input())
primes = RL()
dfs = Levels(adj,N)
#Counting descendants
for b in dfs[::-1]:
if b == 0:
break
count1[par[b]]+=count1[b]
################################
ma = []
for i in range(N):
ma.append((N-count1[i])*count1[i])
ma.sort(reverse=True)
primes.sort(reverse = True)
ans = 0
for i in range(1,max(0,len(primes)-(N-1))+1):
primes[0] = ((primes[0])%m*(primes[i]%m))%m
primes[i] = 0
primes.sort(reverse=True)
for i in range(len(ma)):
if i>=len(primes):
ans=((ans%m)+(ma[i]%m))%m
else:
ans=((ans%m)+((ma[i]%m)*(primes[i]%m))%m)%m
# mul = 1
# for i in range(len(primes)):
# mul = ((mul%m)*(primes[i]%m))%m
# ans = ((ma[0]%m)*(mul%m))%m
# print(mul,ans,ma)
# for i in range(1,len(ma)):
# ans=((ans%m)+(ma[i]%m))%m
print(ans%m)
``` | instruction | 0 | 96,316 | 13 | 192,632 |
Yes | output | 1 | 96,316 | 13 | 192,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
from collections import defaultdict
mod = 10 ** 9 + 7
def dfs(node):
ch = defaultdict(lambda :1)
stack=[node]
visited = [0 for i in range(n+1)]
visited[node]=1
for i in stack:
for j in tree[i]:
if not visited[j]:
visited[j]=i
stack.append(j)
while len(stack)>1:
nxt = stack.pop()
ch[visited[nxt]] += ch[nxt]
return sorted(ch.values())
for _ in range(int(input())):
n= int(input())
#Tree Creation
tree = defaultdict(list)
for i in range(n-1):
u,v = map(int,input().split())
tree[u].append(v)
tree[v].append(u)
children = dfs(1)
#Prime Restoration
k = int(input())
primes = sorted(map(int,input().split()))
for i in range(k-(n-1)):
curr = primes.pop()
primes[-1] = (curr*primes[-1])%mod
primes = [1]*max(n-1-k,0) + primes
#number of times a path is includes
passage = []
for i in range(n-1):
passage.append((children[i])*(n-children[i]))
passage.sort()
ans=0
for i,j in zip(primes,passage):
ans+=i*j
ans=ans%mod
#print(*primes)
#print(*passage)
print(ans%mod)
``` | instruction | 0 | 96,317 | 13 | 192,634 |
Yes | output | 1 | 96,317 | 13 | 192,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
t = int(input())
for _ in range(t):
n = int(input())
edge = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(int, input().split())
u -= 1; v -= 1
edge[u].append(v)
edge[v].append(u)
m = int(input())
pf = [int(item) for item in input().split()]
st = []
weight = [1] * n
cost = []
st.append((-1, 0, True))
while st:
p, v, is_decreasing = st.pop()
if is_decreasing:
if p != -1:
st.append((v, p, False))
for nv in edge[v]:
if nv == p:
continue
st.append((v, nv, True))
else:
cost.append(weight[p] * (n - weight[p]))
weight[v] += weight[p]
cost.sort()
pf.sort()
ret = 0
if len(pf) > len(cost):
accum = 1
for _ in range(len(pf) - len(cost)):
accum *= pf.pop()
accum %= MOD
pf[-1] *= accum
pf.reverse()
for item in pf:
ret += item * cost.pop()
ret %= MOD
ret += sum(cost)
print(ret % MOD)
``` | instruction | 0 | 96,318 | 13 | 192,636 |
Yes | output | 1 | 96,318 | 13 | 192,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
T = int(input())
MOD = 10**9 + 7
for testcase in range(T):
n = int(input())
edge = [[] for i in range(n)]
for _ in range(n-1):
u,v = map(int,input().split())
edge[u-1].append(v-1)
edge[v-1].append(u-1)
m = int(input())
p = list(map(int,input().split()))
par = [-2]*n
par[0] = -1
tank = [0]
order = []
while tank:
now = tank.pop()
order.append(now)
for nxt in edge[now]:
if par[nxt] == -2:
par[nxt] = now
tank.append(nxt)
size = [1]*n
for e in order[::-1]:
if e == 0:
continue
size[par[e]] += size[e]
for i in range(n):
size[i] *= (n-size[i])
#print(size)
if m <= n-1:
p.sort()
size.sort()
res = 0
for i in range(1,n):
if i < n-m:
res = (res + size[i])%MOD
else:
res = (res + size[i]*p[i-(n-m)])%MOD
print(res%MOD)
else:
p.sort()
size.sort()
res = 0
mul = 1
for i in range(m):
if i < n-2:
res = (res + size[i+1]*p[i])%MOD
else:
mul = mul*p[i]%MOD
res = (res + mul*size[-1])%MOD
print(res%MOD)
``` | instruction | 0 | 96,319 | 13 | 192,638 |
Yes | output | 1 | 96,319 | 13 | 192,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
from sys import stdin
def inp():
return stdin.buffer.readline().rstrip().decode('utf8')
def itg():
return int(stdin.buffer.readline())
def mpint():
return map(int, stdin.buffer.readline().split())
# ############################## import
# from ACgenerator.Calculator import tree_edge_descendant
def tree_edge_descendant(graph, edge_time_count=False):
"""
:return: a list for the number of vertices under each edge
if edge_time_count:
:return a list for the sum of times that walking on each edge
the walk mean the path of any pair (u, v) and (u < v)
"""
descendant_count = []
def dfs(u):
if not graph[u]:
return 0
descendant = 0
for v in graph[u]:
des = dfs(v) + 1
descendant_count.append(des)
descendant += des
return descendant
dfs(0)
if edge_time_count:
return list(map(lambda x: x * (len(graph) - x), descendant_count))
return descendant_count
# from ACgenerator.Tools import to_tree
def to_tree(graph, root=0):
"""
graph: undirected graph (adjacency list)
:return directed graph that parent -> children
"""
graph[:] = map(set, graph)
def dfs(v):
for e in graph[v]:
graph[e].remove(v)
dfs(e)
dfs(root)
graph[:] = map(list, graph)
# ############################## main
from functools import reduce
MOD = int(1e9) + 7
g = []
def solve():
for __ in range(itg()):
n = itg()
g = [list() for _ in range(n)]
for _ in range(n - 1):
u, v = mpint()
g[u - 1].append(v - 1)
g[v - 1].append(u - 1)
to_tree(g)
m = itg()
factors = sorted(mpint())
count = sorted(tree_edge_descendant(g, True))
n -= 1
if n >= m:
factors = ([1] * (n - m)) + factors
else: # n < m
while len(factors) != n:
factors[-1] = factors[-2] * factors.pop()
print(
reduce(
lambda a, b: (a + b) % MOD,
((time % MOD) * (value % MOD) % MOD for time, value in zip(count, factors)),
0
)
)
from sys import setrecursionlimit
import threading
if __name__ == "__main__":
setrecursionlimit(200000)
threading.stack_size(int(1e7))
thread = threading.Thread(target=solve)
thread.start()
# Please check!
``` | instruction | 0 | 96,320 | 13 | 192,640 |
No | output | 1 | 96,320 | 13 | 192,641 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
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
@bootstrap
def dfs(node,edge,parentNode):
subtreeNodeCnt=1
for v,edge2 in adj[node]:
if v==parentNode:continue
subtreeNodeCnt+=(yield dfs(v,edge2,node))
evc[edge]+=subtreeNodeCnt*(n-subtreeNodeCnt) #number of nodes in subtree * number of nodes outside subtree (separated by edge)
yield subtreeNodeCnt
import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
M=10**9+7
t=int(input())
for _ in range(t):
n=int(input())
adj=[[] for __ in range(n+1)] #[next node, edge number]
for i in range(n-1):
u,v=[int(x) for x in input().split()]
adj[u].append([v,i])
adj[v].append([u,i])
m=int(input())
p=[int(x) for x in input().split()]
if len(p)<n-1: #m<n-1 edges
p.sort(reverse=True)
while len(p)<n-1: #m<n-1 edges
p.append(1) #the remaining edges are labelled with 1s
if len(p)>n-1: #opposite case: m>n-1
p.sort()
while len(p)>n-1: #opposite case: m>n-1
p[-2]=p[-2]*p[-1]
p.pop()
p.reverse()
evc=[0 for __ in range(n)] #evc[i]=edge visit counts of edge i.evc[n-1] is a dummy for 0th edge
dfs(1,n-1,-1)
evc.pop() #get rid of dummy last edge
evc.sort(reverse=True)
ans=0
for i in range(n-1):
ans+=((evc[i]%M)*(p[i]%M))%M
# print(evc)
# print(p)
print(ans)
``` | instruction | 0 | 96,321 | 13 | 192,642 |
No | output | 1 | 96,321 | 13 | 192,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree that consists of n nodes. You should label each of its n-1 edges with an integer in such way that satisfies the following conditions:
* each integer must be greater than 0;
* the product of all n-1 numbers should be equal to k;
* the number of 1-s among all n-1 integers must be minimum possible.
Let's define f(u,v) as the sum of the numbers on the simple path from node u to node v. Also, let ∑_{i=1}^{n-1} ∑_{j=i+1}^n f(i,j) be a distribution index of the tree.
Find the maximum possible distribution index you can get. Since answer can be too large, print it modulo 10^9 + 7.
In this problem, since the number k can be large, the result of the prime factorization of k is given instead.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines describes an edge: the i-th line contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — indices of vertices connected by the i-th edge.
Next line contains a single integer m (1 ≤ m ≤ 6 ⋅ 10^4) — the number of prime factors of k.
Next line contains m prime numbers p_1, p_2, …, p_m (2 ≤ p_i < 6 ⋅ 10^4) such that k = p_1 ⋅ p_2 ⋅ … ⋅ p_m.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5, the sum of m over all test cases doesn't exceed 6 ⋅ 10^4, and the given edges for each test cases form a tree.
Output
Print the maximum distribution index you can get. Since answer can be too large, print it modulo 10^9+7.
Example
Input
3
4
1 2
2 3
3 4
2
2 2
4
3 4
1 3
3 2
2
3 2
7
6 1
2 3
4 6
7 3
5 1
3 6
4
7 5 13 3
Output
17
18
286
Note
In the first test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=1, f(1,3)=3, f(1,4)=5, f(2,3)=2, f(2,4)=4, f(3,4)=2, so the sum of these 6 numbers is 17.
In the second test case, one of the optimal ways is on the following image:
<image>
In this case, f(1,2)=3, f(1,3)=1, f(1,4)=4, f(2,3)=2, f(2,4)=5, f(3,4)=3, so the sum of these 6 numbers is 18.
Submitted Solution:
```
'''
Name : Jaymeet Mehta
codeforces id :mj_13
Problem :
'''
from sys import stdin,stdout
mod=1e9+7
def dfs(u):
global graph,visited,sub
visited[u]=True
sub[u]=1
for v in graph[u]:
if not visited[v]:
sub[u]+=dfs(v)
return sub[u]
def add(a,b):
global mod
return (a+b)%mod
def mul(a,b):
global mod
return (a*b)%mod
test=int(stdin.readline())
for _ in range(test):
n=int(stdin.readline())
graph=[[] for i in range(n)]
for i in range(n-1):
u,v = map(int,stdin.readline().split())
graph[u-1].append(v-1)
graph[v-1].append(u-1)
m = int(stdin.readline())
f = [int(x) for x in stdin.readline().split()]
visited=[False for i in range(n)]
sub=[0 for i in range(n)]
dfs(0)
cont=[]
for i in range(1,n):
ans=sub[i]*(n-sub[i])
cont.append(ans)
f.sort()
cont.sort()
for i in range(m,n-1):
f.append(1)
ans=0
while(len(f)>n-1):
f[-2]=(f[-1]*f[-2])%mod
a=f.pop()
for i in range(n-1):
ans=(ans+cont[i] * f[i] %mod)%mod
print(int(ans))
``` | instruction | 0 | 96,322 | 13 | 192,644 |
No | output | 1 | 96,322 | 13 | 192,645 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.