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 tags and a correct Python 3 solution for this coding contest problem.
You are given a tree with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots. | instruction | 0 | 41,484 | 13 | 82,968 |
Tags: data structures, dfs and similar, dp, trees
Correct Solution:
```
import io, os;from collections import Counter, defaultdict, deque
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
_default = default;self._func = func;self._len = len(data);self._size = _size = 1 << (self._len - 1).bit_length();self._lazy = [0] * (2 * _size);self.data = [default] * (2 * _size);self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):return self._len
def _push(self, idx):q, self._lazy[idx] = self._lazy[idx], 0;self._lazy[2 * idx] += q;self._lazy[2 * idx + 1] += q;self.data[2 * idx] += q;self.data[2 * idx + 1] += q
def _update(self, idx):
for i in reversed(range(1, idx.bit_length())):self._push(idx >> i)
def _build(self, idx):
idx >>= 1
while idx:self.data[idx] = (self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]);idx >>= 1
def add(self, start, stop, value):
if start == stop:return
start = start_copy = start + self._size;stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=0):
start += self._size
stop += self._size
self._update(start)
self._update(stop - 1)
res = default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self): return "LazySegmentTree({0})".format(self.data)
def solve(N, A, edges):
graph = [[] for i in range(N)]
for u, indices in edges:graph[u].append(indices);graph[indices].append(u)
eulerTour = [];root = 0;stack = [root];seen = [False] * len(graph)
while stack:
node = stack.pop();eulerTour.append(node)
if not seen[node]:
seen[node] = True
for nbr in graph[node]:
if not seen[nbr]:stack.append(node);stack.append(nbr)
assert eulerTour[0] == eulerTour[-1];eulerTour.pop();tourByValues = defaultdict(list)
for i, x in enumerate(eulerTour):tourByValues[A[x]].append(i)
segTree = LazySegmentTree([0] * len(eulerTour), 0, lambda x, y: x + y)
for k, indices in tourByValues.items():
nodes = set(eulerTour[i] for i in indices)
if len(nodes) >= 2:
for i in indices:segTree.add(i, i + 1, 1)
subtour = []
for i, j in zip(indices, indices[1:]):
x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, j + 1, 1)
else:subtour.append(i)
i = indices[-1];j = indices[0];x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, len(eulerTour), 1);segTree.add(0, j + 1, 1)
else:subtour.append(i)
if len(nodes) != len(subtour):return 0
if False:
print("label", k, "visits", indices, "nodes", nodes);print("\t".join(str(eulerTour[i]) + ":" + str(A[eulerTour[i]]) for i in range(len(eulerTour))))
for i in range(len(eulerTour)):print("x", end="\t") if segTree.query(i, i + 1) != 0 else print("o", end="\t")
print();print()
return N - len(set([eulerTour[i] for i in range(len(eulerTour)) if segTree.query(i, i + 1) != 0]))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N = int(input());A = [int(x) for x in input().split()];e = [[int(x) - 1 for x in input().split()] for i in range(N - 1)];print(solve(N, A, e))
``` | output | 1 | 41,484 | 13 | 82,969 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots. | instruction | 0 | 41,485 | 13 | 82,970 |
Tags: data structures, dfs and similar, dp, trees
Correct Solution:
```
import io
import os
from collections import Counter, defaultdict, deque
# https://raw.githubusercontent.com/cheran-senthil/PyRival/master/pyrival/data_structures/LazySegmentTree.py
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the lazy segment tree with data"""
_default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self._lazy = [0] * (2 * _size)
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):
return self._len
def _push(self, idx):
"""push query on idx to its children"""
# Let the children know of the queries
q, self._lazy[idx] = self._lazy[idx], 0
self._lazy[2 * idx] += q
self._lazy[2 * idx + 1] += q
self.data[2 * idx] += q
self.data[2 * idx + 1] += q
def _update(self, idx):
"""updates the node idx to know of all queries applied to it via its ancestors"""
for i in reversed(range(1, idx.bit_length())):
self._push(idx >> i)
def _build(self, idx):
"""make the changes to idx be known to its ancestors"""
idx >>= 1
while idx:
self.data[idx] = (
self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
)
idx >>= 1
def add(self, start, stop, value):
"""lazily add value to [start, stop)"""
if start == stop:
return
start = start_copy = start + self._size
stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
# Tell all nodes above of the updated area of the updates
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=0):
"""func of data[start, stop)"""
start += self._size
stop += self._size
# Apply all the lazily stored queries
self._update(start)
self._update(stop - 1)
res = default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "LazySegmentTree({0})".format(self.data)
def solve(N, A, edges):
graph = [[] for i in range(N)]
for u, indices in edges:
graph[u].append(indices)
graph[indices].append(u)
# Build euler tour
eulerTour = []
root = 0
stack = [root]
seen = [False] * len(graph)
while stack:
node = stack.pop()
eulerTour.append(node)
if not seen[node]:
seen[node] = True
for nbr in graph[node]:
if not seen[nbr]:
stack.append(node)
stack.append(nbr)
assert eulerTour[0] == eulerTour[-1]
eulerTour.pop()
# Group the tour by values
tourByValues = defaultdict(list)
for i, x in enumerate(eulerTour):
tourByValues[A[x]].append(i)
# Track which part of the tour definitely can't be root (0 is good, positive is bad)
segTree = LazySegmentTree([0] * len(eulerTour), 0, lambda x, y: x + y)
for k, indices in tourByValues.items():
nodes = set(eulerTour[i] for i in indices)
if len(nodes) >= 2:
# Dupes can't be root
for i in indices:
segTree.add(i, i + 1, 1)
# Get tour of the subtree with same values
# If adjacent are the same, is actually visiting outside of the subtree (all of which can't be root)
# Otherwise is part of the subtour
subtour = []
for i, j in zip(indices, indices[1:]):
x = eulerTour[i]
y = eulerTour[j]
if x == y:
segTree.add(i, j + 1, 1)
else:
subtour.append(i)
i = indices[-1]
j = indices[0]
x = eulerTour[i]
y = eulerTour[j]
if x == y:
segTree.add(i, len(eulerTour), 1)
segTree.add(0, j + 1, 1)
else:
subtour.append(i)
if len(nodes) != len(subtour):
# Subtour has non leaves, impossible
return 0
if False:
print("label", k, "visits", indices, "nodes", nodes)
print(
"\t".join(
str(eulerTour[i]) + ":" + str(A[eulerTour[i]])
for i in range(len(eulerTour))
)
)
for i in range(len(eulerTour)):
if segTree.query(i, i + 1) != 0:
print("x", end="\t")
else:
print("o", end="\t")
print()
print()
ans = set()
for i in range(len(eulerTour)):
if segTree.query(i, i + 1) != 0:
ans.add(eulerTour[i])
return N - len(set(ans))
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = 1
for tc in range(1, TC + 1):
(N,) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
edges = [[int(x) - 1 for x in input().split()] for i in range(N - 1)]
ans = solve(N, A, edges)
print(ans)
``` | output | 1 | 41,485 | 13 | 82,971 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots. | instruction | 0 | 41,486 | 13 | 82,972 |
Tags: data structures, dfs and similar, dp, trees
Correct Solution:
```
import io, os;from collections import Counter, defaultdict, deque
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
_default = default;self._func = func;self._len = len(data);self._size = _size = 1 << (self._len - 1).bit_length();self._lazy = [0] * (2 * _size);self.data = [default] * (2 * _size);self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):return self._len
def _push(self, idx):q, self._lazy[idx] = self._lazy[idx], 0;self._lazy[2 * idx] += q;self._lazy[2 * idx + 1] += q;self.data[2 * idx] += q;self.data[2 * idx + 1] += q
def _update(self, idx):
for i in reversed(range(1, idx.bit_length())):self._push(idx >> i)
def _build(self, idx):
idx >>= 1
while idx:self.data[idx] = (self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]);idx >>= 1
def add(self, start, stop, value):
if start == stop:return
start = start_copy = start + self._size;stop = stop_copy = stop + self._size
while start < stop:
if start & 1:self._lazy[start] += value;self.data[start] += value;start += 1
if stop & 1:stop -= 1;self._lazy[stop] += value;self.data[stop] += value
start >>= 1;stop >>= 1
self._build(start_copy);self._build(stop_copy - 1)
def query(self, start, stop, default=0):
start += self._size;stop += self._size;self._update(start);self._update(stop - 1);res = default
while start < stop:
if start & 1:res = self._func(res, self.data[start]);start += 1
if stop & 1:stop -= 1;res = self._func(res, self.data[stop])
start >>= 1;stop >>= 1
return res
def __repr__(self): return "LazySegmentTree({0})".format(self.data)
def solve(N, A, edges):
graph = [[] for i in range(N)]
for u, indices in edges:graph[u].append(indices);graph[indices].append(u)
eulerTour = [];root = 0;stack = [root];seen = [False] * len(graph)
while stack:
node = stack.pop();eulerTour.append(node)
if not seen[node]:
seen[node] = True
for nbr in graph[node]:
if not seen[nbr]:stack.append(node);stack.append(nbr)
assert eulerTour[0] == eulerTour[-1];eulerTour.pop();tourByValues = defaultdict(list)
for i, x in enumerate(eulerTour):tourByValues[A[x]].append(i)
segTree = LazySegmentTree([0] * len(eulerTour), 0, lambda x, y: x + y)
for k, indices in tourByValues.items():
nodes = set(eulerTour[i] for i in indices)
if len(nodes) >= 2:
for i in indices:segTree.add(i, i + 1, 1)
subtour = []
for i, j in zip(indices, indices[1:]):
x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, j + 1, 1)
else:subtour.append(i)
i = indices[-1];j = indices[0];x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, len(eulerTour), 1);segTree.add(0, j + 1, 1)
else:subtour.append(i)
if len(nodes) != len(subtour):return 0
if False:
print("label", k, "visits", indices, "nodes", nodes);print("\t".join(str(eulerTour[i]) + ":" + str(A[eulerTour[i]]) for i in range(len(eulerTour))))
for i in range(len(eulerTour)):print("x", end="\t") if segTree.query(i, i + 1) != 0 else print("o", end="\t")
print();print()
return N - len(set([eulerTour[i] for i in range(len(eulerTour)) if segTree.query(i, i + 1) != 0]))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N = int(input());A = [int(x) for x in input().split()];e = [[int(x) - 1 for x in input().split()] for i in range(N - 1)];print(solve(N, A, e))
``` | output | 1 | 41,486 | 13 | 82,973 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots. | instruction | 0 | 41,487 | 13 | 82,974 |
Tags: data structures, dfs and similar, dp, trees
Correct Solution:
```
import io, os
from collections import Counter, defaultdict, deque
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
_default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self._lazy = [0] * (2 * _size)
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):
return self._len
def _push(self, idx):
q, self._lazy[idx] = self._lazy[idx], 0
self._lazy[2 * idx] += q
self._lazy[2 * idx + 1] += q
self.data[2 * idx] += q
self.data[2 * idx + 1] += q
def _update(self, idx):
for i in reversed(range(1, idx.bit_length())):
self._push(idx >> i)
def _build(self, idx):
idx >>= 1
while idx:
self.data[idx] = (
self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
)
idx >>= 1
def add(self, start, stop, value):
if start == stop:
return
start = start_copy = start + self._size
stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=0):
start += self._size
stop += self._size
self._update(start)
self._update(stop - 1)
res = default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "LazySegmentTree({0})".format(self.data)
def solve(N, A, edges):
graph = [[] for i in range(N)]
for u, indices in edges:
graph[u].append(indices)
graph[indices].append(u)
# Build euler tour
eulerTour = []
root = 0
stack = [root]
seen = [False] * len(graph)
while stack:
node = stack.pop()
eulerTour.append(node)
if not seen[node]:
seen[node] = True
for nbr in graph[node]:
if not seen[nbr]:
stack.append(node)
stack.append(nbr)
assert eulerTour[0] == eulerTour[-1]
eulerTour.pop()
tourByValues = defaultdict(list)
for i, x in enumerate(eulerTour):
tourByValues[A[x]].append(i)
segTree = LazySegmentTree([0] * len(eulerTour), 0, lambda x, y: x + y)
for k, indices in tourByValues.items():
nodes = set(eulerTour[i] for i in indices)
if len(nodes) >= 2:
for i in indices:
segTree.add(i, i + 1, 1)
subtour = []
for i, j in zip(indices, indices[1:]):
x = eulerTour[i]
y = eulerTour[j]
if x == y:
segTree.add(i, j + 1, 1)
else:
subtour.append(i)
i = indices[-1]
j = indices[0]
x = eulerTour[i]
y = eulerTour[j]
if x == y:
segTree.add(i, len(eulerTour), 1)
segTree.add(0, j + 1, 1)
else:
subtour.append(i)
if len(nodes) != len(subtour):
# Subtour has non leaves, impossible
return 0
if False:
print("label", k, "visits", indices, "nodes", nodes)
print(
"\t".join(
str(eulerTour[i]) + ":" + str(A[eulerTour[i]])
for i in range(len(eulerTour))
)
)
for i in range(len(eulerTour)):
if segTree.query(i, i + 1) != 0:
print("x", end="\t")
else:
print("o", end="\t")
print()
print()
return N - len(set([eulerTour[i] for i in range(len(eulerTour)) if segTree.query(i, i + 1) != 0]))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N = int(input());A = [int(x) for x in input().split()];e = [[int(x) - 1 for x in input().split()] for i in range(N - 1)];print(solve(N, A, e))
``` | output | 1 | 41,487 | 13 | 82,975 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots. | instruction | 0 | 41,488 | 13 | 82,976 |
Tags: data structures, dfs and similar, dp, trees
Correct Solution:
```
import io, os
from collections import Counter, defaultdict, deque
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
_default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self._lazy = [0] * (2 * _size)
self.data = [default] * (2 * _size)
self.data[_size : _size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):
return self._len
def _push(self, idx):
q, self._lazy[idx] = self._lazy[idx], 0
self._lazy[2 * idx] += q
self._lazy[2 * idx + 1] += q
self.data[2 * idx] += q
self.data[2 * idx + 1] += q
def _update(self, idx):
for i in reversed(range(1, idx.bit_length())):
self._push(idx >> i)
def _build(self, idx):
idx >>= 1
while idx:
self.data[idx] = (
self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
)
idx >>= 1
def add(self, start, stop, value):
if start == stop:
return
start = start_copy = start + self._size
stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=0):
start += self._size
stop += self._size
self._update(start)
self._update(stop - 1)
res = default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "LazySegmentTree({0})".format(self.data)
def solve(N, A, edges):
graph = [[] for i in range(N)]
for u, indices in edges:
graph[u].append(indices)
graph[indices].append(u)
# Build euler tour
eulerTour = []
root = 0
stack = [root]
seen = [False] * len(graph)
while stack:
node = stack.pop()
eulerTour.append(node)
if not seen[node]:
seen[node] = True
for nbr in graph[node]:
if not seen[nbr]:
stack.append(node)
stack.append(nbr)
assert eulerTour[0] == eulerTour[-1];eulerTour.pop();tourByValues = defaultdict(list)
for i, x in enumerate(eulerTour):tourByValues[A[x]].append(i)
segTree = LazySegmentTree([0] * len(eulerTour), 0, lambda x, y: x + y)
for k, indices in tourByValues.items():
nodes = set(eulerTour[i] for i in indices)
if len(nodes) >= 2:
for i in indices:segTree.add(i, i + 1, 1)
subtour = []
for i, j in zip(indices, indices[1:]):
x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, j + 1, 1)
else:subtour.append(i)
i = indices[-1];j = indices[0];x = eulerTour[i];y = eulerTour[j]
if x == y:segTree.add(i, len(eulerTour), 1);segTree.add(0, j + 1, 1)
else:subtour.append(i)
if len(nodes) != len(subtour):return 0
if False:
print("label", k, "visits", indices, "nodes", nodes);print("\t".join(str(eulerTour[i]) + ":" + str(A[eulerTour[i]]) for i in range(len(eulerTour))))
for i in range(len(eulerTour)):print("x", end="\t") if segTree.query(i, i + 1) != 0 else print("o", end="\t")
print();print()
return N - len(set([eulerTour[i] for i in range(len(eulerTour)) if segTree.query(i, i + 1) != 0]))
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N = int(input());A = [int(x) for x in input().split()];e = [[int(x) - 1 for x in input().split()] for i in range(N - 1)];print(solve(N, A, e))
``` | output | 1 | 41,488 | 13 | 82,977 |
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 with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots.
Submitted Solution:
```
from collections import deque
N = int(input())
aa = [int(x) for x in input().split()]
adj_list = {}
degrees = {}
edges = []
for i in range(N-1):
u, v = tuple([int(x) for x in input().split()])
u -= 1
v -= 1
if u not in adj_list:
adj_list[u] = set()
degrees[u] = 0
if v not in adj_list:
adj_list[v] = set()
degrees[v] = 0
adj_list[u].add(v)
degrees[u] += 1
adj_list[v].add(u)
degrees[v] += 1
edges.append((u, v))
# Preprocess aa
aa_count = {}
for a in aa:
aa_count[a] = aa_count.get(a, 0) + 1
bb = aa.copy()
for i in range(len(aa)):
if aa_count.get(aa[i], 0) < 2:
bb[i] = 0
else:
bb[i] = aa[i]
# Create compact graph
nodes = {}
old_new_node_map = {}
adjs = {}
degs = {}
has_visit = set()
## Group the nodes
for i in range(N):
if aa_count.get(aa[i]) >= 2:
nodes[i] = set([i])
old_new_node_map[i] = i
has_visit.add(i)
continue
if i in has_visit:
continue
# Flood fill from i and group all of the cluster as one node on the compact graph and represented by i
q = deque([i])
nodes[i] = set([i])
old_new_node_map[i] = i
while len(q) > 0:
cur_node = q.popleft()
for neigh in adj_list[cur_node]:
if neigh not in has_visit:
has_visit.add(neigh)
if aa_count.get(aa[neigh]) < 2:
q.append(neigh)
old_new_node_map[neigh] = i
nodes[i].add(neigh)
## Create adjs
for u, v in edges:
new_u = old_new_node_map[u]
new_v = old_new_node_map[v]
if new_u == new_v:
continue
if new_u not in adjs:
adjs[new_u] = set()
if new_v not in adjs:
adjs[new_v] = set()
adjs[new_u].add(new_v)
degs[new_u] = degs.get(new_u, 0) + 1
adjs[new_v].add(new_u)
degs[new_v] = degs.get(new_v, 0) + 1
#print(nodes)
#print(adjs)
leaves = []
for node in nodes:
if degs.get(node, 0) == 1:
leaves.append(node)
q = deque(leaves)
path_states = {}
for node in leaves:
path_states[node] = set()
cur_degs = degs.copy()
has_visit = set(leaves)
has_delete = set()
# print(q)
while len(q) > 0:
cur_node = q.popleft()
do_delete = False
# print(path_states, q, cur_node)
for neigh in adjs[cur_node]:
if neigh in path_states[cur_node]:
continue
if neigh in has_delete:
continue
do_delete = True
if neigh not in path_states:
path_states[neigh] = path_states[cur_node]
else:
path_states[neigh] |= path_states[cur_node]
if aa_count.get(aa[cur_node]) >= 2:
path_states[neigh].add(cur_node)
cur_degs[neigh] -= 1
if cur_degs[neigh] == 1:
q.append(neigh)
has_visit.add(neigh)
if do_delete:
del path_states[cur_node]
has_delete.add(cur_node)
# print('path_states: ', path_states)
if len(path_states) == 1:
# We have solution!
repr_node = None
for key in path_states:
repr_node = key
# print('repr_node: ', repr_node)
print(len(nodes[repr_node]))
else:
print(0)
``` | instruction | 0 | 41,489 | 13 | 82,978 |
No | output | 1 | 41,489 | 13 | 82,979 |
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 with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots.
Submitted Solution:
```
import collections,functools,sys
input = sys.stdin.readline
n = int(input())
arr = list(map(int,input().split()))
tree = collections.defaultdict(list)
for i in range(n-1):
a,b = map(int,input().split())
tree[a].append(b)
tree[b].append(a)
#print(tree)
sys.setrecursionlimit(150000)
def fun(a,pre):
if values[arr[a-1]] > 0:
nodes.add(a-1)
values[arr[a-1]] += 1
for i in tree[a]:
if i == pre:
continue
fun(i,a)
values[arr[a-1]] -= 1
pre = set()
for i in range(1,n+1):
if i in pre:
continue
values = collections.Counter()
nodes = set()
fun(i,-1)
if nodes == set():
continue
else:
pre.update(nodes)
pre.add(i-1)
print(n-len(pre))
``` | instruction | 0 | 41,490 | 13 | 82,980 |
No | output | 1 | 41,490 | 13 | 82,981 |
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 with n vertices. Each vertex i has a value a_i associated with it.
Let us root the tree at some vertex v. The vertex v is called a distinctive root if the following holds: in all paths that start at v and end at some other node, all the values encountered are distinct. Two different paths may have values in common but a single path must have all distinct values.
Find the number of distinctive roots in the tree.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2⋅10^5) — the number of vertices in the tree.
The next line contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
The following n-1 lines each contain two space-separated integers u and v (1 ≤ u, v ≤ n), denoting an edge from u to v.
It is guaranteed that the edges form a tree.
Output
Print a single integer — the number of distinctive roots in the tree.
Examples
Input
5
2 5 1 1 4
1 2
1 3
2 4
2 5
Output
3
Input
5
2 1 1 1 4
1 2
1 3
2 4
2 5
Output
0
Note
In the first example, 1, 2 and 5 are distinctive roots.
Submitted Solution:
```
from collections import deque
N = int(input())
aa = [int(x) for x in input().split()]
adj_list = {}
degrees = {}
edges = []
for i in range(N-1):
u, v = tuple([int(x) for x in input().split()])
u -= 1
v -= 1
if u not in adj_list:
adj_list[u] = set()
degrees[u] = 0
if v not in adj_list:
adj_list[v] = set()
degrees[v] = 0
adj_list[u].add(v)
degrees[u] += 1
adj_list[v].add(u)
degrees[v] += 1
edges.append((u, v))
# Preprocess aa
aa_count = {}
for a in aa:
aa_count[a] = aa_count.get(a, 0) + 1
bb = aa.copy()
for i in range(len(aa)):
if aa_count.get(aa[i], 0) < 2:
bb[i] = 0
else:
bb[i] = aa[i]
# Create compact graph
nodes = {}
old_new_node_map = {}
adjs = {}
degs = {}
has_visit = set()
## Group the nodes
for i in range(N):
if aa_count.get(aa[i]) >= 2:
nodes[i] = set([i])
old_new_node_map[i] = i
has_visit.add(i)
continue
if i in has_visit:
continue
# Flood fill from i and group all of the cluster as one node on the compact graph and represented by i
q = deque([i])
nodes[i] = set([i])
old_new_node_map[i] = i
while len(q) > 0:
cur_node = q.popleft()
for neigh in adj_list[cur_node]:
if neigh not in has_visit:
has_visit.add(neigh)
if aa_count.get(aa[neigh]) < 2:
q.append(neigh)
old_new_node_map[neigh] = i
nodes[i].add(neigh)
## Create adjs
for u, v in edges:
new_u = old_new_node_map[u]
new_v = old_new_node_map[v]
if new_u == new_v:
continue
if new_u not in adjs:
adjs[new_u] = set()
if new_v not in adjs:
adjs[new_v] = set()
adjs[new_u].add(new_v)
degs[new_u] = degs.get(new_u, 0) + 1
adjs[new_v].add(new_u)
degs[new_v] = degs.get(new_v, 0) + 1
#print(nodes)
#print(adjs)
leaves = []
for node in nodes:
if degs.get(node, 0) == 1:
leaves.append(node)
q = deque(leaves)
path_states = {}
for node in leaves:
path_states[node] = set()
cur_degs = degs.copy()
has_visit = set(leaves)
has_delete = set()
# print(q)
while len(q) > 0:
cur_node = q.popleft()
if aa_count.get(aa[cur_node]) >= 2:
path_states[cur_node].add(cur_node)
do_delete = False
# print(path_states, q, cur_node)
for neigh in adjs[cur_node]:
if neigh in path_states[cur_node]:
continue
if neigh in has_delete:
continue
do_delete = True
if neigh not in path_states:
path_states[neigh] = path_states[cur_node]
else:
path_states[neigh] |= path_states[cur_node]
cur_degs[neigh] -= 1
if cur_degs[neigh] == 1:
q.append(neigh)
has_visit.add(neigh)
if do_delete:
del path_states[cur_node]
has_delete.add(cur_node)
# print('path_states: ', path_states)
if len(path_states) == 1:
# We have solution!
repr_node = None
for key in path_states:
repr_node = key
# print('repr_node: ', repr_node)
print(len(nodes[repr_node]))
else:
print(0)
``` | instruction | 0 | 41,491 | 13 | 82,982 |
No | output | 1 | 41,491 | 13 | 82,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
<image>
Is it possible for Limak to draw chosen tree?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
Output
Print "Yes" (without the quotes) if Limak can draw chosen tree. Otherwise, print "No" (without the quotes).
Examples
Input
8
1 2
1 3
1 6
6 4
6 7
6 5
7 8
Output
Yes
Input
13
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
Output
No
Submitted Solution:
```
n = int(input())
a = []
for i in range(n + 1):
a.append([0])
for i in range(n - 1):
b, c = map(int, input().split())
a[b].append(c)
a[c].append(b)
sta = True
for i in range(1, n + 1):
b = []
st = 0
for j in a[i]:
if len(a[j]) != 1:
b.append(len(a[j]) - 2)
print(b)
for j in range(len(b)):
if b[j] > 2:
st += 1
if st > 2:
sta = False
if sta:
print('Yes')
else:
print('No')
``` | instruction | 0 | 41,637 | 13 | 83,274 |
No | output | 1 | 41,637 | 13 | 83,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
<image>
Is it possible for Limak to draw chosen tree?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
Output
Print "Yes" (without the quotes) if Limak can draw chosen tree. Otherwise, print "No" (without the quotes).
Examples
Input
8
1 2
1 3
1 6
6 4
6 7
6 5
7 8
Output
Yes
Input
13
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
Output
No
Submitted Solution:
```
# import sys
# sys.stdin=open("D:/i.txt","r")
n=int(input())
neighbours=[]
for i in range(n):
neighbours.append([])
for i in range(n-1):
x,y=[int(x) for x in input().split(' ')]
x-=1
y-=1
neighbours[x].append(y)
neighbours[y].append(x)
# print(neighbours)
parents=[0]*n
done=set()
done.add(0)
stack=[0]
while(len(done)!=n):
parent=stack.pop()
for x in neighbours[parent]:
if(not(x in done)):
done.add(x)
parents[x]=parent
stack.append(x)
parents[0]=-1
# print(parents)
num_daughters=[0]*n
for i in range(n):
num_daughters[i]=len(neighbours[i])-1
num_daughters[0]+=1
# print(num_daughters)
leaves=[]
for i in range(n):
if(len(neighbours[i])==1 and i!=0):
leaves.append(i)
# print(leaves)
raw_status=[0]*n
for i in range(n):
if(num_daughters[i]>2):
raw_status[i]=1
if(num_daughters[i]==2 and parents[i]!=-1):
raw_status[parents[i]]=1
# print(raw_status)
status=[-1]*n
for x in leaves:
node=x
stat=0
status[node]=stat
while(True):
node=parents[node]
if(node==-1):
break
if(status[node]!=-1):
break
else:
if(stat==1):
status[node]=1
else:
if(raw_status[node]==0):
status[node]=0
else:
status[node]=1
stat=1
# print(status)
red=set()
for i in range(n):
if(status[i]):
red.add(i)
# print(red)
# num_of_red_daughters=[0]*n
# for i in range(n):
# for j in range(len(neighbours[i])):
# if(neighbours[i][j]!=parents[i]):
# if(neighbours[i][j] in red):
# num_of_red_daughters[i]+=1
num_of_red_neighbours=[0]*n
for i in range(n):
for j in range(len(neighbours[i])):
if(neighbours[i][j] in red):
num_of_red_neighbours[i]+=1
# num_of_red_daughters.sort()
# num_of_red_daughters.reverse()
# print(num_of_red_daughters)
# if(num_of_red_daughters[0]>2):
# print('No')
# else:
# bhul=True
# for i in range(1,n):
# if(num_of_red_daughters[i]>1):
# bhul=False
# print('No')
# break
# if(bhul):
# print('Yes')
# print(num_of_red_neighbours)
bhul=1
for i in range(n):
if(num_of_red_neighbours[i]>2):
bhul=0
print('No')
break
if(bhul):
print('Yes')
``` | instruction | 0 | 41,638 | 13 | 83,276 |
No | output | 1 | 41,638 | 13 | 83,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
<image>
Is it possible for Limak to draw chosen tree?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
Output
Print "Yes" (without the quotes) if Limak can draw chosen tree. Otherwise, print "No" (without the quotes).
Examples
Input
8
1 2
1 3
1 6
6 4
6 7
6 5
7 8
Output
Yes
Input
13
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
Output
No
Submitted Solution:
```
# import sys
# sys.stdin=open("D:/i.txt","r")
n=int(input())
neighbours=[]
for i in range(n):
neighbours.append([])
for i in range(n-1):
x,y=[int(x) for x in input().split(' ')]
x-=1
y-=1
neighbours[x].append(y)
neighbours[y].append(x)
# print(neighbours)
parents=[0]*n
done=set()
done.add(0)
stack=[0]
while(len(done)!=n):
parent=stack.pop()
for x in neighbours[parent]:
if(not(x in done)):
done.add(x)
parents[x]=parent
stack.append(x)
parents[0]=-1
# print(parents)
num_daughters=[0]*n
for i in range(n):
num_daughters[i]=len(neighbours[i])-1
num_daughters[0]+=1
# print(num_daughters)
leaves=[]
for i in range(n):
if(len(neighbours[i])==1 and i!=0):
leaves.append(i)
# print(leaves)
raw_status=[0]*n
for i in range(n):
if(num_daughters[i]>2):
raw_status[i]=1
if(num_daughters[i]==2 and parents[i]!=-1):
raw_status[parents[i]]=1
# print(raw_status)
status=[-1]*n
for x in leaves:
node=x
stat=0
status[node]=stat
while(True):
node=parents[node]
if(node==-1):
break
if(status[node]!=-1):
break
else:
if(stat==1):
status[node]=1
else:
if(raw_status[node]==0):
status[node]=0
else:
status[node]=1
stat=1
# print(status)
red=set()
for i in range(n):
if(status[i]):
red.add(i)
# print(red)
num_of_red_daughters=[0]*n
for i in range(n):
for j in range(len(neighbours[i])):
if(neighbours[i][j]!=parents[i]):
if(neighbours[i][j] in red):
num_of_red_daughters[i]+=1
# print(num_of_red_daughters)
if(num_of_red_daughters[0]>2):
print('No')
else:
bhul=True
for i in range(1,n):
if(num_of_red_daughters[i]>1):
bhul=False
print('No')
break
if(bhul):
print('Yes')
``` | instruction | 0 | 41,639 | 13 | 83,278 |
No | output | 1 | 41,639 | 13 | 83,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
<image>
Is it possible for Limak to draw chosen tree?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
Output
Print "Yes" (without the quotes) if Limak can draw chosen tree. Otherwise, print "No" (without the quotes).
Examples
Input
8
1 2
1 3
1 6
6 4
6 7
6 5
7 8
Output
Yes
Input
13
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
Output
No
Submitted Solution:
```
def solve(n, Es, degree):
if n <= 4:
return True
n_valid, Es, degree = trim_deg2(n, Es, degree)
if n_valid <= 4:
return True
simple = mark_simple(n, Es, degree)
complexity = mark_complexity(n, Es, degree, simple)
pos, maxc = find_most_complex(complexity)
if maxc >= 3:
return False
if maxc == 0:
return True
LR = []
for npos in Es[pos]:
if simple[npos]:
continue
LR.append(npos)
for npos in LR:
result = dfs(npos, pos, Es, degree, simple)
if result == False:
return False
return True
def dfs(pos, parent, Es, degree, simple):
while True:
L = []
for npos in Es[pos]:
if simple[npos] or npos == parent:
continue
L.append(npos)
if len(L) > 1:
return False
if len(L) == 0:
return True
parent = pos
pos = L[0]
def trim_deg2(n, Es, degree):
for i, d in enumerate(degree):
if d == 2:
a, b = list(Es[i])
Es[a].remove(i)
Es[a].add(b)
Es[b].remove(i)
Es[b].add(a)
Es[i] = set()
degree[i] = 0
n -= 1
return n, Es, degree
def find_most_complex(complexity):
maxc = max(complexity)
return complexity.index(maxc), maxc
def mark_simple(n, Es, degree):
simple = []
for i, d in enumerate(degree):
if d <= 1:
simple.append(True)
continue
if d > 3:
simple.append(False)
continue
if d == 3:
n_leaf = 0
for j in Es[i]:
if degree[j] == 1:
n_leaf += 1
if n_leaf >= 2:
simple.append(True)
else:
simple.append(False)
continue
if degree[i] == 2:
print('unexpected')
return simple
def mark_complexity(n, Es, degree, simple):
complexity = []
for i in range(n):
c = 0
for j in Es[i]:
if not simple[j]:
c += 1
complexity.append(c)
return complexity
n = int(input())
Es = [set() for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
a -= 1
b -= 1
Es[a].add(b)
Es[b].add(a)
degree = [len(e) for e in Es]
if solve(n, Es, degree):
print('Yes')
else:
print('No')
``` | instruction | 0 | 41,640 | 13 | 83,280 |
No | output | 1 | 41,640 | 13 | 83,281 |
Provide a correct Python 3 solution for this coding contest problem.
We have a tree G with N vertices numbered 1 to N. The i-th edge of G connects Vertex a_i and Vertex b_i.
Consider adding zero or more edges in G, and let H be the graph resulted.
Find the number of graphs H that satisfy the following conditions, modulo 998244353.
* H does not contain self-loops or multiple edges.
* The diameters of G and H are equal.
* For every pair of vertices in H that is not directly connected by an edge, the addition of an edge directly connecting them would reduce the diameter of the graph.
Constraints
* 3 \le N \le 2 \times 10^5
* 1 \le a_i, b_i \le N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
\vdots
a_{N-1} b_{N-1}
Output
Print the answer.
Examples
Input
6
1 6
2 1
5 2
3 4
2 3
Output
3
Input
3
1 2
2 3
Output
1
Input
9
1 2
2 3
4 2
1 7
6 1
2 5
5 9
6 8
Output
27
Input
19
2 4
15 8
1 16
1 3
12 19
1 18
7 11
11 15
12 9
1 6
7 14
18 2
13 12
13 5
16 13
7 1
11 10
7 17
Output
78732 | instruction | 0 | 41,853 | 13 | 83,706 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
mod=998244353
N=int(input())
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=map(int,input().split())
E[x].append(y)
E[y].append(x)
Q=[1]
D=[-1]*(N+1)
D[1]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
f=D.index(max(D))
Q=[f]
D=[-1]*(N+1)
D[f]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
MAX=max(D)
l=D.index(MAX)
Q=[l]
D2=[-1]*(N+1)
D2[l]=0
while Q:
x=Q.pop()
for to in E[x]:
if D2[to]==-1:
D2[to]=D2[x]+1
Q.append(to)
if MAX%2==0:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2:
c=i
break
TOP_SORT=[]
Q=[c]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[[0,0,0] for i in range(3)] for i in range(N+1)]
# DP[x][p][m]で, plusのものが0個, 1個, 2個以上, minusのものが0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x][1][1]=1
elif len(E[x])==1:
DP[x][0][0]=1
else:
for to in E[x]:
if to==P[x]:
continue
X=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
X[0][0]+=DP[to][i][j]
X[i][0]+=DP[to][i][j]
X[0][j]+=DP[to][i][j]
if DP[x]==[[0,0,0] for i in range(3)]:
DP[x]=X
else:
Y=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
for k in range(3):
for l in range(3):
Y[min(2,i+k)][min(2,j+l)]=(Y[min(2,i+k)][min(2,j+l)]+X[i][j]*DP[x][k][l])%mod
DP[x]=Y
#print(DP)
print(DP[c][1][1]*pow(2,mod-2,mod)%mod)
else:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2+1:
c1=i
elif D[i]==MAX//2+1 and D2[i]==MAX//2:
c2=i
TOP_SORT=[]
Q=[c1,c2]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c1]=0
D[c2]=0
P[c1]=c2
P[c2]=c1
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[[0,0,0] for i in range(3)] for i in range(N+1)]
# DP[x][p][m]で, plusのものが0個, 1個, 2個以上, minusのものが0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x][1][1]=1
elif len(E[x])==1:
DP[x][0][0]=1
else:
for to in E[x]:
if to==P[x]:
continue
X=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
X[0][0]+=DP[to][i][j]
X[i][0]+=DP[to][i][j]
X[0][j]+=DP[to][i][j]
if DP[x]==[[0,0,0] for i in range(3)]:
DP[x]=X
else:
Y=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
for k in range(3):
for l in range(3):
Y[min(2,i+k)][min(2,j+l)]=(Y[min(2,i+k)][min(2,j+l)]+X[i][j]*DP[x][k][l])%mod
DP[x]=Y
#print(DP[c1])
#print(DP[c2])
print(sum(DP[c1][1])*sum(DP[c2][1])%mod)
``` | output | 1 | 41,853 | 13 | 83,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree G with N vertices numbered 1 to N. The i-th edge of G connects Vertex a_i and Vertex b_i.
Consider adding zero or more edges in G, and let H be the graph resulted.
Find the number of graphs H that satisfy the following conditions, modulo 998244353.
* H does not contain self-loops or multiple edges.
* The diameters of G and H are equal.
* For every pair of vertices in H that is not directly connected by an edge, the addition of an edge directly connecting them would reduce the diameter of the graph.
Constraints
* 3 \le N \le 2 \times 10^5
* 1 \le a_i, b_i \le N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
\vdots
a_{N-1} b_{N-1}
Output
Print the answer.
Examples
Input
6
1 6
2 1
5 2
3 4
2 3
Output
3
Input
3
1 2
2 3
Output
1
Input
9
1 2
2 3
4 2
1 7
6 1
2 5
5 9
6 8
Output
27
Input
19
2 4
15 8
1 16
1 3
12 19
1 18
7 11
11 15
12 9
1 6
7 14
18 2
13 12
13 5
16 13
7 1
11 10
7 17
Output
78732
Submitted Solution:
```
BASE = 9973
MOD1 = 10 ** 9 + 7
MOD2 = 998244353
class RollingHash:
# 文字列Sのローリングハッシュを構築
# 計算量: O(N)
def __init__(self, S, MOD):
self.MOD = MOD
# acc[i]はS[0:i]のハッシュ値となる
self.acc = [0]
a = 0
# 累積和を計算するイメージ
for i, c in enumerate(S):
h = ord(c) - ord("a") + 1
offset = pow(BASE, i, MOD)
a = (a + (h * offset)) % MOD
self.acc.append(a)
# S[i:j]のハッシュ値を返す
# 計算量: O(1)
def hash(self, i, j):
# 累積和を用いて部分区間の和を計算するイメージ
# 注意: 基数によるオフセットをキャンセルする必要がある
offset = pow(BASE, i, self.MOD)
# 素数MODを法とする剰余類における除算は逆元を乗算することで計算できる
# 素数MODを法とする剰余類におけるxの逆元はx^(MOD - 2)に等しい
offset_inv = pow(offset, self.MOD - 2, self.MOD)
return ((self.acc[j] - self.acc[i]) * offset_inv) % self.MOD
N = int(input())
S = input()
# Sのローリングハッシュを計算しておく
rolling1 = RollingHash(S, MOD1)
rolling2 = RollingHash(S, MOD2)
# 長さmのダジャレがSに含まれるならば、長さm-1のダジャレも含まれる
# つまり、長さmのダジャレがSに含まれるならば真となる述語をP(m)とすると、以下を満たす整数cが存在する:
# - 0以上c以下の整数mについてP(m)は真
# - cより大きい整数mについてP(m)は偽
# ※ Pは単調関数ということ
# このcを二分探索で発見すれば高速化できる！
# P(ok)は真
ok = 0
# P(ng)は偽
ng = N
while ng - ok > 1:
# 区間[ok, ng)の中央値をmとする
m = (ok + ng) // 2
# 長さmのダジャレが存在するか判定する
# 長さmのformerのハッシュ値のキャッシュ
former_cache1 = set()
former_cache2 = set()
p = False
# latterに着目してループを回す
for i in range(m, N):
# ダジャレ長を決め打ちしているのでjを直接計算できる
j = i + m
# S[i:j]がSをはみ出したらループ終了
if j > N:
break
# formerのハッシュ値をキャッシュする
former_cache1.add(rolling1.hash(i - m, i))
former_cache2.add(rolling2.hash(i - m, i))
# キャッシャに同一のハッシュ値が存在する場合（ハッシュ値が衝突した場合）、ダジャレになっていると判定できる
# ハッシュ値の計算、キャッシュ存在判定は共にO(1)で処理できる！
if (
rolling1.hash(i, j) in former_cache1
and rolling2.hash(i, j) in former_cache2
):
p = True
# 区間[ok, ng) を更新
if p:
ok = m
else:
ng = m
# whileループを抜けると区間[ok, ng)は[c, c + 1) になっている
ans = ok
print(ans)
``` | instruction | 0 | 41,854 | 13 | 83,708 |
No | output | 1 | 41,854 | 13 | 83,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree G with N vertices numbered 1 to N. The i-th edge of G connects Vertex a_i and Vertex b_i.
Consider adding zero or more edges in G, and let H be the graph resulted.
Find the number of graphs H that satisfy the following conditions, modulo 998244353.
* H does not contain self-loops or multiple edges.
* The diameters of G and H are equal.
* For every pair of vertices in H that is not directly connected by an edge, the addition of an edge directly connecting them would reduce the diameter of the graph.
Constraints
* 3 \le N \le 2 \times 10^5
* 1 \le a_i, b_i \le N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
\vdots
a_{N-1} b_{N-1}
Output
Print the answer.
Examples
Input
6
1 6
2 1
5 2
3 4
2 3
Output
3
Input
3
1 2
2 3
Output
1
Input
9
1 2
2 3
4 2
1 7
6 1
2 5
5 9
6 8
Output
27
Input
19
2 4
15 8
1 16
1 3
12 19
1 18
7 11
11 15
12 9
1 6
7 14
18 2
13 12
13 5
16 13
7 1
11 10
7 17
Output
78732
Submitted Solution:
```
import sys
input = sys.stdin.readline
mod=998244353
N=int(input())
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=map(int,input().split())
E[x].append(y)
E[y].append(x)
Q=[1]
D=[-1]*(N+1)
D[1]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
f=D.index(max(D))
Q=[f]
D=[-1]*(N+1)
D[f]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
MAX=max(D)
l=D.index(MAX)
Q=[l]
D2=[-1]*(N+1)
D2[l]=0
while Q:
x=Q.pop()
for to in E[x]:
if D2[to]==-1:
D2[to]=D2[x]+1
Q.append(to)
if MAX%2==0:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2:
c=i
break
TOP_SORT=[]
Q=[c]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[[0,0,0] for i in range(3)] for i in range(N+1)]
# DP[x][p][m]で, plusのものが0個, 1個, 2個以上, minusのものが0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x][1][1]=1
elif len(E[x])==1:
DP[x][0][0]=1
else:
for to in E[x]:
if to==P[x]:
continue
X=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
X[0][0]+=DP[to][i][j]
X[i][0]+=DP[to][i][j]
X[0][j]+=DP[to][i][j]
if DP[x]==[[0,0,0] for i in range(3)]:
DP[x]=X
else:
Y=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
for k in range(3):
for l in range(3):
Y[min(2,i+k)][min(2,j+l)]=(Y[min(2,i+k)][min(2,j+l)]+X[i][j]*DP[x][k][l])%mod
DP[x]=Y
#print(DP)
print(DP[c][1][1]*pow(2,mod-2,mod)%mod)
else:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2+1:
c1=i
elif D[i]==MAX//2+1 and D2[i]==MAX//2:
c2=i
TOP_SORT=[]
Q=[c1,c2]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c1]=0
D[c2]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[[0,0,0] for i in range(3)] for i in range(N+1)]
# DP[x][p][m]で, plusのものが0個, 1個, 2個以上, minusのものが0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x][1][1]=1
elif len(E[x])==1:
DP[x][0][0]=1
else:
for to in E[x]:
if to==P[x]:
continue
X=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
X[0][0]+=DP[to][i][j]
X[i][0]+=DP[to][i][j]
X[0][j]+=DP[to][i][j]
if DP[x]==[[0,0,0] for i in range(3)]:
DP[x]=X
else:
Y=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
for k in range(3):
for l in range(3):
Y[min(2,i+k)][min(2,j+l)]=(Y[min(2,i+k)][min(2,j+l)]+X[i][j]*DP[x][k][l])%mod
DP[x]=Y
#print(DP)
print(DP[c2][1][1]*pow(2,mod-2,mod)%mod)
``` | instruction | 0 | 41,855 | 13 | 83,710 |
No | output | 1 | 41,855 | 13 | 83,711 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree G with N vertices numbered 1 to N. The i-th edge of G connects Vertex a_i and Vertex b_i.
Consider adding zero or more edges in G, and let H be the graph resulted.
Find the number of graphs H that satisfy the following conditions, modulo 998244353.
* H does not contain self-loops or multiple edges.
* The diameters of G and H are equal.
* For every pair of vertices in H that is not directly connected by an edge, the addition of an edge directly connecting them would reduce the diameter of the graph.
Constraints
* 3 \le N \le 2 \times 10^5
* 1 \le a_i, b_i \le N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
\vdots
a_{N-1} b_{N-1}
Output
Print the answer.
Examples
Input
6
1 6
2 1
5 2
3 4
2 3
Output
3
Input
3
1 2
2 3
Output
1
Input
9
1 2
2 3
4 2
1 7
6 1
2 5
5 9
6 8
Output
27
Input
19
2 4
15 8
1 16
1 3
12 19
1 18
7 11
11 15
12 9
1 6
7 14
18 2
13 12
13 5
16 13
7 1
11 10
7 17
Output
78732
Submitted Solution:
```
import sys
input = sys.stdin.readline
mod=998244353
N=int(input())
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=map(int,input().split())
E[x].append(y)
E[y].append(x)
Q=[1]
D=[-1]*(N+1)
D[1]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
f=D.index(max(D))
Q=[f]
D=[-1]*(N+1)
D[f]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
MAX=max(D)
l=D.index(MAX)
Q=[l]
D2=[-1]*(N+1)
D2[l]=0
while Q:
x=Q.pop()
for to in E[x]:
if D2[to]==-1:
D2[to]=D2[x]+1
Q.append(to)
if MAX%2==0:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2:
c=i
break
TOP_SORT=[]
Q=[c]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[0,0,0] for i in range(N+1)]
# 中心からの距離が条件を満たすものが、0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x]=[0,1,0]
elif len(E[x])==1:
DP[x]=[1,0,0]
elif x==c:
True
else:
for to in E[x]:
if to==P[x]:
continue
xt,yt,zt=DP[to]
x1,y1,z1=xt*3+yt*2+zt*2,yt,zt
if DP[x]==[0,0,0]:
DP[x]=[x1,y1,z1]
else:
x0,y0,z0=DP[x]
DP[x]=[x0*x1%mod,(x1*y0+x0*y1)%mod,(y0*y1+z0*(x1+y1+z1)+z1*(x0+y0))%mod]
ANS=[0,0,0] # 0個, 1個, 2個ちょうど
for to in E[c]:
xt,yt,zt=DP[to]
x1,y1,z1=xt*3+yt*2+zt*2,yt,zt
if ANS==[0,0,0]:
ANS=[x1,y1,z1]
else:
x0,y0,z0=ANS
ANS=[x0*x1%mod,(x1*y0+x0*y1)%mod,(y1*y0+y0*y1)%mod]
print(ANS[2]*pow(2,mod-2,mod)%mod)
else:
A[10000]
``` | instruction | 0 | 41,856 | 13 | 83,712 |
No | output | 1 | 41,856 | 13 | 83,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a tree G with N vertices numbered 1 to N. The i-th edge of G connects Vertex a_i and Vertex b_i.
Consider adding zero or more edges in G, and let H be the graph resulted.
Find the number of graphs H that satisfy the following conditions, modulo 998244353.
* H does not contain self-loops or multiple edges.
* The diameters of G and H are equal.
* For every pair of vertices in H that is not directly connected by an edge, the addition of an edge directly connecting them would reduce the diameter of the graph.
Constraints
* 3 \le N \le 2 \times 10^5
* 1 \le a_i, b_i \le N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
\vdots
a_{N-1} b_{N-1}
Output
Print the answer.
Examples
Input
6
1 6
2 1
5 2
3 4
2 3
Output
3
Input
3
1 2
2 3
Output
1
Input
9
1 2
2 3
4 2
1 7
6 1
2 5
5 9
6 8
Output
27
Input
19
2 4
15 8
1 16
1 3
12 19
1 18
7 11
11 15
12 9
1 6
7 14
18 2
13 12
13 5
16 13
7 1
11 10
7 17
Output
78732
Submitted Solution:
```
import sys
input = sys.stdin.readline
mod=998244353
N=int(input())
E=[[] for i in range(N+1)]
for i in range(N-1):
x,y=map(int,input().split())
E[x].append(y)
E[y].append(x)
Q=[1]
D=[-1]*(N+1)
D[1]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
f=D.index(max(D))
Q=[f]
D=[-1]*(N+1)
D[f]=0
while Q:
x=Q.pop()
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
MAX=max(D)
l=D.index(MAX)
Q=[l]
D2=[-1]*(N+1)
D2[l]=0
while Q:
x=Q.pop()
for to in E[x]:
if D2[to]==-1:
D2[to]=D2[x]+1
Q.append(to)
if MAX%2==0:
for i in range(N+1):
if D[i]==MAX//2 and D2[i]==MAX//2:
c=i
break
TOP_SORT=[]
Q=[c]
D=[-1]*(N+1)
P=[-1]*(N+1)
D[c]=0
while Q:
x=Q.pop()
TOP_SORT.append(x)
for to in E[x]:
if D[to]==-1:
D[to]=D[x]+1
Q.append(to)
P[to]=x
DP=[[[0,0,0] for i in range(3)] for i in range(N+1)]
# DP[x][p][m]で, plusのものが0個, 1個, 2個以上, minusのものが0個, 1個, 2個以上
for x in TOP_SORT[::-1]:
if D[x]==MAX//2:
DP[x][1][1]=1
elif len(E[x])==1:
DP[x][0][0]=1
else:
for to in E[x]:
if to==P[x]:
continue
X=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
X[0][0]+=DP[to][i][j]
X[i][0]+=DP[to][i][j]
X[0][j]+=DP[to][i][j]
if DP[x]==[[0,0,0] for i in range(3)]:
DP[x]=X
else:
Y=[[0,0,0] for i in range(3)]
for i in range(3):
for j in range(3):
for k in range(3):
for l in range(3):
Y[min(2,i+k)][min(2,j+l)]=(Y[min(2,i+k)][min(2,j+l)]+X[i][j]*DP[x][k][l])%mod
DP[x]=Y
#print(DP)
print(DP[c][1][1]*pow(2,mod-2,mod)%mod)
else:
A[10000]
``` | instruction | 0 | 41,857 | 13 | 83,714 |
No | output | 1 | 41,857 | 13 | 83,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha travels around Mars in the Mars rover. But suddenly it broke down, namely — the logical scheme inside it. The scheme is an undirected tree (connected acyclic graph) with a root in the vertex 1, in which every leaf (excluding root) is an input, and all other vertices are logical elements, including the root, which is output. One bit is fed to each input. One bit is returned at the output.
There are four types of logical elements: [AND](https://en.wikipedia.org/wiki/Logical_conjunction) (2 inputs), [OR](https://en.wikipedia.org/wiki/Logical_disjunction) (2 inputs), [XOR](https://en.wikipedia.org/wiki/Exclusive_or) (2 inputs), [NOT](https://en.wikipedia.org/wiki/Negation) (1 input). Logical elements take values from their direct descendants (inputs) and return the result of the function they perform. Natasha knows the logical scheme of the Mars rover, as well as the fact that only one input is broken. In order to fix the Mars rover, she needs to change the value on this input.
For each input, determine what the output will be if Natasha changes this input.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^6) — the number of vertices in the graph (both inputs and elements).
The i-th of the next n lines contains a description of i-th vertex: the first word "AND", "OR", "XOR", "NOT" or "IN" (means the input of the scheme) is the vertex type. If this vertex is "IN", then the value of this input follows (0 or 1), otherwise follow the indices of input vertices of this element: "AND", "OR", "XOR" have 2 inputs, whereas "NOT" has 1 input. The vertices are numbered from one.
It is guaranteed that input data contains a correct logical scheme with an output produced by the vertex 1.
Output
Print a string of characters '0' and '1' (without quotes) — answers to the problem for each input in the ascending order of their vertex indices.
Example
Input
10
AND 9 4
IN 1
IN 1
XOR 6 5
AND 3 7
IN 0
NOT 10
IN 1
IN 1
AND 2 8
Output
10110
Note
The original scheme from the example (before the input is changed):
<image>
Green indicates bits '1', yellow indicates bits '0'.
If Natasha changes the input bit 2 to 0, then the output will be 1.
If Natasha changes the input bit 3 to 0, then the output will be 0.
If Natasha changes the input bit 6 to 1, then the output will be 1.
If Natasha changes the input bit 8 to 0, then the output will be 1.
If Natasha changes the input bit 9 to 0, then the output will be 0. | instruction | 0 | 42,107 | 13 | 84,214 |
Tags: dfs and similar, graphs, implementation, trees
Correct Solution:
```
AND = "AND"
OR = "OR"
XOR = "XOR"
NOT = "NOT"
IN = "IN"
OPS = {
AND: AND,
OR: OR,
XOR: XOR,
NOT: NOT,
}
class Node:
def __init__(self, num):
self.num = num
self.op = None
self.parent = None
self.input_1 = None
self.input_2 = None
self.orig_value = None
self.root_value_if_changed = None
@property
def children(self):
if self.op == IN:
return []
elif self.op == NOT:
return [self.input_1]
else:
return [self.input_1, self.input_2]
def can_compute(self):
if self.op == IN:
return True
if self.op == NOT:
return self.input_1.orig_value is not None
return self.input_1.orig_value is not None and self.input_2.orig_value is not None
def compute(self):
if self.op == IN:
return self.orig_value
assert self.can_compute()
if self.op == NOT:
return not self.input_1.orig_value
elif self.op == AND:
return self.input_1.orig_value and self.input_2.orig_value
elif self.op == OR:
return self.input_1.orig_value or self.input_2.orig_value
else:
return self.input_1.orig_value != self.input_2.orig_value
def set_input(self, a):
self.input_1 = a
a.parent = self
def set_inputs(self, a, b):
self.input_1 = a
self.input_2 = b
a.parent = self
b.parent = self
def compute_orig_values(root):
stack = [root]
while len(stack) > 0:
node: Node = stack[-1]
if node.can_compute():
node.orig_value = node.compute()
stack.pop()
else:
stack.extend(node.children)
def compute_if_change(root: Node):
def comp_if_changed(node: Node):
if node is root:
return not node.orig_value
orig = node.orig_value
node.orig_value = not node.orig_value
res = node.parent.compute()
node.orig_value = orig
if res == node.parent.orig_value:
return root.orig_value
else:
return node.parent.root_value_if_changed
stack = [root]
while len(stack) > 0:
node: Node = stack.pop()
node.root_value_if_changed = comp_if_changed(node)
stack.extend(node.children)
def main():
import sys
n = int(sys.stdin.readline())
nodes = {i: Node(i) for i in range(1, n + 1)}
assert len(nodes) == n
for i in range(1, n + 1):
toks = sys.stdin.readline().strip().split(" ")
node = nodes[i]
if len(toks) == 2:
if toks[0] == IN:
node.op = IN
node.orig_value = toks[1] == "1"
else:
node.op = NOT
node.set_input(nodes[int(toks[1])])
else:
node.op = OPS[toks[0]]
a, b = map(int, toks[1:])
a = nodes[a]
b = nodes[b]
node.set_inputs(a, b)
root: Node = nodes[1]
compute_orig_values(root)
compute_if_change(root)
ret = []
for i in range(1, n + 1):
node = nodes[i]
if node.op == IN:
ret.append(int(node.root_value_if_changed))
ret = "".join(str(x) for x in ret)
print(ret)
if __name__ == '__main__':
main()
``` | output | 1 | 42,107 | 13 | 84,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Natasha travels around Mars in the Mars rover. But suddenly it broke down, namely — the logical scheme inside it. The scheme is an undirected tree (connected acyclic graph) with a root in the vertex 1, in which every leaf (excluding root) is an input, and all other vertices are logical elements, including the root, which is output. One bit is fed to each input. One bit is returned at the output.
There are four types of logical elements: [AND](https://en.wikipedia.org/wiki/Logical_conjunction) (2 inputs), [OR](https://en.wikipedia.org/wiki/Logical_disjunction) (2 inputs), [XOR](https://en.wikipedia.org/wiki/Exclusive_or) (2 inputs), [NOT](https://en.wikipedia.org/wiki/Negation) (1 input). Logical elements take values from their direct descendants (inputs) and return the result of the function they perform. Natasha knows the logical scheme of the Mars rover, as well as the fact that only one input is broken. In order to fix the Mars rover, she needs to change the value on this input.
For each input, determine what the output will be if Natasha changes this input.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^6) — the number of vertices in the graph (both inputs and elements).
The i-th of the next n lines contains a description of i-th vertex: the first word "AND", "OR", "XOR", "NOT" or "IN" (means the input of the scheme) is the vertex type. If this vertex is "IN", then the value of this input follows (0 or 1), otherwise follow the indices of input vertices of this element: "AND", "OR", "XOR" have 2 inputs, whereas "NOT" has 1 input. The vertices are numbered from one.
It is guaranteed that input data contains a correct logical scheme with an output produced by the vertex 1.
Output
Print a string of characters '0' and '1' (without quotes) — answers to the problem for each input in the ascending order of their vertex indices.
Example
Input
10
AND 9 4
IN 1
IN 1
XOR 6 5
AND 3 7
IN 0
NOT 10
IN 1
IN 1
AND 2 8
Output
10110
Note
The original scheme from the example (before the input is changed):
<image>
Green indicates bits '1', yellow indicates bits '0'.
If Natasha changes the input bit 2 to 0, then the output will be 1.
If Natasha changes the input bit 3 to 0, then the output will be 0.
If Natasha changes the input bit 6 to 1, then the output will be 1.
If Natasha changes the input bit 8 to 0, then the output will be 1.
If Natasha changes the input bit 9 to 0, then the output will be 0. | instruction | 0 | 42,108 | 13 | 84,216 |
Tags: dfs and similar, graphs, implementation, trees
Correct Solution:
```
import sys
input=sys.stdin.readline
n=int(input())
stack=[]
children=[]
for i in range(n):
children.append([])
parent=[-1]*n
nodes=[-1]*n
inputs=[]
functions=[-1]*n
for i in range(n):
a=list(map(str,input().split()))
r=a[0]
if r=='IN':
stack.append((i,int(a[1])))
inputs.append(i)
elif r=='NOT':
parent[int(a[1])-1]=i
children[i].append(int(a[1])-1)
functions[i]=1
else:
x1=int(a[1])-1
x2=int(a[2])-1
parent[x1]=i
parent[x2]=i
children[i].append(x1)
children[i].append(x2)
if r=='AND':
functions[i]=2
elif r=='XOR':
functions[i]=3
else:
functions[i]=4
while stack:
pos,val=stack.pop()
nodes[pos]=val
if pos==0:
break
r=parent[pos]
flag=0
values=[]
for child in children[r]:
values.append(nodes[child])
if not -1 in values:
if functions[r]==1:
stack.append((r,1-values[0]))
elif functions[r]==2:
stack.append((r,values[0]&values[1]))
elif functions[r]==3:
stack.append((r,values[0]^values[1]))
else:
stack.append((r,values[0]|values[1]))
output=nodes[0]
stack=[0]
important=[0]*n
while stack:
pos=stack.pop()
important[pos]=1
if functions[pos]==-1:
continue
q=children[pos]
if functions[pos]==1:
stack.append(q[0])
elif functions[pos]==2:
if nodes[pos]==1:
stack.append(q[0])
stack.append(q[1])
else:
if nodes[q[0]]==1 and nodes[q[1]]==0:
stack.append(q[1])
elif nodes[q[0]]==0 and nodes[q[1]]==1:
stack.append(q[0])
elif functions[pos]==3:
stack.append(q[0])
stack.append(q[1])
else:
if nodes[pos]==0:
stack.append(q[0])
stack.append(q[1])
else:
if nodes[q[0]]==1 and nodes[q[1]]==0:
stack.append(q[0])
elif nodes[q[0]]==0 and nodes[q[1]]==1:
stack.append(q[1])
ans=[]
for i in inputs:
if important[i]:
ans.append(1-output)
else:
ans.append(output)
print(''.join(map(str,ans)))
``` | output | 1 | 42,108 | 13 | 84,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.
The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.
All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.
To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.
Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.
Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.
It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.
Input
The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).
The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).
Output
In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).
In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).
In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.
Examples
Input
5
0 0 1 1
Output
0 2 1 4 3
2
1 3
Input
4
0 1 2
Output
0 1 2 3
0
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
N = int(input())
P = [-1] + [int(a) for a in input().split()]
C = [[] for _ in range(N)]
M = [1] * N
DE = [1] * N
for i in range(1, N):
C[P[i]].append(i)
for i in range(N)[::-1]:
for c in C[i]:
M[i] += M[c]
DE[i] = max(DE[i], DE[c] + 1)
for i in range(N):
C[i] = [a[1] for a in sorted([(DE[c], c) for c in C[i]])[::-1]]
ANS = []
G = [-1] * N
INV = [-1] * N
X = [0]
G[0] = 0
INV[0] = 0
while X:
x = X.pop()
if x < 0:
ANS.append(~x)
continue
a = INV[x]+1
for i in range(1, len(C[x]))[::-1]:
G[a] = C[x][i]
INV[C[x][i]] = a
a += M[C[x][i]]
for _ in range(DE[C[x][i]]):
# ANS.append(C[x][i-1])
X.append(~C[x][i-1])
X.append(C[x][i])
for c in C[x][:1]:
G[a] = c
INV[c] = a
X.append(c)
print(*G)
print(len(ANS))
print(*ANS)
``` | instruction | 0 | 42,185 | 13 | 84,370 |
No | output | 1 | 42,185 | 13 | 84,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.
The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.
All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.
To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.
Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.
Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.
It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.
Input
The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).
The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).
Output
In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).
In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).
In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.
Examples
Input
5
0 0 1 1
Output
0 2 1 4 3
2
1 3
Input
4
0 1 2
Output
0 1 2 3
0
Submitted Solution:
```
n=int(input())
used=list(False for i in range(n))
child=list(list() for i in range(n))
a=list(map(int,input().split()))
for i in range(len(a)):
child[a[i]].append(i+1)
now=0
bambuk=list(range(n))
count=1
used[now]=True
bambuk[count-1]=now
f=True
k=0
result=list()
fcount=0
while count!=n:
flag=False
nowday=list()
for i in range(len(child[now])):
if not used[child[now][i]]:
flag=True
nowday.append(child[now][i])
if len(nowday)>1:
now=nowday[0]
for i in range(1,len(nowday)):
if len(child[now])>len(child[nowday[i]]):
now=nowday[i]
elif len(nowday)==1:
now=nowday[0]
if flag:
count+=1
used[now]=True
bambuk[count-1]=now
if not f:
f=True
for i in range(fcount):
result.append(now)
k+=1
fcount=0
else:
now=a[now-1]
f=False
fcount+=1
for i in range(n):
print(bambuk[i],end=' ')
print()
print(k)
for i in range(k):
print(result[i],end=' ')
``` | instruction | 0 | 42,186 | 13 | 84,372 |
No | output | 1 | 42,186 | 13 | 84,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.
The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.
All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.
To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.
Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.
Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.
It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.
Input
The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).
The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).
Output
In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).
In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).
In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.
Examples
Input
5
0 0 1 1
Output
0 2 1 4 3
2
1 3
Input
4
0 1 2
Output
0 1 2 3
0
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
N = int(input())
P = [-1] + [int(a) for a in input().split()]
C = [[] for _ in range(N)]
M = [1] * N
DE = [1] * N
for i in range(1, N):
C[P[i]].append(i)
for i in range(N)[::-1]:
for c in C[i]:
M[i] += M[c]
DE[i] = max(DE[i], DE[c] + 1)
for i in range(N):
C[i] = [a[1] for a in sorted([(DE[c], c) for c in C[i]])[::-1]]
ANS = []
G = [-1] * N
INV = [-1] * N
X = [0]
G[0] = 0
INV[0] = 0
while X:
x = X.pop()
if x < 0:
ANS.append(~x)
continue
a = INV[x]+1
for i in range(1, len(C[x])):
G[a] = C[x][i]
INV[C[x][i]] = a
a += M[C[x][i]]
for _ in range(DE[C[x][i]]):
# ANS.append(C[x][i-1])
X.append(~C[x][i-1])
X.append(C[x][i])
for c in C[x][:1][::-1]:
G[a] = c
INV[c] = a
X.append(c)
print(*G)
print(len(ANS))
print(*ANS)
``` | instruction | 0 | 42,187 | 13 | 84,374 |
No | output | 1 | 42,187 | 13 | 84,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.
The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n - 1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.
All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.
To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.
Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.
Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.
It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 10^6 operations. Note that any hack that does not meet these conditions will be invalid.
Input
The first line contains a single integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5).
The second line contains n - 1 integers p(1), …, p(n - 1) — indices of parent vertices of 1, …, n - 1 respectively (0 ≤ p(i) < i).
Output
In the first line, print n distinct integers id_1, …, id_n — the initial labelling of the bamboo blank starting from the root vertex (0 ≤ id_i < n).
In the second line, print a single integer k — the number of operations in your sequence (0 ≤ k ≤ 10^6).
In the third line print k integers v_1, …, v_k describing operations in order. The i-th operation consists of changing p(v_i) to p(p(v_i)). Each operation should be valid, i.e. neither v_i nor p(v_i) can be the root of the tree at the moment.
Examples
Input
5
0 0 1 1
Output
0 2 1 4 3
2
1 3
Input
4
0 1 2
Output
0 1 2 3
0
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
N = int(input())
P = [-1] + [int(a) for a in input().split()]
C = [[] for _ in range(N)]
M = [1] * N
DE = [1] * N
for i in range(1, N):
C[P[i]].append(i)
for i in range(N)[::-1]:
for c in C[i]:
M[i] += M[c]
DE[i] = max(DE[i], DE[c] + 1)
for i in range(N):
C[i] = [a[1] for a in sorted([(DE[c], c) for c in C[i]])[::-1]]
ANS = []
G = [-1] * N
INV = [-1] * N
X = [0]
G[0] = 0
INV[0] = 0
while X:
x = X.pop()
if x < 0:
ANS.append(~x)
continue
a = INV[x]+1
for c in C[x][:1]:
G[a] = c
INV[c] = a
X.append(c)
for i in range(1, len(C[x])):
G[a] = C[x][i]
INV[C[x][i]] = a
a += M[C[x][i]]
for _ in range(DE[C[x][i]]):
# ANS.append(C[x][i-1])
X.append(~C[x][i-1])
X.append(C[x][i])
print(*G)
print(len(ANS))
print(*ANS)
``` | instruction | 0 | 42,188 | 13 | 84,376 |
No | output | 1 | 42,188 | 13 | 84,377 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a directed acyclic graph G, consisting of n vertexes, numbered from 0 to n - 1. The graph contains n edges numbered from 0 to n - 1. An edge with number i connects vertexes i and (i + 1) mod n, and it can be directed in either direction (from i to (i + 1) mod n, or vise versa).
Operation x mod y means taking the remainder after dividing number x by number y.
Let's call two vertexes u and v in graph G comparable if the graph contains a path either from u to v or from v to u. We'll assume that an antichain is a set of vertexes of graph G, where any two distinct vertexes are not comparable. The size of an antichain is the number of vertexes in the corresponding set. An antichain is maximum if the graph doesn't have antichains of a larger size.
Your task is to find the size of the maximum antichain in graph G.
Input
The first line contains the sequence of characters s0s1... sn - 1 (2 ≤ n ≤ 106), consisting of numbers zero and one. The length of the line (number n) corresponds to the number of vertexes and edges in graph G. If character si (i ≥ 0) equals 0, then the edge between vertexes i and (i + 1) mod n is directed from the i-th vertex to the (i + 1) mod n-th one, otherwise — to the opposite point.
It is guaranteed that the given graph is acyclic.
Output
Print a single integer — the size of the maximum antichain of graph G.
Examples
Input
001
Output
1
Input
110010
Output
3
Note
Consider the first test sample. The graph's G edges are: 0 → 1, 1 → 2, 0 → 2. We can choose the set of vertexes [0] as the maximum antichain. We cannot choose an antichain of larger size.
Submitted Solution:
```
s = input()
es = s + s[0]
start = 0
for i, _ in enumerate(s):
if es[i] == '1' and es[i+1] == '0':
start = (i+1) % len(s)
es = s[start:] + s[:start] + '0'
count = 0
prev = '0'
b = (s[-2] == '0')
p1, p2 = 0, 0
for i in range(0, len(es)):
if prev == es[i]:
if prev == '0':
p1 += 1
else:
p2 += 1
else:
if prev == '0':
p2 += 1
else:
if b:
count += 1
b = (p2 == 1)
else:
if p1 == 1:
count += 1
b = False
else:
count += 2
b = (p2 == 1)
prev = es[i]
print(count)
``` | instruction | 0 | 42,419 | 13 | 84,838 |
No | output | 1 | 42,419 | 13 | 84,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a directed acyclic graph G, consisting of n vertexes, numbered from 0 to n - 1. The graph contains n edges numbered from 0 to n - 1. An edge with number i connects vertexes i and (i + 1) mod n, and it can be directed in either direction (from i to (i + 1) mod n, or vise versa).
Operation x mod y means taking the remainder after dividing number x by number y.
Let's call two vertexes u and v in graph G comparable if the graph contains a path either from u to v or from v to u. We'll assume that an antichain is a set of vertexes of graph G, where any two distinct vertexes are not comparable. The size of an antichain is the number of vertexes in the corresponding set. An antichain is maximum if the graph doesn't have antichains of a larger size.
Your task is to find the size of the maximum antichain in graph G.
Input
The first line contains the sequence of characters s0s1... sn - 1 (2 ≤ n ≤ 106), consisting of numbers zero and one. The length of the line (number n) corresponds to the number of vertexes and edges in graph G. If character si (i ≥ 0) equals 0, then the edge between vertexes i and (i + 1) mod n is directed from the i-th vertex to the (i + 1) mod n-th one, otherwise — to the opposite point.
It is guaranteed that the given graph is acyclic.
Output
Print a single integer — the size of the maximum antichain of graph G.
Examples
Input
001
Output
1
Input
110010
Output
3
Note
Consider the first test sample. The graph's G edges are: 0 → 1, 1 → 2, 0 → 2. We can choose the set of vertexes [0] as the maximum antichain. We cannot choose an antichain of larger size.
Submitted Solution:
```
s = input()
count = 0
border = False
prev = s[0]
for c in s[1:] + s[0]:
if c != prev:
if border:
count += 1
else:
border = True
prev = c
else:
if border:
border = False
count += 1
print(count)
``` | instruction | 0 | 42,420 | 13 | 84,840 |
No | output | 1 | 42,420 | 13 | 84,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a directed acyclic graph G, consisting of n vertexes, numbered from 0 to n - 1. The graph contains n edges numbered from 0 to n - 1. An edge with number i connects vertexes i and (i + 1) mod n, and it can be directed in either direction (from i to (i + 1) mod n, or vise versa).
Operation x mod y means taking the remainder after dividing number x by number y.
Let's call two vertexes u and v in graph G comparable if the graph contains a path either from u to v or from v to u. We'll assume that an antichain is a set of vertexes of graph G, where any two distinct vertexes are not comparable. The size of an antichain is the number of vertexes in the corresponding set. An antichain is maximum if the graph doesn't have antichains of a larger size.
Your task is to find the size of the maximum antichain in graph G.
Input
The first line contains the sequence of characters s0s1... sn - 1 (2 ≤ n ≤ 106), consisting of numbers zero and one. The length of the line (number n) corresponds to the number of vertexes and edges in graph G. If character si (i ≥ 0) equals 0, then the edge between vertexes i and (i + 1) mod n is directed from the i-th vertex to the (i + 1) mod n-th one, otherwise — to the opposite point.
It is guaranteed that the given graph is acyclic.
Output
Print a single integer — the size of the maximum antichain of graph G.
Examples
Input
001
Output
1
Input
110010
Output
3
Note
Consider the first test sample. The graph's G edges are: 0 → 1, 1 → 2, 0 → 2. We can choose the set of vertexes [0] as the maximum antichain. We cannot choose an antichain of larger size.
Submitted Solution:
```
s = input()
es = s + s[0]
start = 0
for i, _ in enumerate(s):
if es[i] == '1' and es[i+1] == '0':
start = (i+1) % len(s)
es = s[start:] + s[:start] + '0'
count = 0
prev = '0'
b = (es[-3] == '0')
p1, p2 = 0, 0
print(es)
for i in range(0, len(es)):
if prev == es[i]:
if prev == '0':
p1 += 1
else:
p2 += 1
else:
if prev == '0':
p2 += 1
else:
if b:
count += 1
b = (p2 == 1)
else:
if p1 == 1:
count += 1
b = False
else:
count += 2
b = (p2 == 1)
p1 = 1
p2 = 0
prev = es[i]
print(count)
``` | instruction | 0 | 42,421 | 13 | 84,842 |
No | output | 1 | 42,421 | 13 | 84,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have a directed acyclic graph G, consisting of n vertexes, numbered from 0 to n - 1. The graph contains n edges numbered from 0 to n - 1. An edge with number i connects vertexes i and (i + 1) mod n, and it can be directed in either direction (from i to (i + 1) mod n, or vise versa).
Operation x mod y means taking the remainder after dividing number x by number y.
Let's call two vertexes u and v in graph G comparable if the graph contains a path either from u to v or from v to u. We'll assume that an antichain is a set of vertexes of graph G, where any two distinct vertexes are not comparable. The size of an antichain is the number of vertexes in the corresponding set. An antichain is maximum if the graph doesn't have antichains of a larger size.
Your task is to find the size of the maximum antichain in graph G.
Input
The first line contains the sequence of characters s0s1... sn - 1 (2 ≤ n ≤ 106), consisting of numbers zero and one. The length of the line (number n) corresponds to the number of vertexes and edges in graph G. If character si (i ≥ 0) equals 0, then the edge between vertexes i and (i + 1) mod n is directed from the i-th vertex to the (i + 1) mod n-th one, otherwise — to the opposite point.
It is guaranteed that the given graph is acyclic.
Output
Print a single integer — the size of the maximum antichain of graph G.
Examples
Input
001
Output
1
Input
110010
Output
3
Note
Consider the first test sample. The graph's G edges are: 0 → 1, 1 → 2, 0 → 2. We can choose the set of vertexes [0] as the maximum antichain. We cannot choose an antichain of larger size.
Submitted Solution:
```
s = input()
count = 1
prev = s[0]
for c in s:
if prev != c:
count += 1
prev = c
if prev == s[0]:
count += 1
print(count-1)
``` | instruction | 0 | 42,422 | 13 | 84,844 |
No | output | 1 | 42,422 | 13 | 84,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the expose procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agreed to help if Rostislav solves a simple task (and if he doesn't, then why would he need Splay trees anyway?)
Given integers l, r and k, you need to print all powers of number k within range from l to r inclusive. However, Rostislav doesn't want to spent time doing this, as he got interested in playing a network game called Agar with Gleb. Help him!
Input
The first line of the input contains three space-separated integers l, r and k (1 ≤ l ≤ r ≤ 1018, 2 ≤ k ≤ 109).
Output
Print all powers of number k, that lie within range from l to r in the increasing order. If there are no such numbers, print "-1" (without the quotes).
Examples
Input
1 10 2
Output
1 2 4 8
Input
2 4 5
Output
-1
Note
Note to the first sample: numbers 20 = 1, 21 = 2, 22 = 4, 23 = 8 lie within the specified range. The number 24 = 16 is greater then 10, thus it shouldn't be printed.
Submitted Solution:
```
(l, r, k) = map(int, input().split())
cur = 1
ok = False
while cur <= r:
if l <= cur <= r:
print(cur, end = ' ')
ok = True
cur *= k
if not ok:
print(-1)
``` | instruction | 0 | 42,527 | 13 | 85,054 |
Yes | output | 1 | 42,527 | 13 | 85,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the expose procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agreed to help if Rostislav solves a simple task (and if he doesn't, then why would he need Splay trees anyway?)
Given integers l, r and k, you need to print all powers of number k within range from l to r inclusive. However, Rostislav doesn't want to spent time doing this, as he got interested in playing a network game called Agar with Gleb. Help him!
Input
The first line of the input contains three space-separated integers l, r and k (1 ≤ l ≤ r ≤ 1018, 2 ≤ k ≤ 109).
Output
Print all powers of number k, that lie within range from l to r in the increasing order. If there are no such numbers, print "-1" (without the quotes).
Examples
Input
1 10 2
Output
1 2 4 8
Input
2 4 5
Output
-1
Note
Note to the first sample: numbers 20 = 1, 21 = 2, 22 = 4, 23 = 8 lie within the specified range. The number 24 = 16 is greater then 10, thus it shouldn't be printed.
Submitted Solution:
```
l, r, k = map(int, input().split())
i = 0
temp = pow(k, i)
while temp<=r:
print("{} ".format(temp), end="")
i += 1
temp = pow(k, i)
if i==0:
print(-1)
``` | instruction | 0 | 42,531 | 13 | 85,062 |
No | output | 1 | 42,531 | 13 | 85,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the expose procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agreed to help if Rostislav solves a simple task (and if he doesn't, then why would he need Splay trees anyway?)
Given integers l, r and k, you need to print all powers of number k within range from l to r inclusive. However, Rostislav doesn't want to spent time doing this, as he got interested in playing a network game called Agar with Gleb. Help him!
Input
The first line of the input contains three space-separated integers l, r and k (1 ≤ l ≤ r ≤ 1018, 2 ≤ k ≤ 109).
Output
Print all powers of number k, that lie within range from l to r in the increasing order. If there are no such numbers, print "-1" (without the quotes).
Examples
Input
1 10 2
Output
1 2 4 8
Input
2 4 5
Output
-1
Note
Note to the first sample: numbers 20 = 1, 21 = 2, 22 = 4, 23 = 8 lie within the specified range. The number 24 = 16 is greater then 10, thus it shouldn't be printed.
Submitted Solution:
```
l, r, k = map(int, input().split())
if k == 1:
if 1 <= r and 1 >= l:
print(1)
else:
a = k
f = 0
while a <= r:
if a >= l:
print(a, end=" ")
f = 1
a *= k
if not f:
print(-1)
``` | instruction | 0 | 42,532 | 13 | 85,064 |
No | output | 1 | 42,532 | 13 | 85,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have a tree (undirected acyclic connected graph). There are ai chocolates waiting to be picked up in the i-th vertex of the tree. First, they choose two different vertices as their starting positions (Alice chooses first) and take all the chocolates contained in them.
Then, they alternate their moves, selecting one vertex at a time and collecting all chocolates from this node. To make things more interesting, they decided that one can select a vertex only if he/she selected a vertex adjacent to that one at his/her previous turn and this vertex has not been already chosen by any of them during other move.
If at any moment one of them is not able to select the node that satisfy all the rules, he/she will skip his turns and let the other person pick chocolates as long as he/she can. This goes on until both of them cannot pick chocolates any further.
Due to their greed for chocolates, they want to collect as many chocolates as possible. However, as they are friends they only care about the total number of chocolates they obtain together. What is the maximum total number of chocolates they may pick?
Input
The first line of the input contains the single integer n (2 ≤ n ≤ 100 000) — the number of vertices in the tree.
The second line contains n integers ai (1 ≤ ai ≤ 109), i-th of these numbers stands for the number of chocolates stored at the node i.
Then follow n - 1 lines that describe the tree. Each of them contains two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of vertices connected by the i-th edge.
Output
Print the number of chocolates Alice and Bob can collect together if they behave optimally.
Examples
Input
9
1 2 3 4 5 6 7 8 9
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
Output
25
Input
2
20 10
1 2
Output
30
Note
In the first sample, Alice may start at the vertex 9 and Bob at vertex 8. Alice will select vertex 1 and Bob has no options now. Alice selects the vertex 7 and they both stop.
In the second sample, both of them will pick either of the nodes alternately.
Submitted Solution:
```
vertexno = int(input())
food = [int(i) for i in input().split()]
edges = [[] for i in range(vertexno)]
for i in range(vertexno - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
parents = [-1 for i in range(vertexno)]
children = [[] for i in range(vertexno)]
def buildtree(vno):
children[vno] = [i for i in edges[vno] if i != parents[vno]]
for i in children[vno]:
parents[i] = vno
buildtree(i)
buildtree(0)
cmaxesfor1 = [-1 for i in range(vertexno)]
def findcastratedmaxfor1(vno):
if (cmaxesfor1[vno] >= 0):
return cmaxesfor1[vno]
maxhere = food[vno]
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 1:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
cmaxesfor1[vno] = maxhere
return maxhere
maxesfor1 = [-1 for i in range(vertexno)]
def findmaxfor1(vno):
if (maxesfor1[vno] >= 0):
return maxesfor1[vno]
if (len(children[vno]) == 0):
maxhere = food[vno]
maxesfor1[vno] = food[vno]
return maxhere
maxhere = 0
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 2:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0] + csmaxes[-2][0])
else:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
maxesfor1[vno] = maxhere
return maxhere
cmaxesfor2 = [-1 for i in range(vertexno)]
def findcastratedmaxfor2(vno):
if (cmaxesfor2[vno] >= 0):
return cmaxesfor2[vno]
maxhere = 0
if (len(children[vno]) == 0):
maxhere = 0
cmaxesfor2[vno] = 0
return 0
maxhere = max(maxhere, food[vno] + max([findcastratedmaxfor2(i) for i in children[vno]]))
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
gmaxes.sort()
if (csmaxes[-1][1] != gmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (len(children[vno]) >= 2):
maxhere = max(maxhere, csmaxes[-2][0] + food[vno] + gmaxes[-1][0])
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
maxhere = max(maxhere, food[vno] + gmaxes[-1][0])
cmaxesfor2[vno] = maxhere
return maxhere
maxesfor2 = [-1 for i in range(vertexno)]
def findmaxfor2(vno):
if (maxesfor2[vno] >= 0):
return maxesfor2[vno]
maxhere = 0
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
cpmaxes = [(findcastratedmaxfor2(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
cpmaxes.sort()
gmaxes.sort()
if (len(children[vno]) == 0):
maxesfor2[vno] = 0
return 0
if (cpmaxes[-1][1] != csmaxes[-1][1]):
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-1][0] + food[vno])
elif (len(children[vno]) == 1):
maxhere = max(maxhere, cpmaxes[-1][0] + food[vno])
else:
maxhere = max(maxhere, cpmaxes[-2][0] + csmaxes[-1][0] + food[vno])
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-2][0] + food[vno])
if len(children[vno]) >= 3:
if (gmaxes[-1][1] != csmaxes[-1][1] and gmaxes[-1][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (gmaxes[-1][1] == csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-3][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
elif (gmaxes[-1][1] == csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-2][0])
if (len(children[vno])) >= 2:
maxhere = max(maxhere, gmaxes[-1][0] + gmaxes[-2][0])
maxhere = max(maxhere, max([findmaxfor2(i) for i in children[vno]]))
maxhere = max(maxhere, food[vno] + gmaxes[-1][0])
maxesfor2[vno] = maxhere
return maxhere
print(findmaxfor2(0))
``` | instruction | 0 | 42,535 | 13 | 85,070 |
No | output | 1 | 42,535 | 13 | 85,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have a tree (undirected acyclic connected graph). There are ai chocolates waiting to be picked up in the i-th vertex of the tree. First, they choose two different vertices as their starting positions (Alice chooses first) and take all the chocolates contained in them.
Then, they alternate their moves, selecting one vertex at a time and collecting all chocolates from this node. To make things more interesting, they decided that one can select a vertex only if he/she selected a vertex adjacent to that one at his/her previous turn and this vertex has not been already chosen by any of them during other move.
If at any moment one of them is not able to select the node that satisfy all the rules, he/she will skip his turns and let the other person pick chocolates as long as he/she can. This goes on until both of them cannot pick chocolates any further.
Due to their greed for chocolates, they want to collect as many chocolates as possible. However, as they are friends they only care about the total number of chocolates they obtain together. What is the maximum total number of chocolates they may pick?
Input
The first line of the input contains the single integer n (2 ≤ n ≤ 100 000) — the number of vertices in the tree.
The second line contains n integers ai (1 ≤ ai ≤ 109), i-th of these numbers stands for the number of chocolates stored at the node i.
Then follow n - 1 lines that describe the tree. Each of them contains two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of vertices connected by the i-th edge.
Output
Print the number of chocolates Alice and Bob can collect together if they behave optimally.
Examples
Input
9
1 2 3 4 5 6 7 8 9
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
Output
25
Input
2
20 10
1 2
Output
30
Note
In the first sample, Alice may start at the vertex 9 and Bob at vertex 8. Alice will select vertex 1 and Bob has no options now. Alice selects the vertex 7 and they both stop.
In the second sample, both of them will pick either of the nodes alternately.
Submitted Solution:
```
vertexno = int(input())
food = [int(i) for i in input().split()]
edges = [[] for i in range(vertexno)]
for i in range(vertexno - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
parents = [-1 for i in range(vertexno)]
children = [[] for i in range(vertexno)]
def buildtree(vno):
children[vno] = [i for i in edges[vno] if i != parents[vno]]
for i in children[vno]:
parents[i] = vno
buildtree(i)
buildtree(0)
cmaxesfor1 = [-1 for i in range(vertexno)]
def findcastratedmaxfor1(vno):
if (cmaxesfor1[vno] >= 0):
return cmaxesfor1[vno]
maxhere = food[vno]
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 1:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
cmaxesfor1[vno] = maxhere
return maxhere
maxesfor1 = [-1 for i in range(vertexno)]
def findmaxfor1(vno):
if (maxesfor1[vno] >= 0):
return maxesfor1[vno]
if (len(children[vno]) == 0):
maxhere = food[vno]
maxesfor1[vno] = food[vno]
return maxhere
maxhere = 0
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 2:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0] + csmaxes[-2][0])
else:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
maxesfor1[vno] = maxhere
return maxhere
cmaxesfor2 = [-1 for i in range(vertexno)]
def findcastratedmaxfor2(vno):
if (cmaxesfor2[vno] >= 0):
return cmaxesfor2[vno]
maxhere = 0
if (len(children[vno]) == 0):
maxhere = 0
cmaxesfor2[vno] = 0
return 0
maxhere = max(maxhere, food[vno] + max([findcastratedmaxfor2(i) for i in children[vno]]))
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
gmaxes.sort()
if (csmaxes[-1][1] != gmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (len(children[vno]) >= 2):
maxhere = max(maxhere, csmaxes[-2][0] + food[vno] + gmaxes[-1][0])
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
cmaxesfor2[vno] = maxhere
return maxhere
maxesfor2 = [-1 for i in range(vertexno)]
def findmaxfor2(vno):
if (maxesfor2[vno] >= 0):
return maxesfor2[vno]
maxhere = 0
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
cpmaxes = [(findcastratedmaxfor2(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
cpmaxes.sort()
gmaxes.sort()
if (len(children[vno]) == 0):
maxesfor2[vno] = 0
return 0
if (cpmaxes[-1][1] != csmaxes[-1][1]):
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-1][0] + food[vno])
elif (len(children[vno]) == 1):
maxhere = max(maxhere, cpmaxes[-1][0] + food[vno])
else:
maxhere = max(maxhere, cpmaxes[-2][0] + csmaxes[-1][0] + food[vno])
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-2][0] + food[vno])
if len(children[vno]) >= 3:
if (gmaxes[-1][1] != csmaxes[-1][1] and gmaxes[-1][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (gmaxes[-1][1] == csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-3][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
elif (gmaxes[-1][1] == csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-2][0])
if (len(children[vno])) >= 2:
maxhere = max(maxhere, gmaxes[-1][0] + gmaxes[-2][0])
maxhere = max(maxhere, max([findmaxfor2(i) for i in children[vno]]))
maxhere = max(maxhere, food[vno] + gmaxes[-1][0])
maxesfor2[vno] = maxhere
return maxhere
print(findmaxfor2(0))
``` | instruction | 0 | 42,536 | 13 | 85,072 |
No | output | 1 | 42,536 | 13 | 85,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob have a tree (undirected acyclic connected graph). There are ai chocolates waiting to be picked up in the i-th vertex of the tree. First, they choose two different vertices as their starting positions (Alice chooses first) and take all the chocolates contained in them.
Then, they alternate their moves, selecting one vertex at a time and collecting all chocolates from this node. To make things more interesting, they decided that one can select a vertex only if he/she selected a vertex adjacent to that one at his/her previous turn and this vertex has not been already chosen by any of them during other move.
If at any moment one of them is not able to select the node that satisfy all the rules, he/she will skip his turns and let the other person pick chocolates as long as he/she can. This goes on until both of them cannot pick chocolates any further.
Due to their greed for chocolates, they want to collect as many chocolates as possible. However, as they are friends they only care about the total number of chocolates they obtain together. What is the maximum total number of chocolates they may pick?
Input
The first line of the input contains the single integer n (2 ≤ n ≤ 100 000) — the number of vertices in the tree.
The second line contains n integers ai (1 ≤ ai ≤ 109), i-th of these numbers stands for the number of chocolates stored at the node i.
Then follow n - 1 lines that describe the tree. Each of them contains two integers ui and vi (1 ≤ ui, vi ≤ n) — indices of vertices connected by the i-th edge.
Output
Print the number of chocolates Alice and Bob can collect together if they behave optimally.
Examples
Input
9
1 2 3 4 5 6 7 8 9
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
Output
25
Input
2
20 10
1 2
Output
30
Note
In the first sample, Alice may start at the vertex 9 and Bob at vertex 8. Alice will select vertex 1 and Bob has no options now. Alice selects the vertex 7 and they both stop.
In the second sample, both of them will pick either of the nodes alternately.
Submitted Solution:
```
vertexno = int(input())
food = [int(i) for i in input().split()]
edges = [[] for i in range(vertexno)]
for i in range(vertexno - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
parents = [-1 for i in range(vertexno)]
children = [[] for i in range(vertexno)]
def buildtree(vno):
children[vno] = [i for i in edges[vno] if i != parents[vno]]
for i in children[vno]:
parents[i] = vno
buildtree(i)
buildtree(0)
cmaxesfor1 = [-1 for i in range(vertexno)]
def findcastratedmaxfor1(vno):
if (cmaxesfor1[vno] >= 0):
return cmaxesfor1[vno]
maxhere = food[vno]
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 1:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
cmaxesfor1[vno] = maxhere
return maxhere
maxesfor1 = [-1 for i in range(vertexno)]
def findmaxfor1(vno):
if (maxesfor1[vno] >= 0):
return maxesfor1[vno]
if (len(children[vno]) == 0):
maxhere = food[vno]
maxesfor1[vno] = food[vno]
return maxhere
maxhere = food[vno]
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
if len(children[vno]) >= 2:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0] + csmaxes[-2][0])
else:
maxhere = max(maxhere, food[vno] + csmaxes[-1][0])
maxesfor1[vno] = maxhere
return maxhere
cmaxesfor2 = [-1 for i in range(vertexno)]
def findcastratedmaxfor2(vno):
if (cmaxesfor2[vno] >= 0):
return cmaxesfor2[vno]
maxhere = 0
if (len(children[vno]) == 0):
maxhere = 0
cmaxesfor2[vno] = 0
return 0
maxhere = max(maxhere, food[vno] + max([findcastratedmaxfor2(i) for i in children[vno]]))
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
gmaxes.sort()
if (csmaxes[-1][1] != gmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (len(children[vno]) >= 2):
maxhere = max(maxhere, csmaxes[-2][0] + food[vno] + gmaxes[-1][0])
maxhere = max(maxhere, csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
maxhere = max(maxhere, food[vno] + gmaxes[-1][0])
cmaxesfor2[vno] = maxhere
return maxhere
maxesfor2 = [-1 for i in range(vertexno)]
def findmaxfor2(vno):
if (maxesfor2[vno] >= 0):
return maxesfor2[vno]
maxhere = 0
csmaxes = [(findcastratedmaxfor1(i), i) for i in children[vno]]
cpmaxes = [(findcastratedmaxfor2(i), i) for i in children[vno]]
gmaxes = [(findmaxfor1(i), i) for i in children[vno]]
csmaxes.sort()
cpmaxes.sort()
gmaxes.sort()
if (len(children[vno]) == 0):
maxesfor2[vno] = 0
return 0
if (cpmaxes[-1][1] != csmaxes[-1][1]):
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-1][0] + food[vno])
elif (len(children[vno]) == 1):
maxhere = max(maxhere, cpmaxes[-1][0] + food[vno])
else:
maxhere = max(maxhere, cpmaxes[-2][0] + csmaxes[-1][0] + food[vno])
maxhere = max(maxhere, cpmaxes[-1][0] + csmaxes[-2][0] + food[vno])
if len(children[vno]) >= 3:
if (gmaxes[-1][1] != csmaxes[-1][1] and gmaxes[-1][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-1][0])
elif (gmaxes[-1][1] == csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-3][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
elif (gmaxes[-1][1] == csmaxes[-2][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-1][0])
if (gmaxes[-2][1] != csmaxes[-1][1]):
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-2][0])
else:
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-1][0] + food[vno] + gmaxes[-3][0])
maxhere = max(maxhere, csmaxes[-2][0] + csmaxes[-3][0] + food[vno] + gmaxes[-2][0])
if (len(children[vno])) >= 2:
maxhere = max(maxhere, gmaxes[-1][0] + gmaxes[-2][0])
maxhere = max(maxhere, max([findmaxfor2(i) for i in children[vno]]))
maxhere = max(maxhere, food[vno] + gmaxes[-1][0])
maxesfor2[vno] = maxhere
return maxhere
print(max(findmaxfor2(0), sorted(food)[-1] + sorted(food)[-2]))
``` | instruction | 0 | 42,537 | 13 | 85,074 |
No | output | 1 | 42,537 | 13 | 85,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with weighted edges. The length of some path between two vertices is the bitwise xor of weights of all edges belonging to this path (if some edge is traversed more than once, then it is included in bitwise xor the same number of times). You have to find the minimum length of path between vertex 1 and vertex n.
Note that graph can contain multiple edges and loops. It is guaranteed that the graph is connected.
Input
The first line contains two numbers n and m (1 ≤ n ≤ 100000, n - 1 ≤ m ≤ 100000) — the number of vertices and the number of edges, respectively.
Then m lines follow, each line containing three integer numbers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108). These numbers denote an edge that connects vertices x and y and has weight w.
Output
Print one number — the minimum length of path between vertices 1 and n.
Examples
Input
3 3
1 2 3
1 3 2
3 2 0
Output
2
Input
2 2
1 1 3
1 2 3
Output
0
Submitted Solution:
```
def dei(a, d, s):
global dist
for elem in a[s]:
if dist[elem] > dist[s] + d[(s, elem)]:
dist[elem] = dist[s] + d[(s, elem)]
n, m = map(int, input().split())
a = [[] for i in range(n + 1)]
d = dict()
dist = [0, 0] + [10 ** 9 for i in range(n - 1)]
for i in range(m):
x, y, w = map(int, input().split())
if (x, y) in d and x != y:
d[(x, y)] = min(d[(x, y)], w)
d[(y, x)] = min(d[(x, y)], w)
elif x != y:
d[(x, y)] = w
d[(y, x)] = w
a[x].append(y)
a[y].append(x)
dei(a, d, 1)
print(dist)
``` | instruction | 0 | 42,574 | 13 | 85,148 |
No | output | 1 | 42,574 | 13 | 85,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with weighted edges. The length of some path between two vertices is the bitwise xor of weights of all edges belonging to this path (if some edge is traversed more than once, then it is included in bitwise xor the same number of times). You have to find the minimum length of path between vertex 1 and vertex n.
Note that graph can contain multiple edges and loops. It is guaranteed that the graph is connected.
Input
The first line contains two numbers n and m (1 ≤ n ≤ 100000, n - 1 ≤ m ≤ 100000) — the number of vertices and the number of edges, respectively.
Then m lines follow, each line containing three integer numbers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108). These numbers denote an edge that connects vertices x and y and has weight w.
Output
Print one number — the minimum length of path between vertices 1 and n.
Examples
Input
3 3
1 2 3
1 3 2
3 2 0
Output
2
Input
2 2
1 1 3
1 2 3
Output
0
Submitted Solution:
```
import sys
sys.setrecursionlimit(1000000)
n,e = map(int,input().split())
x = [[] for i in range(n)]
done = [True]*n
ensure = [True]*n
w = {}
cost = [1000000000000000000]*n
def findMin(n):
for i in x[n]:
cost[n] = min(cost[n],cost[i]+w[(n,i)])
def dik(s):
for i in x[s]:
if done[i]:
findMin(i)
done[i] = False
dik(i)
return
for k in range(e):
i,j,c = map(int,input().split())
x[i-1].append(j-1)
x[j-1].append(i-1)
w[(i-1,j-1)] = c
w[(j-1,i-1)] = c
src = 0
done[src] = False
cost[src] = 0
dik(src) #First iteration to assign possbile minimum values
done = [True]*n #Done ko wapas se true
dik(src) #Second iteration to update and get updated values if previous ones were not shortest
print(cost[n-1])
``` | instruction | 0 | 42,575 | 13 | 85,150 |
No | output | 1 | 42,575 | 13 | 85,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with weighted edges. The length of some path between two vertices is the bitwise xor of weights of all edges belonging to this path (if some edge is traversed more than once, then it is included in bitwise xor the same number of times). You have to find the minimum length of path between vertex 1 and vertex n.
Note that graph can contain multiple edges and loops. It is guaranteed that the graph is connected.
Input
The first line contains two numbers n and m (1 ≤ n ≤ 100000, n - 1 ≤ m ≤ 100000) — the number of vertices and the number of edges, respectively.
Then m lines follow, each line containing three integer numbers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108). These numbers denote an edge that connects vertices x and y and has weight w.
Output
Print one number — the minimum length of path between vertices 1 and n.
Examples
Input
3 3
1 2 3
1 3 2
3 2 0
Output
2
Input
2 2
1 1 3
1 2 3
Output
0
Submitted Solution:
```
import heapq
from collections import defaultdict
def shortestPath(graph,src,dest):
h = []
# keep a track record of vertices with the cost
# heappop will return vertex with least cost
# greedy SRC -> MIN - > MIN -> MIN -> DEST
heapq.heappush(h,(0,src))
while len(h)!=0:
currcost,currvtx = heapq.heappop(h)
if currvtx == dest:
print("Path Exisits {} to {} with cost {}".format(src,dest,currcost))
break
for neigh,neighcost in graph[currvtx]:
heapq.heappush(h,(currcost+neighcost,neigh))
graph = defaultdict(list)
v,e = map(int,input().split())
for i in range(e):
u,v,w = map(str,input().split())
graph[u].append((v,int(w)))
shortestPath(graph,str(1),str(e))
``` | instruction | 0 | 42,576 | 13 | 85,152 |
No | output | 1 | 42,576 | 13 | 85,153 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph with weighted edges. The length of some path between two vertices is the bitwise xor of weights of all edges belonging to this path (if some edge is traversed more than once, then it is included in bitwise xor the same number of times). You have to find the minimum length of path between vertex 1 and vertex n.
Note that graph can contain multiple edges and loops. It is guaranteed that the graph is connected.
Input
The first line contains two numbers n and m (1 ≤ n ≤ 100000, n - 1 ≤ m ≤ 100000) — the number of vertices and the number of edges, respectively.
Then m lines follow, each line containing three integer numbers x, y and w (1 ≤ x, y ≤ n, 0 ≤ w ≤ 108). These numbers denote an edge that connects vertices x and y and has weight w.
Output
Print one number — the minimum length of path between vertices 1 and n.
Examples
Input
3 3
1 2 3
1 3 2
3 2 0
Output
2
Input
2 2
1 1 3
1 2 3
Output
0
Submitted Solution:
```
def dei(a, d, s):
global dist
for elem in a[s]:
if dist[elem] > dist[s] + d[(s, elem)]:
dist[elem] = dist[s] + d[(s, elem)]
n, m = map(int, input().split())
a = [[] for i in range(n + 1)]
d = dict()
dist = [0, 0] + [10 ** 9 for i in range(n - 1)]
for i in range(m):
x, y, w = map(int, input().split())
if (x, y) in d and x != y:
d[(x, y)] = min(d[(x, y)], w)
d[(y, x)] = min(d[(x, y)], w)
elif x != y:
d[(x, y)] = w
d[(y, x)] = w
a[x].append(y)
a[y].append(x)
dei(a, d, 1)
print(dist[n])
``` | instruction | 0 | 42,577 | 13 | 85,154 |
No | output | 1 | 42,577 | 13 | 85,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog.
Let us define k-multihedgehog as follows:
* 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1.
* For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift.
Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog.
Input
First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter.
Next n-1 lines contains two integers u v (1 ≤ u, v ≤ n; u ≠ v) — indices of vertices connected by edge.
It is guaranteed that given graph is a tree.
Output
Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise.
Examples
Input
14 2
1 4
2 4
3 4
4 13
10 5
11 5
12 5
14 5
5 13
6 7
8 6
13 6
9 6
Output
Yes
Input
3 1
1 3
2 3
Output
No
Note
2-multihedgehog from the first example looks like this:
<image>
Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13].
Tree from second example is not a hedgehog because degree of center should be at least 3. | instruction | 0 | 42,928 | 13 | 85,856 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
from collections import deque
n, k = list(map(int, input().split()))
G = [set() for _ in range(n + 1)]
q, nq = deque(), deque()
for _ in range(n - 1):
u, v = list(map(int, input().split()))
G[u].add(v)
G[v].add(u)
for u in range(1, n + 1):
if len(G[u]) == 1:
q.append(u)
step = 0
removed = 0
ok = True
while removed < n - 1:
each = {}
for u in q:
nxt = G[u].pop()
G[nxt].remove(u)
each[nxt] = each.get(nxt, 0) + 1
removed += 1
if len(G[nxt]) == 0:
break
if len(G[nxt]) == 1:
nq.append(nxt)
if any(v < 3 for k,v in each.items()):
ok = False
break
q, nq = nq, deque()
step += 1
if ok and step == k and removed == n - 1:
print('Yes')
else:
print('No')
``` | output | 1 | 42,928 | 13 | 85,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog.
Let us define k-multihedgehog as follows:
* 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1.
* For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift.
Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog.
Input
First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter.
Next n-1 lines contains two integers u v (1 ≤ u, v ≤ n; u ≠ v) — indices of vertices connected by edge.
It is guaranteed that given graph is a tree.
Output
Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise.
Examples
Input
14 2
1 4
2 4
3 4
4 13
10 5
11 5
12 5
14 5
5 13
6 7
8 6
13 6
9 6
Output
Yes
Input
3 1
1 3
2 3
Output
No
Note
2-multihedgehog from the first example looks like this:
<image>
Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13].
Tree from second example is not a hedgehog because degree of center should be at least 3. | instruction | 0 | 42,929 | 13 | 85,858 |
Tags: dfs and similar, graphs, shortest paths
Correct Solution:
```
from collections import deque
n,k = map(int,input().split())
d = {}
for i in range(n):
d[i+1] = set()
for i in range(n-1):
u,v = map(int,input().split())
d[u].add(v)
d[v].add(u)
dist = {}
prev = {}
dist[1] = 0
q = deque()
q.append(1)
while len(q) >0:
cur = q.popleft()
for x in d[cur]:
if x not in dist:
prev[x] = cur
dist[x] = dist[cur]+1
q.append(x)
answer = True
if k > dist[cur]:
answer = False
else:
for i in range(k):
cur = prev[cur]
dist2 = {}
dist2[cur] = 0
q = deque()
q.append(cur)
while len(q) >0:
cur2 = q.popleft()
if cur2 == cur and len(d[cur]) < 3:
answer = False
break
if len(d[cur2]) == 1:
if dist2[cur2] != k:
answer = False
break
elif len(d[cur2]) < 4 and cur2 != cur:
answer = False
break
for x in d[cur2]:
if x not in dist2:
dist2[x] = dist2[cur2]+1
q.append(x)
if answer:
print("Yes")
else:
print("No")
``` | output | 1 | 42,929 | 13 | 85,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog.
Let us define k-multihedgehog as follows:
* 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1.
* For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift.
Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog.
Input
First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter.
Next n-1 lines contains two integers u v (1 ≤ u, v ≤ n; u ≠ v) — indices of vertices connected by edge.
It is guaranteed that given graph is a tree.
Output
Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise.
Examples
Input
14 2
1 4
2 4
3 4
4 13
10 5
11 5
12 5
14 5
5 13
6 7
8 6
13 6
9 6
Output
Yes
Input
3 1
1 3
2 3
Output
No
Note
2-multihedgehog from the first example looks like this:
<image>
Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13].
Tree from second example is not a hedgehog because degree of center should be at least 3.
Submitted Solution:
```
from collections import deque
n, k = list(map(int, input().split()))
G = [set() for _ in range(n + 1)]
q, nq = deque(), deque()
for _ in range(n - 1):
u, v = list(map(int, input().split()))
G[u].add(v)
G[v].add(u)
for u in range(1, n + 1):
if len(G[u]) == 1:
q.append(u)
step = 0
removed = 0
ok = False
while removed < n - 1:
each = {}
for u in q:
nxt = G[u].pop()
G[nxt].remove(u)
each[nxt] = each.get(nxt, 0) + 1
removed += 1
if len(G[nxt]) == 0:
break
if len(G[nxt]) == 1:
nq.append(nxt)
if any(v < 3 for k,v in each.items()):
break
q, nq = nq, deque()
step += 1
if step == k and removed == n - 1:
print('Yes')
else:
print('No')
``` | instruction | 0 | 42,930 | 13 | 85,860 |
No | output | 1 | 42,930 | 13 | 85,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog.
Let us define k-multihedgehog as follows:
* 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1.
* For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift.
Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog.
Input
First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter.
Next n-1 lines contains two integers u v (1 ≤ u, v ≤ n; u ≠ v) — indices of vertices connected by edge.
It is guaranteed that given graph is a tree.
Output
Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise.
Examples
Input
14 2
1 4
2 4
3 4
4 13
10 5
11 5
12 5
14 5
5 13
6 7
8 6
13 6
9 6
Output
Yes
Input
3 1
1 3
2 3
Output
No
Note
2-multihedgehog from the first example looks like this:
<image>
Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13].
Tree from second example is not a hedgehog because degree of center should be at least 3.
Submitted Solution:
```
from collections import deque
n, k = list(map(int, input().split()))
G = [set() for _ in range(n + 1)]
q, nq = deque(), deque()
for _ in range(n - 1):
u, v = list(map(int, input().split()))
G[u].add(v)
G[v].add(u)
for u in range(1, n + 1):
if len(G[u]) == 1:
q.append(u)
step = 0
removed = 0
ok = True
while removed < n - 1:
each = {}
for u in q:
nxt = G[u].pop()
G[nxt].remove(u)
each[nxt] = each.get(nxt, 0) + 1
removed += 1
if len(G[nxt]) == 0:
ok = False
break
if len(G[nxt]) == 1:
nq.append(nxt)
if any(v < 3 for k,v in each.items()):
ok = False
break
q, nq = nq, deque()
step += 1
if ok and step == k and removed == n - 1:
print('Yes')
else:
print('No')
``` | instruction | 0 | 42,931 | 13 | 85,862 |
No | output | 1 | 42,931 | 13 | 85,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task.
You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0).
Wu is too tired after his training to solve this problem. Help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow.
The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively.
The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph.
Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges.
Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well.
Output
For each test case print a single integer — the required greatest common divisor.
Example
Input
3
2 4
1 1
1 1
1 2
2 1
2 2
3 4
1 1 1
1 1
1 2
2 2
2 3
4 7
36 31 96 29
1 2
1 3
1 4
2 2
2 4
3 1
4 3
Output
2
1
12
Note
The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g.
In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2.
In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1.
Submitted Solution:
```
import io
import os
from math import gcd
from collections import deque, defaultdict, Counter
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
out = []
T = int(input())
for t in range(T):
N, M = list(map(int, input().split()))
C = list(map(int, input().split()))
edges = [list(map(int, input().split())) for i in range(M)]
def f(edges):
assign = {}
sums = defaultdict(int)
for u, v in edges:
if v not in assign:
assign[v] = u
sums[u] += C[v - 1]
g = 0
for v in sums.values():
g = gcd(g, v)
return g
out.append(str(gcd(f(edges), f(edges[::-1]))))
burn = input()
print("\n".join(out))
``` | instruction | 0 | 43,103 | 13 | 86,206 |
No | output | 1 | 43,103 | 13 | 86,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task.
You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0).
Wu is too tired after his training to solve this problem. Help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow.
The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively.
The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph.
Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges.
Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well.
Output
For each test case print a single integer — the required greatest common divisor.
Example
Input
3
2 4
1 1
1 1
1 2
2 1
2 2
3 4
1 1 1
1 1
1 2
2 2
2 3
4 7
36 31 96 29
1 2
1 3
1 4
2 2
2 4
3 1
4 3
Output
2
1
12
Note
The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g.
In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2.
In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1.
Submitted Solution:
```
import io
import os
from math import gcd
from collections import deque, defaultdict, Counter
def solve(N, M, C, edges):
graph = [[] for i in range(N)]
for u, v in edges:
graph[u].append(v)
assign = [None for i in range(N)]
sums = [0 for i in range(N)]
sums2 = [0 for i in range(N)]
for u in range(N):
for v in graph[u]:
if assign[v] is None:
assign[v] = u
sums[u] += C[v]
sums2[u] += C[v]
g = 0
for v in sums:
g = gcd(g, v)
for v in sums2:
g = gcd(g, v)
return g
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
N, M = [int(x) for x in input().split()]
C = [int(x) for x in input().split()]
edges = [[int(x) - 1 for x in input().split()] for i in range(M)]
burn = input()
ans = solve(N, M, C, edges)
print(ans)
``` | instruction | 0 | 43,104 | 13 | 86,208 |
No | output | 1 | 43,104 | 13 | 86,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task.
You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0).
Wu is too tired after his training to solve this problem. Help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow.
The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively.
The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph.
Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges.
Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well.
Output
For each test case print a single integer — the required greatest common divisor.
Example
Input
3
2 4
1 1
1 1
1 2
2 1
2 2
3 4
1 1 1
1 1
1 2
2 2
2 3
4 7
36 31 96 29
1 2
1 3
1 4
2 2
2 4
3 1
4 3
Output
2
1
12
Note
The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g.
In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2.
In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1.
Submitted Solution:
```
import io
import os
from math import gcd
from collections import deque, defaultdict, Counter
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
out = []
T = int(input())
for t in range(T):
N, M = list(map(int, input().split()))
C = list(map(int, input().split()))
edges = [list(map(int, input().split())) for i in range(M)]
burn = input()
#edges.sort()
seen = set()
curr = None
total = 0
g = 0
for u, v in edges:
if u != curr:
if curr is not None and total:
g = gcd(g, total)
curr = u
total = 0
if v not in seen:
total += C[v - 1]
seen.add(v)
if curr is not None and total:
g = gcd(g, total)
out.append(str(g))
print("\n".join(out))
``` | instruction | 0 | 43,105 | 13 | 86,210 |
No | output | 1 | 43,105 | 13 | 86,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Wu got hungry after an intense training session, and came to a nearby store to buy his favourite instant noodles. After Wu paid for his purchase, the cashier gave him an interesting task.
You are given a bipartite graph with positive integers in all vertices of the right half. For a subset S of vertices of the left half we define N(S) as the set of all vertices of the right half adjacent to at least one vertex in S, and f(S) as the sum of all numbers in vertices of N(S). Find the greatest common divisor of f(S) for all possible non-empty subsets S (assume that GCD of empty set is 0).
Wu is too tired after his training to solve this problem. Help him!
Input
The first line contains a single integer t (1 ≤ t ≤ 500 000) — the number of test cases in the given test set. Test case descriptions follow.
The first line of each case description contains two integers n and m (1~≤~n,~m~≤~500 000) — the number of vertices in either half of the graph, and the number of edges respectively.
The second line contains n integers c_i (1 ≤ c_i ≤ 10^{12}). The i-th number describes the integer in the vertex i of the right half of the graph.
Each of the following m lines contains a pair of integers u_i and v_i (1 ≤ u_i, v_i ≤ n), describing an edge between the vertex u_i of the left half and the vertex v_i of the right half. It is guaranteed that the graph does not contain multiple edges.
Test case descriptions are separated with empty lines. The total value of n across all test cases does not exceed 500 000, and the total value of m across all test cases does not exceed 500 000 as well.
Output
For each test case print a single integer — the required greatest common divisor.
Example
Input
3
2 4
1 1
1 1
1 2
2 1
2 2
3 4
1 1 1
1 1
1 2
2 2
2 3
4 7
36 31 96 29
1 2
1 3
1 4
2 2
2 4
3 1
4 3
Output
2
1
12
Note
The greatest common divisor of a set of integers is the largest integer g such that all elements of the set are divisible by g.
In the first sample case vertices of the left half and vertices of the right half are pairwise connected, and f(S) for any non-empty subset is 2, thus the greatest common divisor of these values if also equal to 2.
In the second sample case the subset \{1\} in the left half is connected to vertices \{1, 2\} of the right half, with the sum of numbers equal to 2, and the subset \{1, 2\} in the left half is connected to vertices \{1, 2, 3\} of the right half, with the sum of numbers equal to 3. Thus, f(\{1\}) = 2, f(\{1, 2\}) = 3, which means that the greatest common divisor of all values of f(S) is 1.
Submitted Solution:
```
import io
import os
from math import gcd
from collections import deque, defaultdict, Counter
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
out = []
T = int(input())
for t in range(T):
N, M = list(map(int, input().split()))
C = list(map(int, input().split()))
assign = {}
sums = defaultdict(int)
for u, v in ((map(int, input().split())) for i in range(M)):
if v not in assign:
assign[v] = u
sums[u] += C[v - 1]
g = 0
for v in sums.values():
g = gcd(g, v)
out.append(str(g))
burn = input()
print("\n".join(out))
``` | instruction | 0 | 43,106 | 13 | 86,212 |
No | output | 1 | 43,106 | 13 | 86,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a connected undirected graph with n vertices and an integer k, you have to either:
* either find an independent set that has exactly ⌈k/2⌉ vertices.
* or find a simple cycle of length at most k.
An independent set is a set of vertices such that no two of them are connected by an edge. A simple cycle is a cycle that doesn't contain any vertex twice.
I have a proof that for any input you can always solve at least one of these problems, but it's left as an exercise for the reader.
Input
The first line contains three integers n, m, and k (3 ≤ k ≤ n ≤ 10^5, n-1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges in the graph, and the parameter k from the statement.
Each of the next m lines contains two integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between vertices u and v. It's guaranteed that the graph is connected and doesn't contain any self-loops or multiple edges.
Output
If you choose to solve the first problem, then on the first line print 1, followed by a line containing ⌈k/2⌉ distinct integers not exceeding n, the vertices in the desired independent set.
If you, however, choose to solve the second problem, then on the first line print 2, followed by a line containing one integer, c, representing the length of the found cycle, followed by a line containing c distinct integers not exceeding n, the vertices in the desired cycle, in the order they appear in the cycle.
Examples
Input
4 4 3
1 2
2 3
3 4
4 1
Output
1
1 3
Input
4 5 3
1 2
2 3
3 4
4 1
2 4
Output
2
3
2 3 4
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
2
3
1 2 3
Input
5 4 5
1 2
1 3
2 4
2 5
Output
1
1 4 5
Note
In the first sample:
<image>
Notice that printing the independent set \{2,4\} is also OK, but printing the cycle 1-2-3-4 isn't, because its length must be at most 3.
In the second sample:
<image>
Notice that printing the independent set \{1,3\} or printing the cycle 2-1-4 is also OK.
In the third sample:
<image>
In the fourth sample:
<image> | instruction | 0 | 43,124 | 13 | 86,248 |
Tags: constructive algorithms, dfs and similar, graphs, greedy, implementation, trees
Correct Solution:
```
######################################################
############Created by Devesh Kumar###################
#############devesh1102@gmail.com####################
##########For CodeForces(Devesh1102)#################
#####################2020#############################
######################################################
import sys
input = sys.stdin.readline
# import sys
import heapq
import copy
import math
import decimal
# import sys.stdout.flush as flush
# from decimal import *
#heapq.heapify(li)
#
#heapq.heappush(li,4)
#
#heapq.heappop(li)
#
# & Bitwise AND Operator 10 & 7 = 2
# | Bitwise OR Operator 10 | 7 = 15
# ^ Bitwise XOR Operator 10 ^ 7 = 13
# << Bitwise Left Shift operator 10<<2 = 40
# >> Bitwise Right Shift Operator
# '''############ ---- Input Functions ---- #######Start#####'''
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def insr2():
s = input()
return((s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
############ ---- Input Functions ---- #######End
# #####
def pr_list(a):
print(*a, sep=" ")
def main():
# tests = inp()
tests = 1
mod = 998244353
limit = 10**18
ans = 0
for test in range(tests):
[n,m,k] = inlt()
adj = [{} for i in range(n+1)]
for i in range(m):
[u,v]= inlt()
adj[u][v] = 1
adj[v][u]= 1
done = [0 for i in range(n+1)]
s_hash = {}
s_hash[1] = 1
done[1] = 1
stack = [1]
is_cycle =0
found = 0
token0 = {}
token1 = {}
token0 [1]= 1
while(stack!=[]):
# print(stack)
curr = stack[-1]
to_pop = 1
for i in adj[curr]:
if curr in token0:
token1[i] = 1
else:
token0[i] = 1
if i in s_hash and stack[-2] !=i:
is_cycle = 1
for j in range(len(stack)):
if stack[j] == i:
cycle = stack[j:len(stack)]
break
break
if is_cycle ==1:
break
if len(stack) >= k and stack[0] not in adj[stack[-1]]:
found = 1
break
for i in adj[curr]:
if done[i]!=1:
stack.append(i)
done[i] = 1
s_hash[i] = 1
to_pop = 0
break
if to_pop ==1:
del s_hash[curr]
stack.pop()
if is_cycle == 1:
print(2)
print(len(cycle))
pr_list(cycle)
continue
elif found == 1:
ans = []
for i in range(len(stack)):
if i%2 == 0:
ans.append(stack[i])
print(1)
pr_list(ans[0:math.ceil(k/2)])
continue
ans = []
if len(token1)>len(token0):
maxi = token1
else:
maxi = token0
for i in maxi:
ans.append(i)
if len(ans)>=k:
break
print(1)
pr_list(ans[0:math.ceil(k/2)])
if __name__== "__main__":
main()
``` | output | 1 | 43,124 | 13 | 86,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a connected undirected graph with n vertices and an integer k, you have to either:
* either find an independent set that has exactly ⌈k/2⌉ vertices.
* or find a simple cycle of length at most k.
An independent set is a set of vertices such that no two of them are connected by an edge. A simple cycle is a cycle that doesn't contain any vertex twice.
I have a proof that for any input you can always solve at least one of these problems, but it's left as an exercise for the reader.
Input
The first line contains three integers n, m, and k (3 ≤ k ≤ n ≤ 10^5, n-1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges in the graph, and the parameter k from the statement.
Each of the next m lines contains two integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between vertices u and v. It's guaranteed that the graph is connected and doesn't contain any self-loops or multiple edges.
Output
If you choose to solve the first problem, then on the first line print 1, followed by a line containing ⌈k/2⌉ distinct integers not exceeding n, the vertices in the desired independent set.
If you, however, choose to solve the second problem, then on the first line print 2, followed by a line containing one integer, c, representing the length of the found cycle, followed by a line containing c distinct integers not exceeding n, the vertices in the desired cycle, in the order they appear in the cycle.
Examples
Input
4 4 3
1 2
2 3
3 4
4 1
Output
1
1 3
Input
4 5 3
1 2
2 3
3 4
4 1
2 4
Output
2
3
2 3 4
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
2
3
1 2 3
Input
5 4 5
1 2
1 3
2 4
2 5
Output
1
1 4 5
Note
In the first sample:
<image>
Notice that printing the independent set \{2,4\} is also OK, but printing the cycle 1-2-3-4 isn't, because its length must be at most 3.
In the second sample:
<image>
Notice that printing the independent set \{1,3\} or printing the cycle 2-1-4 is also OK.
In the third sample:
<image>
In the fourth sample:
<image> | instruction | 0 | 43,125 | 13 | 86,250 |
Tags: constructive algorithms, dfs and similar, graphs, greedy, implementation, trees
Correct Solution:
```
import sys
from math import ceil
input = sys.stdin.readline
n, m, req = map(int, input().split())
e = [tuple(map(int, input().split())) for _ in range(m)]
g = [[] for _ in range(n + 1)]
for u, v in e:
g[u].append(v)
g[v].append(u)
# req = 1
# while req * req < n:
# req += 1
def dfs():
dep = [0] * (n + 1)
par = [0] * (n + 1)
st = [1]
st2 = []
while st:
u = st.pop()
if dep[u]:
continue
st2.append(u)
dep[u] = dep[par[u]] + 1
for v in g[u]:
if not dep[v]:
par[v] = u
st.append(v)
elif 2 < dep[u] - dep[v] + 1 <= req:
cyc = []
while u != par[v]:
cyc.append(u)
u = par[u]
return (None, cyc)
mk = [0] * (n + 1)
iset = []
while st2:
u = st2.pop()
if not mk[u]:
iset.append(u)
for v in g[u]:
mk[v] = 1
return (iset[:ceil(req/2)], None)
iset, cyc = dfs()
if iset:
print(1)
print(*iset)
else:
print(2)
print(len(cyc))
print(*cyc)
``` | output | 1 | 43,125 | 13 | 86,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a connected undirected graph with n vertices and an integer k, you have to either:
* either find an independent set that has exactly ⌈k/2⌉ vertices.
* or find a simple cycle of length at most k.
An independent set is a set of vertices such that no two of them are connected by an edge. A simple cycle is a cycle that doesn't contain any vertex twice.
I have a proof that for any input you can always solve at least one of these problems, but it's left as an exercise for the reader.
Input
The first line contains three integers n, m, and k (3 ≤ k ≤ n ≤ 10^5, n-1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges in the graph, and the parameter k from the statement.
Each of the next m lines contains two integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between vertices u and v. It's guaranteed that the graph is connected and doesn't contain any self-loops or multiple edges.
Output
If you choose to solve the first problem, then on the first line print 1, followed by a line containing ⌈k/2⌉ distinct integers not exceeding n, the vertices in the desired independent set.
If you, however, choose to solve the second problem, then on the first line print 2, followed by a line containing one integer, c, representing the length of the found cycle, followed by a line containing c distinct integers not exceeding n, the vertices in the desired cycle, in the order they appear in the cycle.
Examples
Input
4 4 3
1 2
2 3
3 4
4 1
Output
1
1 3
Input
4 5 3
1 2
2 3
3 4
4 1
2 4
Output
2
3
2 3 4
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
2
3
1 2 3
Input
5 4 5
1 2
1 3
2 4
2 5
Output
1
1 4 5
Note
In the first sample:
<image>
Notice that printing the independent set \{2,4\} is also OK, but printing the cycle 1-2-3-4 isn't, because its length must be at most 3.
In the second sample:
<image>
Notice that printing the independent set \{1,3\} or printing the cycle 2-1-4 is also OK.
In the third sample:
<image>
In the fourth sample:
<image> | instruction | 0 | 43,126 | 13 | 86,252 |
Tags: constructive algorithms, dfs and similar, graphs, greedy, implementation, trees
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
from collections import *
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]
def dfs():
global req
dep = [0]* (n + 1)
par = [0] * (n + 1)
st = [5]
while st:
u = st.pop()
if dep[u]:
continue
dep[u] = dep[par[u]] + 1
for v in g2[u]:
if not dep[v]:
par[v] = u
st.append(v)
elif dep[u] - dep[v] + 1>= req:
cyc = []
while u != par[v]:
cyc.append(u)
u = par[u]
return (None, cyc)
g = defaultdict(set)
g2 = defaultdict(set)
n,m = li()
for i in range(m):
a,b = li()
g[a].add(b)
g[b].add(a)
g2[a].add(b)
g2[b].add(a)
for i in g2:
g2[i] = set(sorted(list(g2[i])))
currset = set()
ma = math.ceil(n**0.5)
req = ma
for i in sorted(g,key = lambda x:len(g[x])):
if i in g:
currset.add(i)
for k in list(g[i]):
if k in g:g.pop(k)
g.pop(i)
if len(currset) == ma:break
if len(currset) >= ma:
print(1)
print(*list(currset)[:ma])
exit()
print(2)
_,cycles = dfs()
print(len(cycles))
print(*cycles)
``` | output | 1 | 43,126 | 13 | 86,253 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a connected undirected graph with n vertices and an integer k, you have to either:
* either find an independent set that has exactly ⌈k/2⌉ vertices.
* or find a simple cycle of length at most k.
An independent set is a set of vertices such that no two of them are connected by an edge. A simple cycle is a cycle that doesn't contain any vertex twice.
I have a proof that for any input you can always solve at least one of these problems, but it's left as an exercise for the reader.
Input
The first line contains three integers n, m, and k (3 ≤ k ≤ n ≤ 10^5, n-1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges in the graph, and the parameter k from the statement.
Each of the next m lines contains two integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between vertices u and v. It's guaranteed that the graph is connected and doesn't contain any self-loops or multiple edges.
Output
If you choose to solve the first problem, then on the first line print 1, followed by a line containing ⌈k/2⌉ distinct integers not exceeding n, the vertices in the desired independent set.
If you, however, choose to solve the second problem, then on the first line print 2, followed by a line containing one integer, c, representing the length of the found cycle, followed by a line containing c distinct integers not exceeding n, the vertices in the desired cycle, in the order they appear in the cycle.
Examples
Input
4 4 3
1 2
2 3
3 4
4 1
Output
1
1 3
Input
4 5 3
1 2
2 3
3 4
4 1
2 4
Output
2
3
2 3 4
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
2
3
1 2 3
Input
5 4 5
1 2
1 3
2 4
2 5
Output
1
1 4 5
Note
In the first sample:
<image>
Notice that printing the independent set \{2,4\} is also OK, but printing the cycle 1-2-3-4 isn't, because its length must be at most 3.
In the second sample:
<image>
Notice that printing the independent set \{1,3\} or printing the cycle 2-1-4 is also OK.
In the third sample:
<image>
In the fourth sample:
<image> | instruction | 0 | 43,127 | 13 | 86,254 |
Tags: constructive algorithms, dfs and similar, graphs, greedy, implementation, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
from math import sqrt
n,m=map(int,input().split())
k=int(-(-sqrt(n)//1))
E=[[] for i in range(n+1)]
D=[0]*(n+1)
for i in range(m):
x,y=map(int,input().split())
E[x].append(y)
E[y].append(x)
D[x]+=1
D[y]+=1
Q=[(d,i+1) for i,d in enumerate(D[1:])]
import heapq
heapq.heapify(Q)
ANS=[]
USE=[0]*(n+1)
while Q:
d,i=heapq.heappop(Q)
if D[i]!=d or USE[i]==1:
continue
else:
if d>=k-1:
break
else:
ANS.append(i)
USE[i]=1
for to in E[i]:
if USE[to]==0:
USE[to]=1
for to2 in E[to]:
if USE[to2]==0:
D[to2]-=1
heapq.heappush(Q,(D[to2],to2))
#print(ANS)
if len(ANS)>=k:
print(1)
print(*ANS[:k])
sys.exit()
for i in range(1,n+1):
if USE[i]==0:
start=i
break
Q=[start]
ANS=[]
#print(USE)
while Q:
x=Q.pop()
USE[x]=1
ANS.append(x)
for to in E[x]:
if USE[to]==1:
continue
else:
USE[to]=1
Q.append(to)
break
for i in range(len(ANS)):
if ANS[-1] in E[ANS[i]]:
break
ANS=ANS[i:]
print(2)
print(len(ANS))
print(*ANS)
``` | output | 1 | 43,127 | 13 | 86,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a connected undirected graph with n vertices and an integer k, you have to either:
* either find an independent set that has exactly ⌈k/2⌉ vertices.
* or find a simple cycle of length at most k.
An independent set is a set of vertices such that no two of them are connected by an edge. A simple cycle is a cycle that doesn't contain any vertex twice.
I have a proof that for any input you can always solve at least one of these problems, but it's left as an exercise for the reader.
Input
The first line contains three integers n, m, and k (3 ≤ k ≤ n ≤ 10^5, n-1 ≤ m ≤ 2 ⋅ 10^5) — the number of vertices and edges in the graph, and the parameter k from the statement.
Each of the next m lines contains two integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between vertices u and v. It's guaranteed that the graph is connected and doesn't contain any self-loops or multiple edges.
Output
If you choose to solve the first problem, then on the first line print 1, followed by a line containing ⌈k/2⌉ distinct integers not exceeding n, the vertices in the desired independent set.
If you, however, choose to solve the second problem, then on the first line print 2, followed by a line containing one integer, c, representing the length of the found cycle, followed by a line containing c distinct integers not exceeding n, the vertices in the desired cycle, in the order they appear in the cycle.
Examples
Input
4 4 3
1 2
2 3
3 4
4 1
Output
1
1 3
Input
4 5 3
1 2
2 3
3 4
4 1
2 4
Output
2
3
2 3 4
Input
4 6 3
1 2
2 3
3 4
4 1
1 3
2 4
Output
2
3
1 2 3
Input
5 4 5
1 2
1 3
2 4
2 5
Output
1
1 4 5
Note
In the first sample:
<image>
Notice that printing the independent set \{2,4\} is also OK, but printing the cycle 1-2-3-4 isn't, because its length must be at most 3.
In the second sample:
<image>
Notice that printing the independent set \{1,3\} or printing the cycle 2-1-4 is also OK.
In the third sample:
<image>
In the fourth sample:
<image> | instruction | 0 | 43,128 | 13 | 86,256 |
Tags: constructive algorithms, dfs and similar, graphs, greedy, implementation, trees
Correct Solution:
```
#!/usr/bin/env python3
import sys
from math import *
from collections import defaultdict
from queue import deque # Queues
from heapq import heappush, heappop # Priority Queues
# parse
lines = [line.strip() for line in sys.stdin.readlines()]
n, m = list(map(int, lines[0].split()))
edges = [set() for i in range(n)]
for i in range(1, m+1):
u, v = list(map(int, lines[i].split()))
u -= 1
v -= 1
edges[u].add(v)
edges[v].add(u)
nn = int(ceil(sqrt(n)))
def find_cycle(v, forbidden):
used = set([v])
forbidden = set(forbidden)
ret = [v]
while True:
v = ret[-1]
ss = edges[v] - used - forbidden
nxt = None
for s in ss:
nxt = s
break
if nxt is None:
break
ret += [nxt]
used.add(nxt)
i = 0
while ret[i] not in edges[ret[-1]]:
i += 1
return ret[i:]
q = []
for v in range(n):
heappush(q, (len(edges[v]), v))
# find indep set
ind = set()
covered = set()
while q:
d, v = heappop(q)
if v in covered:
continue
ind.add(v)
ss = set(edges[v])
ss.add(v)
if len(ind) == nn:
# found an indep set
print(1)
print(' '.join('%s' % (i+1) for i in ind))
break
if d >= nn - 1:
# found a cycle
ys = find_cycle(v, list(covered))
print(2)
print(len(ys))
print(' '.join('%s' % (i+1) for i in ys))
break
covered |= ss
ws = set()
for u in edges[v]:
for w in edges[u]:
ws.add(w)
ws -= ss
for w in ws:
edges[w] -= ss
heappush(q, (len(edges[w]), w))
``` | output | 1 | 43,128 | 13 | 86,257 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.