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 directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 918 | 13 | 1,836 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
import sys
input = sys.stdin.readline
def dfs(cur_node, childs, vis, cur_dfs):
if cur_node in cur_dfs:
return True
if vis[cur_node]:
return False
vis[cur_node] = True
cur_dfs.add(cur_node)
for ele in childs[cur_node]:
if dfs(ele, childs, vis, cur_dfs):
return True
cur_dfs.remove(cur_node)
return False
n, m = map(int, input().split())
childs = [[] for i in range(n+1)]
has_dad = [False] * (n+1)
vis = [False] * (n+1)
ans2 = []
for i in range(m):
x1, x2 = map(int, input().split())
ans2.append(str((x1 < x2) + 1))
childs[x1].append(x2)
has_dad[x2] = True
has_cycle = False
for i in range(1, n+1):
if not has_dad[i] and dfs(i, childs, vis, set()):
has_cycle = True
break
for i in range(1, n+1):
if has_dad[i] and not vis[i]:
has_cycle = True
break
if has_cycle:
print(2)
print(' '.join(ans2))
else:
print(1)
print(' '.join(['1']*m))
``` | output | 1 | 918 | 13 | 1,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 919 | 13 | 1,838 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
from collections import defaultdict
ans = defaultdict(lambda : 1)
flag = 0
def dfs(i):
global flag
vis[i] = 1
for j in hash[i]:
if not vis[j]:
dfs(j)
else:
if vis[j] == 1:
flag = 1
ans[(i,j)] = 2
vis[i] = 2
n,m = map(int,input().split())
hash = defaultdict(list)
par = [0]+[i+1 for i in range(n)]
for i in range(m):
a,b = map(int,input().split())
hash[a].append(b)
ans[(a,b)] = 1
vis = [0]*(n+1)
for i in range(n):
if vis[i] == 0:
dfs(i)
if flag:
print(2)
else:
print(1)
for i in ans:
print(ans[i],end = ' ')
``` | output | 1 | 919 | 13 | 1,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 920 | 13 | 1,840 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
[N,M] = list(map(int,input().split()))
edges = [[] for _ in range(N+1)]
edge_in = []
for _ in range(M):
[u,v] = list(map(int,input().split()))
edge_in.append([u,v])
edges[u].append(v)
seen = [False for _ in range(N+1)]
visited = [False for _ in range(N+1)]
def bfs(node):
visited[node] = True
seen[node] = True
for v in edges[node]:
if not seen[v] and visited[v]:
continue
if seen[v] or bfs(v):
return True
seen[node] = False
return False
hasCycle = False
for i in range(1,N+1):
if visited[i]:
continue
if bfs(i):
hasCycle = True
break
if not hasCycle:
print(1)
print(" ".join(["1" for _ in range(M)]))
else:
print(2)
print(" ".join(["1" if u < v else "2" for (u,v) in edge_in]))
``` | output | 1 | 920 | 13 | 1,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 921 | 13 | 1,842 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
n, m = input().split(' ')
n, m = int(n), int(m)
ch = [[] for i in range(n+1)]
edges_by_order = []
for i in range(m):
x, y = input().split(' ')
x, y = int(x), int(y)
ch[x].append(y)
edges_by_order.append((x, y))
for i in range(n+1):
ch[i] = sorted(ch[i])
st = [0 for i in range(n+1)]
end = [0 for i in range(n+1)]
timestamp = 0
cycle_exists = False
def dfs(x):
global ch, st, end, timestamp, cycle_exists
timestamp += 1
st[x] = timestamp
for y in ch[x]:
if st[y] == 0:
dfs(y)
else:
if st[y] < st[x] and end[y] == 0:
cycle_exists = True
timestamp += 1
end[x] = timestamp
for i in range(1, n+1):
if st[i] == 0:
dfs(i)
if not cycle_exists:
print(1)
for i in range(m):
print(1, end=' ')
print('', end='\n')
else:
print(2)
for i in range(m):
x = st[edges_by_order[i][0]]
y = st[edges_by_order[i][1]]
if x < y:
print(1, end=' ')
else:
print(2, end=' ')
print('', end='\n')
``` | output | 1 | 921 | 13 | 1,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 922 | 13 | 1,844 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
WHITE, GRAY, BLACK = 0, 1, 2
def solve(graph: [], colors: []):
n = len(graph)-1
visited = [WHITE] * (n + 1)
returnValue = 1
for i in range(1, n + 1):
if visited[i] == WHITE and Dfs(graph, colors, i, visited):
returnValue = 2
return returnValue
def Dfs(graph: [], colors: [], id, visited: []):
visited[id] = GRAY
returnValue = False
for adj, colorId in graph[id]:
if visited[adj] == WHITE:
val = Dfs(graph, colors, adj, visited)
returnValue=True if val else returnValue
elif visited[adj] == GRAY:
returnValue = True
colors[colorId] = 2
visited[id] = BLACK
return returnValue
n, m = [int(x) for x in input().split()]
graph = [[] for _ in range(n + 1)]
colors = [1] * (m)
for i in range(m):
u, v = [int(x) for x in input().split()]
graph[u].append((v, i))
print(solve(graph,colors))
for color in colors:
print(color,end=" ")
print()
``` | output | 1 | 922 | 13 | 1,845 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 923 | 13 | 1,846 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
#!python3
from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest
def read_int():
return int(input().strip())
def read_int_array():
return [int(i) for i in input().strip().split(' ')]
######################################################
vn, en = read_int_array()
al = [[] for _ in range(vn)] # adjacency list
def adj(v):
return al[v]
itoe = [None for _ in range(en)] # index to edge
for eid in range(en): # eid - edge id
v, w = read_int_array()
v -= 1
w -= 1
al[v] += [w]
itoe[eid] = (v, w)
marked = set()
stack = set()
etoc = {} # edge to color
def dfs(v): # vertex
if v in marked:
return
marked.add(v)
stack.add(v)
hasbackedge = False
for w in adj(v):
if w in stack: # back edge
hasbackedge = True
etoc[(v, w)] = 2
continue
if w in marked:
continue
if dfs(w):
hasbackedge = True
stack.remove(v)
return hasbackedge
hasbackedge = False
for v in range(vn):
if v not in marked:
if dfs(v):
hasbackedge = True
print(2 if hasbackedge else 1)
for ei in range(en):
v, w = itoe[ei]
c = etoc.get((v,w), 1)
print(c, end=' ')
``` | output | 1 | 923 | 13 | 1,847 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2 | instruction | 0 | 924 | 13 | 1,848 |
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
v_n, e_n = tuple(map(int, input().split()))
G = [set() for _ in range(v_n)]
edges = []
d_s = [-1] * v_n
ok = False
def dfs(u):
global ok
if ok:
return
d_s[u] = 0
for v in G[u]:
if d_s[v] == -1:
dfs(v)
elif d_s[v] == 0:
ok = True
d_s[u] = 1
for _ in range(e_n):
u, v = tuple(map(int, input().split()))
u -= 1
v -= 1
edges.append((u, v))
G[u].add(v)
for u in range(v_n):
if d_s[u]==-1:
dfs(u)
if not ok:
print(1)
for _ in range(e_n):
print(1, end=' ')
else:
print(2)
for (u, v) in edges:
print(int(u < v) + 1, end=' ')
``` | output | 1 | 924 | 13 | 1,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
import math
# import sys
# input = sys.stdin.readline
n,m=[int(i) for i in input().split(' ')]
d=[[] for i in range(n)]
done = [False for i in range(n)]
def dfs(visited,i,d):
visited[i]=True
done[i] = True
for j in d[i]:
if visited[j]:
return True
if not done[j]:
temp = dfs(visited,j,d)
if temp:return True
visited[i]=False
return False
edgelist=[]
for i in range(m):
a,b=[int(i) for i in input().split(' ')]
edgelist.append([a,b])
d[a-1].append(b-1)
ans = 0
visited=[False for i in range(n)]
for i in range(n):
if dfs(visited,i,d):
ans = 1
break
if ans:
print(2)
for i in edgelist:
if i[0]>i[1]:
print(2,end=' ')
else:print(1,end=' ')
else:
print(1)
print(' '.join('1' for i in range(m)))
``` | instruction | 0 | 925 | 13 | 1,850 |
Yes | output | 1 | 925 | 13 | 1,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
colors = 1
n, m = map(int, input().split(' '))
adj = [[] for i in range(n)]
color = [0 for i in range(m)]
vis = [0 for i in range(n)]
def dfs(u):
global colors
vis[u] = 1
for i, v in adj[u]:
if vis[v] == 1:
colors = 2
color[i] = 2
else:
color[i] = 1
if vis[v] == 0:
dfs(v)
vis[u] = 2
for i in range(m):
u, v = map(int, input().split(' '))
adj[u-1].append((i, v-1))
for i in range(n):
if vis[i] == 0:
dfs(i)
print(colors)
print(' '.join(map(str, color)))
``` | instruction | 0 | 926 | 13 | 1,852 |
Yes | output | 1 | 926 | 13 | 1,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
n, m = [int(i) for i in input().split()]
data = []
chil = []
for i in range(n+1):
chil.append(set())
for j in range(m):
data.append([int(i) for i in input().split()])
chil[data[-1][0]].add(data[-1][1])
# done = set()
# fnd = set()
# cycle = False
# def dfs(a):
# for c in chil[a]:
# print(a,c)
# if c in fnd:
# global cycle
# cycle = True
# return
# if c not in done:
# fnd.add(c)
# dfs(c)
# for i in range(1, n+1):
# if i not in done:
# dfs(i)
# done |= fnd
# fnd = set()
# if cycle:
# break
def cycle():
for i in range(1, n+1):
stack = [i]
fnd = [0] * (n+1)
while stack:
s = stack.pop()
for c in chil[s]:
if c == i:
return True
if not fnd[c]:
stack.append(c)
fnd[c] = 1
if not cycle():
print(1)
l = ['1' for i in range(m)]
print(' '.join(l))
else:
print(2)
for d in data:
print(["2","1"][d[0] < d[1]], end=' ')
print()
``` | instruction | 0 | 927 | 13 | 1,854 |
Yes | output | 1 | 927 | 13 | 1,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
class Graph:
def __init__(self, n, m):
self.nodes = n
self.edges = m
self.adj = [[] for i in range(n)]
self.color = [0 for i in range(m)]
self.vis = [0 for i in range(n)]
self.colors = 1
def add_edge(self, u, v, i):
self.adj[u].append((i, v))
def dfs(self, u):
self.vis[u] = 1
for i, v in self.adj[u]:
if self.vis[v] == 1:
self.colors = 2
self.color[i] = 2
else:
self.color[i] = 1
if self.vis[v] == 0:
self.dfs(v)
self.vis[u] = 2
def solve(self):
for i in range(self.nodes):
if self.vis[i] == 0:
self.dfs(i)
print(self.colors)
print(' '.join(map(str, self.color)))
n, m = map(int, input().split(' '))
graph = Graph(n, m)
for i in range(m):
u, v = map(int, input().split(' '))
graph.add_edge(u-1, v-1, i)
graph.solve()
``` | instruction | 0 | 928 | 13 | 1,856 |
Yes | output | 1 | 928 | 13 | 1,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
def main():
import sys
from collections import deque
input = sys.stdin.readline
N, M = map(int, input().split())
adj = [[] for _ in range(N+1)]
edge = {}
for i in range(M):
a, b = map(int, input().split())
adj[a].append(b)
edge[a*(N+1)+b] = i
seen = [0] * (N + 1)
ans = [0] * M
flg = 1
cnt = 1
for i in range(1, N+1):
if seen[i]:
continue
seen[i] = 1
cnt += 1
que = deque()
que.append(i)
while que:
v = que.popleft()
seen[v] = cnt
for u in adj[v]:
if not seen[u]:
seen[u] = 1
ans[edge[v*(N+1)+u]] = 1
que.append(u)
elif seen[u] == cnt:
flg = 0
ans[edge[v * (N + 1) + u]] = 2
else:
ans[edge[v * (N + 1) + u]] = 1
assert 0 not in ans
if flg:
print(1)
print(*ans)
else:
print(2)
print(*ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 929 | 13 | 1,858 |
No | output | 1 | 929 | 13 | 1,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
# import random
# arr1=[random.randint(1,100) for i in range(10)]
# arr2=[random.randint(1,100) for i in range(10)]
# print(arr1," SORTED:-",sorted(arr1))
# print(arr2," SORTED:-",sorted(arr2))
# def brute_inv(a1,a2):
# a3=a1+a2
# inv=0
# for i in range(len(a3)):
# for j in range(i+1,len(a3)):
# if a3[i]>a3[j]:
# inv+=1
# return inv
# def smart_inv(arr1,arr2):
# i1,i2=0,0
# inv1=0;
# while i1<len(arr1) and i2<len(arr2):
# if arr1[i1]>arr2[i2]:
# inv1+=(len(arr1)-i1)
# i2+=1
# else:
# i1+=1
# return inv1
# print(arr1+arr2,smart_inv(sorted(arr1),sorted(arr2)))
# print(brute_inv(arr1,arr2))
# print(arr2+arr1,smart_inv(sorted(arr2),sorted(arr1)))
# print(brute_inv(arr2,arr1))
# if (smart_inv(sorted(arr1),sorted(arr2))<smart_inv(sorted(arr2),sorted(arr1)) and brute_inv(arr1,arr2)<brute_inv(arr2,arr1)) or (smart_inv(sorted(arr2),sorted(arr1))<smart_inv(sorted(arr1),sorted(arr2)) and brute_inv(arr2,arr1)<brute_inv(arr1,arr2)):
# print("True")
# else:
# print("False")
# print(brute_inv([1,2,10],[3,5,7]))
# print(brute_inv([3,5,7],[1,2,10]))
# print(brute_inv([1,7,10],[3,5,17]))
# print(brute_inv([3,5,17],[1,7,10]))
# 1 :- 1
# 2 :- 10
# 3 :- 011
# 4 :- 0100
# 5 :- 00101
# 6 :- 000110
# 7 :- 0000111
# 8 :- 00001000
# 9 :- 000001001
# 10 :- 0000001010
# 11 :- 00000001011
# 12 :- 000000001100
# 13 :- 0000000001101
# 14 :- 00000000001110
# 15 :- 000000000001111
# 16 :- 0000000000010000
from sys import stdin,stdout
n,m=stdin.readline().strip().split(' ')
n,m=int(n),int(m)
adj=[[] for i in range(n+1)]
d={}
for i in range(m):
u,v=stdin.readline().strip().split(' ')
u,v=int(u),int(v)
adj[u].append(v)
d[(u,v)]=i
visited=[0 for i in range(n+1)]
color=['1' for i in range(m)]
flag=1
def dfs(curr,par):
global flag
for i in adj[curr]:
if i!=par:
if visited[i]==0:
visited[i]=1
color[d[(curr,i)]]='1'
dfs(i,curr)
elif visited[i]==1:
color[d[(curr,i)]]='2'
flag=2
visited[curr]=2
visited[1]=1
dfs(1,-1)
if flag==1:
stdout.write("1\n");
stdout.write(' '.join(color)+"\n")
else:
stdout.write("2\n")
stdout.write(' '.join(color)+"\n")
``` | instruction | 0 | 930 | 13 | 1,860 |
No | output | 1 | 930 | 13 | 1,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
from collections import defaultdict
vis=[]
def isCyclic(n, graph):
global vis
vis=[0]*n
rec=[0]*n
for i in range(0,n):
if(vis[i]== False):
if(DfsRec(i,rec,graph)):
return True
return False
def DfsRec(i,rec,g):
global s1
global s2
global vis
vis[i]=True
rec[i]=True
for u in g[i]:
# print(u,rec,g)
if(vis[u]==False and DfsRec(u,rec,g)):
return True
elif(rec[u]==True):
s1=i
s2=u
return True
rec[i]=False
return False
n,e=list(map(int,input().split()))
d=defaultdict(lambda:[])
l=[]
for i in range(0,e):
a,b=list(map(int,input().split()))
l.append([a-1,b-1])
d[a-1].append(b-1)
#print(d)
s1=-1
s2=-1
c=isCyclic(n,d)
#print(s1,s2)
if(c==True):
print(2)
ans=[]
for i,j in l:
if(i==s1 and s2==j):
ans.append(2)
else:
ans.append(1)
print(*ans)
else:
print(1)
l=[1]*e
print(*l)
``` | instruction | 0 | 931 | 13 | 1,862 |
No | output | 1 | 931 | 13 | 1,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a directed graph with n vertices and m directed edges without self-loops or multiple edges.
Let's denote the k-coloring of a digraph as following: you color each edge in one of k colors. The k-coloring is good if and only if there no cycle formed by edges of same color.
Find a good k-coloring of given digraph with minimum possible k.
Input
The first line contains two integers n and m (2 ≤ n ≤ 5000, 1 ≤ m ≤ 5000) — the number of vertices and edges in the digraph, respectively.
Next m lines contain description of edges — one per line. Each edge is a pair of integers u and v (1 ≤ u, v ≤ n, u ≠ v) — there is directed edge from u to v in the graph.
It is guaranteed that each ordered pair (u, v) appears in the list of edges at most once.
Output
In the first line print single integer k — the number of used colors in a good k-coloring of given graph.
In the second line print m integers c_1, c_2, ..., c_m (1 ≤ c_i ≤ k), where c_i is a color of the i-th edge (in order as they are given in the input).
If there are multiple answers print any of them (you still have to minimize k).
Examples
Input
4 5
1 2
1 3
3 4
2 4
1 4
Output
1
1 1 1 1 1
Input
3 3
1 2
2 3
3 1
Output
2
1 1 2
Submitted Solution:
```
import math
def ii():
return int(input())
def mi():
return map(int, input().split())
def dfs(s, c, used_colors):
global visited
global gr
used_copy = used_colors.copy()
if gr[c] == [] or len(visited) == len(gr):
return
if c == -1:
c = s
visited.add(c)
for elem in gr[c]:
cur_color = p[tuple([c + 1, elem + 1])]
used_copy.add(cur_color)
if elem == s and len(used_copy) == 1:
p[tuple([c + 1, elem + 1])] += 1
else:
dfs(s, elem, used_copy)
visited = set()
n, m = mi()
tuples = list()
p = dict()
gr = [[] for _ in range(n)]
for _ in range(m):
u, v = mi()
gr[u - 1].append(v - 1)
tuples.append(tuple([u, v]))
p[tuple([u, v])] = 1
for s in range(len(gr)):
if len(gr[s]) == 0:
continue
dfs(s, -1, set())
visited.clear()
m = 0
s = ''
for t in tuples:
m = max(m, p[t])
s += str(p[t]) + ' '
print(m)
print(s)
``` | instruction | 0 | 932 | 13 | 1,864 |
No | output | 1 | 932 | 13 | 1,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
For his computer science class, Jacob builds a model tree with sticks and balls containing n nodes in the shape of a tree. Jacob has spent ai minutes building the i-th ball in the tree.
Jacob's teacher will evaluate his model and grade Jacob based on the effort he has put in. However, she does not have enough time to search his whole tree to determine this; Jacob knows that she will examine the first k nodes in a DFS-order traversal of the tree. She will then assign Jacob a grade equal to the minimum ai she finds among those k nodes.
Though Jacob does not have enough time to rebuild his model, he can choose the root node that his teacher starts from. Furthermore, he can rearrange the list of neighbors of each node in any order he likes. Help Jacob find the best grade he can get on this assignment.
A DFS-order traversal is an ordering of the nodes of a rooted tree, built by a recursive DFS-procedure initially called on the root of the tree. When called on a given node v, the procedure does the following:
1. Print v.
2. Traverse the list of neighbors of the node v in order and iteratively call DFS-procedure on each one. Do not call DFS-procedure on node u if you came to node v directly from u.
Input
The first line of the input contains two positive integers, n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n) — the number of balls in Jacob's tree and the number of balls the teacher will inspect.
The second line contains n integers, ai (1 ≤ ai ≤ 1 000 000), the time Jacob used to build the i-th ball.
Each of the next n - 1 lines contains two integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi) representing a connection in Jacob's tree between balls ui and vi.
Output
Print a single integer — the maximum grade Jacob can get by picking the right root of the tree and rearranging the list of neighbors.
Examples
Input
5 3
3 6 1 4 2
1 2
2 4
2 5
1 3
Output
3
Input
4 2
1 5 5 5
1 2
1 3
1 4
Output
1
Note
In the first sample, Jacob can root the tree at node 2 and order 2's neighbors in the order 4, 1, 5 (all other nodes have at most two neighbors). The resulting preorder traversal is 2, 4, 1, 3, 5, and the minimum ai of the first 3 nodes is 3.
In the second sample, it is clear that any preorder traversal will contain node 1 as either its first or second node, so Jacob cannot do better than a grade of 1. | instruction | 0 | 1,292 | 13 | 2,584 |
Tags: binary search, dfs and similar, dp, graphs, greedy, trees
Correct Solution:
```
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(i) for i in input().split()]
g = [[] for _ in range(n)]
for i in range(n - 1):
u, v = map(int, input().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
stack = [0]
done = [False] * n
par = [0] * n
order = []
while len(stack) > 0:
x = stack.pop()
done[x] = True
order.append(x)
for i in g[x]:
if done[i] == False:
par[i] = x
stack.append(i)
order = order[::-1]
sub = [0] * n
for i in order:
sub[i] = 1
for j in g[i]:
if par[j] == i:
sub[i] += sub[j]
def good(guess):
cnt = [0] * n
for i in order:
if a[i] < guess:
continue
cnt[i] = 1
opt = 0
for j in g[i]:
if par[j] == i:
if cnt[j] == sub[j]:
cnt[i] += cnt[j]
else:
opt = max(opt, cnt[j])
cnt[i] += opt
if cnt[0] >= k:
return True
up = [0] * n
for i in order[::-1]:
if a[i] < guess:
continue
opt, secondOpt = 0, 0
total = 1
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
if opt < val:
opt, secondOpt = val, opt
elif secondOpt < val:
secondOpt = val
for j in g[i]:
if par[j] == i:
up[j] = total
add = opt
if sub[j] == cnt[j]:
up[j] -= cnt[j]
elif cnt[j] == opt:
add = secondOpt
up[j] += add
for i in range(n):
if a[i] < guess:
continue
total, opt = 1, 0
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
opt = max(opt, val)
if total + opt >= k:
return True
return False
l, r = 0, max(a)
while l < r:
mid = (l + r + 1) // 2
if good(mid):
l = mid
else:
r = mid - 1
print(l)
``` | output | 1 | 1,292 | 13 | 2,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For his computer science class, Jacob builds a model tree with sticks and balls containing n nodes in the shape of a tree. Jacob has spent ai minutes building the i-th ball in the tree.
Jacob's teacher will evaluate his model and grade Jacob based on the effort he has put in. However, she does not have enough time to search his whole tree to determine this; Jacob knows that she will examine the first k nodes in a DFS-order traversal of the tree. She will then assign Jacob a grade equal to the minimum ai she finds among those k nodes.
Though Jacob does not have enough time to rebuild his model, he can choose the root node that his teacher starts from. Furthermore, he can rearrange the list of neighbors of each node in any order he likes. Help Jacob find the best grade he can get on this assignment.
A DFS-order traversal is an ordering of the nodes of a rooted tree, built by a recursive DFS-procedure initially called on the root of the tree. When called on a given node v, the procedure does the following:
1. Print v.
2. Traverse the list of neighbors of the node v in order and iteratively call DFS-procedure on each one. Do not call DFS-procedure on node u if you came to node v directly from u.
Input
The first line of the input contains two positive integers, n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n) — the number of balls in Jacob's tree and the number of balls the teacher will inspect.
The second line contains n integers, ai (1 ≤ ai ≤ 1 000 000), the time Jacob used to build the i-th ball.
Each of the next n - 1 lines contains two integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi) representing a connection in Jacob's tree between balls ui and vi.
Output
Print a single integer — the maximum grade Jacob can get by picking the right root of the tree and rearranging the list of neighbors.
Examples
Input
5 3
3 6 1 4 2
1 2
2 4
2 5
1 3
Output
3
Input
4 2
1 5 5 5
1 2
1 3
1 4
Output
1
Note
In the first sample, Jacob can root the tree at node 2 and order 2's neighbors in the order 4, 1, 5 (all other nodes have at most two neighbors). The resulting preorder traversal is 2, 4, 1, 3, 5, and the minimum ai of the first 3 nodes is 3.
In the second sample, it is clear that any preorder traversal will contain node 1 as either its first or second node, so Jacob cannot do better than a grade of 1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(i) for i in input().split()]
g = [[] for _ in range(n)]
for i in range(n - 1):
u, v = map(int, input().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
stack = [0]
done = [False] * n
par = [0] * n
order = []
while len(stack) > 0:
x = stack.pop()
done[x] = True
order.append(x)
for i in g[x]:
if done[i] == False:
par[i] = x
stack.append(i)
order = order[::-1]
sub = [0] * n
for i in order:
sub[i] = 1
for j in g[i]:
if par[j] == i:
sub[i] += sub[j]
def good(guess):
cnt = [0] * n
for i in order:
if a[i] < guess:
continue
cnt[i] = 1
opt = 0
for j in g[i]:
if par[j] == i:
if cnt[j] == sub[j]:
cnt[i] += cnt[j]
else:
opt = max(opt, cnt[j])
cnt[i] += opt
return cnt[0] >= k
l, r = 0, max(a)
while l < r:
mid = (l + r + 1) // 2
if good(mid):
l = mid
else:
r = mid - 1
print(l)
``` | instruction | 0 | 1,293 | 13 | 2,586 |
No | output | 1 | 1,293 | 13 | 2,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
For his computer science class, Jacob builds a model tree with sticks and balls containing n nodes in the shape of a tree. Jacob has spent ai minutes building the i-th ball in the tree.
Jacob's teacher will evaluate his model and grade Jacob based on the effort he has put in. However, she does not have enough time to search his whole tree to determine this; Jacob knows that she will examine the first k nodes in a DFS-order traversal of the tree. She will then assign Jacob a grade equal to the minimum ai she finds among those k nodes.
Though Jacob does not have enough time to rebuild his model, he can choose the root node that his teacher starts from. Furthermore, he can rearrange the list of neighbors of each node in any order he likes. Help Jacob find the best grade he can get on this assignment.
A DFS-order traversal is an ordering of the nodes of a rooted tree, built by a recursive DFS-procedure initially called on the root of the tree. When called on a given node v, the procedure does the following:
1. Print v.
2. Traverse the list of neighbors of the node v in order and iteratively call DFS-procedure on each one. Do not call DFS-procedure on node u if you came to node v directly from u.
Input
The first line of the input contains two positive integers, n and k (2 ≤ n ≤ 200 000, 1 ≤ k ≤ n) — the number of balls in Jacob's tree and the number of balls the teacher will inspect.
The second line contains n integers, ai (1 ≤ ai ≤ 1 000 000), the time Jacob used to build the i-th ball.
Each of the next n - 1 lines contains two integers ui, vi (1 ≤ ui, vi ≤ n, ui ≠ vi) representing a connection in Jacob's tree between balls ui and vi.
Output
Print a single integer — the maximum grade Jacob can get by picking the right root of the tree and rearranging the list of neighbors.
Examples
Input
5 3
3 6 1 4 2
1 2
2 4
2 5
1 3
Output
3
Input
4 2
1 5 5 5
1 2
1 3
1 4
Output
1
Note
In the first sample, Jacob can root the tree at node 2 and order 2's neighbors in the order 4, 1, 5 (all other nodes have at most two neighbors). The resulting preorder traversal is 2, 4, 1, 3, 5, and the minimum ai of the first 3 nodes is 3.
In the second sample, it is clear that any preorder traversal will contain node 1 as either its first or second node, so Jacob cannot do better than a grade of 1.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(i) for i in input().split()]
g = [[] for _ in range(n)]
for i in range(n - 1):
u, v = map(int, input().split())
g[u-1].append(v-1)
g[v-1].append(u-1)
stack = [0]
done = [False] * n
par = [0] * n
order = []
while len(stack) > 0:
x = stack.pop()
done[x] = True
order.append(x)
for i in g[x]:
if done[i] == False:
par[i] = x
stack.append(i)
order = order[::-1]
sub = [0] * n
for i in order:
sub[i] = 1
for j in g[i]:
if par[j] == i:
sub[i] += sub[j]
def good(guess):
cnt = [0] * n
for i in order:
if a[i] < guess:
continue
cnt[i] = 1
opt = 0
for j in g[i]:
if par[j] == i:
if cnt[j] == sub[j]:
cnt[i] += cnt[j]
else:
opt = max(opt, cnt[j])
cnt[i] += opt
if cnt[0] >= k:
return True
up = [0] * n
for i in order[::-1]:
if a[i] < guess:
continue
opt, secondOpt = 0, 0
total = 1
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
if opt > val:
opt, secondOpt = val, opt
elif secondOpt > val:
secondOpt = val
for j in g[i]:
if par[j] == i:
up[j] = total
add = opt
if sub[j] == cnt[j]:
up[j] -= cnt[j]
elif cnt[j] == opt:
add = secondOpt
up[j] += add
for i in range(n):
if a[i] < guess:
continue
total, opt = 1, 0
for j in g[i]:
val, size = 0, 0
if par[j] == i:
val = cnt[j]
size = sub[j]
else:
val = up[i]
size = n - sub[i]
if val == size:
total += val
else:
opt = max(opt, val)
if total + opt >= k:
return True
return False
l, r = 0, max(a)
while l < r:
mid = (l + r + 1) // 2
if good(mid):
l = mid
else:
r = mid - 1
print(l)
``` | instruction | 0 | 1,294 | 13 | 2,588 |
No | output | 1 | 1,294 | 13 | 2,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree, which consists of n vertices. Recall that a tree is a connected undirected graph without cycles.
<image> Example of a tree.
Vertices are numbered from 1 to n. All vertices have weights, the weight of the vertex v is a_v.
Recall that the distance between two vertices in the tree is the number of edges on a simple path between them.
Your task is to find the subset of vertices with the maximum total weight (the weight of the subset is the sum of weights of all vertices in it) such that there is no pair of vertices with the distance k or less between them in this subset.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 200) — the number of vertices in the tree and the distance restriction, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5), where a_i is the weight of the vertex i.
The next n - 1 lines contain edges of the tree. Edge i is denoted by two integers u_i and v_i — the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i).
It is guaranteed that the given edges form a tree.
Output
Print one integer — the maximum total weight of the subset in which all pairs of vertices have distance more than k.
Examples
Input
5 1
1 2 3 4 5
1 2
2 3
3 4
3 5
Output
11
Input
7 2
2 1 2 1 2 1 1
6 4
1 5
3 1
2 3
7 5
7 4
Output
4 | instruction | 0 | 1,774 | 13 | 3,548 |
Tags: dp, trees
Correct Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
g = {}
def dfs(v, p=-1):
c = [dfs(child, v) for child in g.get(v, set()) - {p}]
c.sort(key=len, reverse=True)
r = []
i = 0
while c:
if i >= len(c[-1]):
c.pop()
else:
o = max(i, k - i - 1)
s = q = 0
for x in c:
if len(x) <= o:
q = max(q, x[i])
else:
s += x[o]
q = max(q, x[i] - x[o])
r.append(q + s)
i += 1
r.append(0)
for i in range(len(r) - 1, 0, -1):
r[i - 1] = max(r[i - 1], r[i])
while len(r) > 1 and r[-2] == 0:
r.pop()
o = (r[k] if k < len(r) else 0) + a[v]
r.insert(0, max(o, r[0]))
return r
for _ in range(1, n):
u, v = map(lambda x: int(x) - 1, input().split())
g.setdefault(u, set()).add(v)
g.setdefault(v, set()).add(u)
print(dfs(0)[0])
``` | output | 1 | 1,774 | 13 | 3,549 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,238 | 13 | 4,476 |
"Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def calc():
def mex(i):
D = {}
for j in X[i]:
D[G[j]] = 1
for g in range(N + 1):
if g not in D:
return g
M = int(input())
X = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
X[N - min(a, b)].append(N - max(a, b))
G = [0] * N
for i in range(N):
G[i] = mex(i)
H = [0] * 1024
a = 1
for i in range(N)[::-1]:
a = a * A % P
H[G[i]] = (H[G[i]] + a) % P
return H
P = 998244353
A = pow(10, 18, P)
N = int(input())
H1, H2, H3 = calc(), calc(), calc()
ans = 0
for i in range(1024):
if H1[i] == 0: continue
for j in range(1024):
if H2[j] == 0: continue
ans = (ans + H1[i] * H2[j] * H3[i^j]) % P
print(ans)
``` | output | 1 | 2,238 | 13 | 4,477 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,239 | 13 | 4,478 |
"Correct Solution:
```
from collections import defaultdict
M = 998244353
B = 10**18 % M
def mex(s):
for i in range(N+1):
if i not in s:
return i
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in sorted(e.keys(), reverse=True):
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
x = pow(B, i, M)
sum_g[m] += x
sum_g[0] -= x
return sum_g
def read_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz)%M
return ret
N = int(input())
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,239 | 13 | 4,479 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,240 | 13 | 4,480 |
"Correct Solution:
```
from collections import defaultdict
import sys
input = lambda: sys.stdin.readline().rstrip()
M = 998244353
B = pow(10, 18, M)
N = int(input())
def geometric_mod(a, r, m, n):
x = a
for i in range(n):
yield x
x = (x*r)%m
BB = list(geometric_mod(1, B, M, N+2))
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in set(e[i])})
if m:
g[i] = m
sum_g[g[i]] = (sum_g[g[i]] + BB[i]) % M
sum_g[0] = (sum_g[0] - BB[i]) % M
return sum_g
def read_edge():
M = int(input())
e = defaultdict(list)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].append(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz) % M
return ret
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,240 | 13 | 4,481 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,241 | 13 | 4,482 |
"Correct Solution:
```
import sys
from collections import defaultdict
n, *mabs = map(int, sys.stdin.buffer.read().split())
MOD = 998244353
base = 10 ** 18 % MOD
base_costs = [base]
for i in range(n - 1):
base_costs.append(base_costs[-1] * base % MOD)
graphs = []
i = 0
for _ in range(3):
m = mabs[i]
i += 1
j = i + 2 * m
parents = [set() for _ in range(n)]
for a, b in zip(mabs[i:j:2], mabs[i + 1:j:2]):
a -= 1
b -= 1
if a > b:
a, b = b, a
parents[a].add(b)
grundy = [0] * n
weights = defaultdict(int)
for v in range(n - 1, -1, -1):
pgs = {grundy[p] for p in parents[v]}
for g in range(m + 1):
if g not in pgs:
grundy[v] = g
weights[g] += base_costs[v]
break
for g in weights:
weights[g] %= MOD
graphs.append(dict(weights))
i = j
ans = 0
graph_x, graph_y, graph_z = graphs
for gx, cx in graph_x.items():
for gy, cy in graph_y.items():
gz = gx ^ gy
if gz in graph_z:
ans = (ans + cx * cy * graph_z[gz]) % MOD
print(ans)
``` | output | 1 | 2,241 | 13 | 4,483 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,242 | 13 | 4,484 |
"Correct Solution:
```
from collections import defaultdict
import sys
input = lambda: sys.stdin.readline().rstrip()
M = 998244353
B = pow(10, 18, M)
N = int(input())
def geometric_mod(a, r, m, n):
x = a
for i in range(n):
yield x
x = (x*r)%m
BB = list(geometric_mod(1, B, M, N+2))
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
sum_g[g[i]] = (sum_g[g[i]] + BB[i]) % M
sum_g[0] = (sum_g[0] + BB[i]) % M
sum_g[0] = (inv_mod(B-1, pow(B, N+1, M)-B, M) - sum_g[0]) % M
return sum_g
def read_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz) % M
return ret
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,242 | 13 | 4,485 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,243 | 13 | 4,486 |
"Correct Solution:
```
from collections import defaultdict
M = 998244353
B = pow(10, 18, M)
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
x = pow(B, i, M)
sum_g[m] = (sum_g[m] + x) % M
sum_g[0] = (sum_g[0] - x) % M
return sum_g
def read_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz)%M
return ret
N = int(input())
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,243 | 13 | 4,487 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,244 | 13 | 4,488 |
"Correct Solution:
```
from collections import defaultdict
M = 998244353
B = 10**18 % M
def mex(s):
for i in range(max(s)+2):
if i not in s:
return i
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in sorted(e.keys(), reverse=True):
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
x = pow(B, i, M)
sum_g[m] += x
sum_g[0] -= x
return sum_g
def read_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz)%M
return ret
N = int(input())
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,244 | 13 | 4,489 |
Provide a correct Python 3 solution for this coding contest problem.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | instruction | 0 | 2,245 | 13 | 4,490 |
"Correct Solution:
```
from collections import defaultdict
M = 998244353
B = pow(10, 18, M)
N = int(input())
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
x = pow(B, i, M)
sum_g[m] += x
sum_g[0] -= x
return sum_g
def read_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret += (sx*sy*sz) % M
return ret%M
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | output | 1 | 2,245 | 13 | 4,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
import itertools
import os
import sys
from collections import defaultdict
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
# MOD = 10 ** 9 + 7
MOD = 998244353
# 解説
# 大きい方から貪欲に取るのの見方を変えるとゲームになる
N = int(sys.stdin.buffer.readline())
M = []
m = int(sys.stdin.buffer.readline())
M.append(m)
XVU = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(m)]
m = int(sys.stdin.buffer.readline())
M.append(m)
YVU = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(m)]
m = int(sys.stdin.buffer.readline())
M.append(m)
ZVU = [list(map(int, sys.stdin.buffer.readline().split())) for _ in range(m)]
X = [[] for _ in range(N)]
Y = [[] for _ in range(N)]
Z = [[] for _ in range(N)]
for G, VU in zip([X, Y, Z], (XVU, YVU, ZVU)):
for v, u in VU:
v -= 1
u -= 1
if v > u:
v, u = u, v
G[v].append(u)
def grundy(graph):
ret = [-1] * N
for v in reversed(range(N)):
gs = set()
for u in graph[v]:
gs.add(ret[u])
g = 0
while g in gs:
g += 1
ret[v] = g
return ret
grundy_x = defaultdict(list)
grundy_y = defaultdict(list)
grundy_z = defaultdict(list)
for x, g in enumerate(grundy(X), 1):
grundy_x[g].append(x)
for y, g in enumerate(grundy(Y), 1):
grundy_y[g].append(y)
for z, g in enumerate(grundy(Z), 1):
grundy_z[g].append(z)
# base[i]: (10^18)^i
base = [1]
for _ in range(N * 3 + 10):
base.append(base[-1] * pow(10, 18, MOD) % MOD)
ans = 0
for xg, yg in itertools.product(grundy_x.keys(), grundy_y.keys()):
zg = xg ^ yg
# 10^(x1+y1+z1) + 10^(x1+y1+z2) + ... + 10^(x1+y2+z1) + ...
# = (10^x1 + 10^x2 + ...) * (10^y1 + ...) * (10^z1 + ...)
xs = 0
ys = 0
zs = 0
for x in grundy_x[xg]:
xs += base[x]
for y in grundy_y[yg]:
ys += base[y]
for z in grundy_z[zg]:
zs += base[z]
ans += xs % MOD * ys % MOD * zs % MOD
ans %= MOD
print(ans)
``` | instruction | 0 | 2,246 | 13 | 4,492 |
Yes | output | 1 | 2,246 | 13 | 4,493 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
def calc():
def mex(i):
t = 0
for j in X[i]:
t |= 1 << G[j]
t = ~t
return (t & -t).bit_length() - 1
M = int(input())
X = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
X[N - min(a, b)].append(N - max(a, b))
G = [0] * N
for i in range(N):
G[i] = mex(i)
H = [0] * 1024
a = 1
for i in range(N)[::-1]:
a = a * A % P
H[G[i]] = (H[G[i]] + a) % P
return H
P = 998244353
A = pow(10, 18, P)
N = int(input())
H1, H2, H3 = calc(), calc(), calc()
ans = 0
for i in range(1024):
if H1[i] == 0: continue
for j in range(1024):
if H2[j] == 0: continue
ans = (ans + H1[i] * H2[j] * H3[i^j]) % P
print(ans)
``` | instruction | 0 | 2,247 | 13 | 4,494 |
Yes | output | 1 | 2,247 | 13 | 4,495 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
mod=998244353
inv=pow(2,mod-2,mod)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
import sys
input=sys.stdin.buffer.readline
N=int(input())
def data():
edge=[[] for i in range(N)]
for i in range(int(input())):
a,b=map(int,input().split())
if a>b:
a,b=b,a
edge[a-1].append(b-1)
mex=[0 for i in range(N)]
for i in range(N-1,-1,-1):
used=[False]*(len(edge[i])+1)
for pv in edge[i]:
if mex[pv]<=len(edge[i]):
used[mex[pv]]=True
for j in range(len(used)):
if not used[j]:
mex[i]=j
break
res=[0]*(max(mex)+1)
for i in range(N):
res[mex[i]]+=pow(10,18*(i+1),mod)
res[mex[i]]%=mod
return res
Xdata=data()
Ydata=data()
Zdata=data()
n=0
m=max(len(Xdata),len(Ydata),len(Zdata))
while 2**n<m:
n+=1
X=[0 for i in range(2**n)]
Y=[0 for i in range(2**n)]
Z=[0 for i in range(2**n)]
for i in range(len(Xdata)):
X[i]=Xdata[i]
for i in range(len(Ydata)):
Y[i]=Ydata[i]
for i in range(len(Zdata)):
Z[i]=Zdata[i]
YZ=xorconv(n,Y,Z)
ans=0
for i in range(2**n):
ans+=X[i]*YZ[i]
ans%=mod
print(ans)
``` | instruction | 0 | 2,248 | 13 | 4,496 |
Yes | output | 1 | 2,248 | 13 | 4,497 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
from collections import defaultdict
M = 998244353
B = pow(10, 18, M)
N = int(input())
def geometric_mod(a, r, m, n):
x = a
for i in range(n):
yield x
x = (x*r)%m
BB = list(geometric_mod(1, B, M, N+2))
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in set(e[i])})
if m:
g[i] = m
sum_g[g[i]] = (sum_g[g[i]] + BB[i]) % M
sum_g[0] = (sum_g[0] - BB[i]) % M
return sum_g
def read_edge():
M = int(input())
e = defaultdict(list)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].append(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz) % M
return ret
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | instruction | 0 | 2,249 | 13 | 4,498 |
Yes | output | 1 | 2,249 | 13 | 4,499 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
data = tuple(map(int,read().split()))
m1 = data[0]
ab = data[1:1+2*m1]
m2 = data[1+2*m1]
cd = data[2+2*m1:2+2*(m1+m2)]
m3 = data[2+2*(m1+m2)]
ef = data[3+2*(m1+m2):]
mod = 998244353
mods = [1] * (n+10)
base = pow(10,18,mod)
for i in range(1,n+1):
mods[i] = (mods[i-1] * base)%mod
def calc_node(xy):
links = [[] for _ in range(n+1)]
it = iter(xy)
for x,y in zip(it,it):
links[x].append(y)
links[y].append(x)
group = [-1] * (n+1)
group[-1] = 0
num_max = 1
for i in range(n,0,-1):
remain = set(range(num_max+2))
for j in links[i]:
if(i < j):
remain.discard(group[j])
num = min(remain)
group[i] = num
num_max = max(num_max,num)
res = [0] * (num_max+1)
for i,num in enumerate(group[1:],1):
res[num] += mods[i]
res[num] %= mod
return res
x = calc_node(ab)
y = calc_node(cd)
z = calc_node(ef)
if(len(x) < len(y)):
x,y = y,x
if(len(y) < len(z)):
y,z = z,y
if(len(x) < len(y)):
x,y = y,x
len_2 = 2**(len(y)-1).bit_length()
yz = [0] * (len_2)
for j in range(len(y)):
for k in range(len(z)):
yz[j^k] += y[j]*z[k]
yz[j^k] %= mod
ans = 0
for i,j in zip(x,yz):
ans += i*j
ans %= mod
print(ans)
``` | instruction | 0 | 2,250 | 13 | 4,500 |
No | output | 1 | 2,250 | 13 | 4,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
def main():
""""ここに今までのコード"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
data = tuple(map(int,read().split()))
m1 = data[0]
ab = data[1:1+2*m1]
m2 = data[1+2*m1]
cd = data[2+2*m1:2+2*(m1+m2)]
m3 = data[2+2*(m1+m2)]
ef = data[3+2*(m1+m2):]
mod = 998244353
mods = [1] * (n+10)
base = pow(10,18,mod)
for i in range(1,n+1):
mods[i] = (mods[i-1] * base)%mod
def calc_node(xy):
links = [[] for _ in range(n+1)]
it = iter(xy)
for x,y in zip(it,it):
if(x < y):
x,y = y,x
links[y].append(x)
group = [-1] * (n+1)
group[-1] = 0
num_max = 1
for i in range(n,0,-1):
remain = set(range(num_max+2))
for j in links[i]:
remain.discard(group[j])
num = min(remain)
group[i] = num
num_max = max(num_max,num)
res = [0] * (num_max+1)
for i,num in enumerate(group[1:],1):
res[num] += mods[i]
res[num] %= mod
return res
x = calc_node(ab)
y = calc_node(cd)
z = calc_node(ef)
if(len(x) < len(y)):
x,y = y,x
if(len(y) < len(z)):
y,z = z,y
if(len(x) < len(y)):
x,y = y,x
len_2 = 2**(len(y)-1).bit_length()
yz = [0] * (len_2)
for j in range(len(y)):
for k in range(len(z)):
yz[j^k] += y[j]*z[k]
yz[j^k] %= mod
ans = 0
for i,j in zip(x,yz):
ans += i*j
ans %= mod
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 2,251 | 13 | 4,502 |
No | output | 1 | 2,251 | 13 | 4,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
from collections import defaultdict
M = 998244353
B = pow(10, 18, M)
N = int(input())
def geometric_mod(a, r, m, n):
x = a
for i in range(n):
yield x
x = (x*r)%m
BB = list(geometric_mod(1, B, M, N+2))
def ext_euc(a, b):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, b
while z1 != 1:
d, m = divmod(z2,z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1, y1
def inv_mod(a, b, m):
x, y = ext_euc(a, m)
return (x * b % m)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(e):
e = set(e)
g = {}
sum_g = defaultdict(int)
sum_g[0] = inv_mod(B-1, pow(B, N+1, M)-B, M)
for i in range(N, 0, -1):
if i not in e:
continue
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
sum_g[g[i]] = (sum_g[g[i]] + BB[i]) % M
sum_g[0] = (sum_g[0] - BB[i]) % M
return sum_g
def read_edge():
M = int(input())
e = defaultdict(list)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].append(b)
return e
def solve(N, edge):
sum_g = list(map(calc_grundy, edge))
ret = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ret = (ret + sx*sy*sz) % M
return ret
edge = [read_edge() for i in range(3)]
print(solve(N, edge))
``` | instruction | 0 | 2,252 | 13 | 4,504 |
No | output | 1 | 2,252 | 13 | 4,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248
Submitted Solution:
```
from collections import defaultdict
M = 998244353
B = 10**18 % M
def mex(s):
for i in range(max(s)+2):
if i not in s:
return i
def calc_grandy(e):
g = {}
rev_g = defaultdict(set)
rev_g[0] = set(range(1, N+1))
for i in sorted(e.keys(), reverse=True):
m = mex({g.get(j,0) for j in e[i]})
if m:
g[i] = m
rev_g[m].add(i)
rev_g[0].remove(i)
return defaultdict(int, ((k,sum(map(lambda x:pow(B, x, M), v))%M) for k, v in rev_g.items()))
def get_edge():
M = int(input())
e = defaultdict(set)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].add(b)
return e
def solve(N, edge):
grandy = list(map(calc_grandy, edge))
ret = 0
for gx, x in grandy[0].items():
for gy, y in grandy[1].items():
gz = gx^gy
z = grandy[2][gz]
ret = (ret + x*y*z)%M
return ret
N = int(input())
edge = [get_edge() for i in range(3)]
print(solve(N, edge))
``` | instruction | 0 | 2,253 | 13 | 4,506 |
No | output | 1 | 2,253 | 13 | 4,507 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,254 | 13 | 4,508 |
"Correct Solution:
```
import sys
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
DBG = True and False
PROBL = 1
MAXVISIT = 400
def ddprint(x):
if DBG:
print(x)
sys.stdout.flush()
def trigger():
return (len(pendreq) > 0)
def nxtnode():
global lastnd, workreq, nxtndary
tgt = workreq[0] if len(workreq)>0 else 1
#ddprint("in nxtnode lastnd {} wr0 {} tgt {} ret {}".format(\
# lastnd, workreq[0] if len(workreq)>0 else -1, tgt, nxtndary[lastnd][tgt]))
return nxtndary[lastnd][tgt]
def atdepot():
return (lastnd==1 and distfromlast==0)
def stay():
#print(-1, flush=True)
print(-1)
sys.stdout.flush()
def readput():
n = inn()
for i in range(n):
inn()
def readverd():
v = input().strip()
if v != 'OK':
exit()
readput()
def move():
global distfromlast, lastnd, workreq
nxtnd = nxtnode()
#print(nxtnd, flush=True)
print(nxtnd)
sys.stdout.flush()
distfromlast += 1
if distfromlast == dist[lastnd][nxtnd]:
distfromlast = 0
if len(workreq)>0 and nxtnd == workreq[0]:
del workreq[0]
lastnd = nxtnd
def ufinit(n):
global ufary, ufrank
ufary = [i for i in range(n)]
ufrank = [0] * n
def ufroot(i):
p = ufary[i]
if p==i:
return p
q = ufroot(p)
ufary[i] = q
return q
def ufmerge(i,j):
global ufary, ufrank
ri = ufroot(i)
rj = ufroot(j)
if ri==rj:
return
if ufrank[ri]>ufrank[rj]:
ufary[rj] = ri
else:
ufary[ri] = rj
if ufrank[ri]==ufrank[rj]:
ufrank[rj] += 1
def setwork():
global pendreq, workreq
vislist = set([x[1] for x in pendreq]) | set(workreq)
vv = len(vislist)
pendreq = []
if vv==1:
workreq = list(vislist)
return
# Clark & Wright
e = {}
f = {}
for x in vislist:
e[x] = []
ufinit(V+1)
#ddprint("e pre")
#ddprint(e)
for _ in range(vv-1):
mx = -1
for i in e:
for j in e:
if ufroot(i)==ufroot(j):
continue
df = dist[i][1] + dist[1][j] - dist[i][j]
if df>mx:
mx = df
mxi = i
mxj = j
i = mxi
j = mxj
e[i].append(j)
e[j].append(i)
ufmerge(i,j)
if len(e[i])==2:
f[i] = e[i]
del e[i]
if len(e[j])==2:
f[j] = e[j]
del e[j]
# now len(e) is 2. find the first
#ddprint("e {}".format(e))
#ddprint("f {}".format(f))
ek = list(e.keys())
p = ek[0]
#q = ek[1]
prev = p
cur = e[p][0]
workreq = [p,cur]
for i in range(vv-2):
p = cur
cur = f[p][0]
if cur==prev:
cur = f[p][1]
prev = p
workreq.append(cur)
#workreq.append(q)
#ddprint("w {}".format(workreq))
def setwork1():
global pendreq, workreq
# sort pend reqs by distance from depot/oldest
oldest = pendreq[0][1]
pendset = set([x[1] for x in pendreq])
sortq = []
for i in [0,1]:
q = []
base = 1 if i==1 else oldest # 0:oldest 1:depot
for x in pendset:
q.append((dist[base][x], x))
q.sort(reverse=True) # shortest at tail
sortq.append(q)
# create visit node list - closest to depot/oldest
vislist = []
while len(vislist) < MAXVISIT and \
(len(sortq[0])>0 or len(sortq[1])>0):
for j in [0,1]:
if len(sortq[j])==0:
continue
d,x = sortq[j].pop()
if x in vislist or x in workreq:
continue
vislist.append(x)
#ddprint("vislist")
#ddprint(vislist)
# create route
prev = 1
while len(vislist)>0:
mn = 9999
for i,x in enumerate(vislist):
d = dist[prev][x]
if d<mn:
mn = d
mni = i
mnx = vislist[mni]
workreq.append(mnx)
del vislist[mni]
prev = mnx
# update pendreq
pendreq = [x for x in pendreq if x[1] not in workreq]
# # # # main start # # # #
ddprint("start")
prob = PROBL # int(sys.argv[1])
V, E = inm()
es = [[] for i in range(V+1)]
dist = [[9999]*(V+1) for i in range(V+1)]
for i in range(V+1):
dist[i][i] = 0
for i in range(E):
a, b, c = inm()
#a, b = a-1, b-1
es[a].append((b,c))
es[b].append((a,c))
dist[a][b] = dist[b][a] = c
if DBG:
for i,z in enumerate(es):
print(str(i)+' ' + str(z))
# Warshal-Floyd
for k in range(1,V+1):
for i in range(1,V+1):
for j in range(1,V+1):
dist[i][j] = min(dist[i][j], \
dist[i][k]+dist[k][j])
ddprint("WS done")
nxtndary = [[0]*(V+1) for i in range(V+1)]
for i in range(1,V+1):
for j in range(1,V+1):
if j==i:
continue
found = False
for z in es[i]:
k = z[0]
if dist[i][j] == z[1]+dist[k][j]:
nxtndary[i][j] = k
found = True
break
if not found:
print("nxtndary ERR")
exit()
if prob==2:
F = inl()
tt = inn()
pendreq = []
workreq = []
lastnd = 1
distfromlast = 0
for t in range(tt):
#ddprint("t {} lastnd {} dist {}".format( \
# t,lastnd,distfromlast))
#ddprint(pendreq)
#ddprint(workreq)
if DBG and t>3400:
exit()
# read a new req if any
n = inn()
if n==1:
new_id, dst = inm()
#ddprint("new req id {} dst {}".format(new_id, dst))
pendreq.append((new_id, dst))
if prob==2:
readput()
# determine action
if atdepot():
if trigger():
setwork()
if len(workreq)>0:
move()
else:
stay()
else:
stay()
else:
move()
if prob==2:
readverd()
``` | output | 1 | 2,254 | 13 | 4,509 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,255 | 13 | 4,510 |
"Correct Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
from math import sqrt
from itertools import permutations
def root_search(order, cost, wf, V): #店舗から出るときの探索
type_num = len(order)
hold = [] #holdで上位n個のみ保持し、最後に残ったものをpre_holdに移す
heapify(hold)
pre_hold = [] #一段階前の確定した道順
pre_hold.append((0, "0", set() | order, 0)) #cost, pass, left, id
hold_size = 0
for i in range(type_num):
for pre_cost, pre_pass, to_search, pre_id in pre_hold:
for key in to_search:
heappush(hold, (pre_cost + wf[pre_id][key] / sqrt(cost[key][1]), " ".join([pre_pass, str(key)]), to_search - {key}, key))
hold_size += 1
pre_hold = []
for _ in range(min(hold_size, 3)):
pre_hold.append(heappop(hold))
hold = []
hold_size = 0
ans_cost, ans_pass, ans_search, ans_id = pre_hold[0]
pass_list = [int(v) for v in ans_pass.split()]
pass_list.append(0)
return pass_list
def decide_next_dst(cost, order, current_id, final_dist, store_hold, wf):
c = store_hold * 1000 / wf[current_id][0]
for key in order:
if cost[key][1] * 10000 / wf[current_id][key] > c: return final_dist
return 0
def solve():
inf = 10000000000
input = sys.stdin.readline
#fin = open("sampleinput.txt", "r")
#input = fin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i, j in permutations(range(V), 2):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
T = int(input())
order = set()
stuck_order = set()
command = dict()
for t in range(T): command[t] = -1
heading = 0 #次に向かう地点
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
driver_hold = 0
root_pointer = 0
store_list = [0] * V
root_list = []
cost = dict()
for i in range(V):
cost[i] = [0, 0]
store_hold = 0
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
store_hold += 1
store_list[dst - 1] += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
if store_hold == driver_hold == 0:
continue
else:
order |= stuck_order
driver_hold += store_hold
for key in order:
cost[key][1] += 0.5 * cost[key][0] + store_list[key]
cost[key][0] += store_list[key]
store_list[key] = 0
stuck_order = set()
store_hold = 0
root_list = root_search(order, cost, wf, V)
current_id = heading = final_dist = 0
root_pointer = 0
root_size = len(root_list)
if heading in order:
order.remove(heading)
driver_hold -= cost[heading][0]
cost[heading] = [0, 0]
current_id = heading #現在地の更新
if current_id == final_dist:
for j in range(root_pointer, root_size - 1):
if cost[root_list[j + 1]][0] > 0:
final_dist = root_list[j + 1]
root_pointer = j + 1
if current_id > 0 and store_hold > 0:
final_dist = decide_next_dst(cost, order, current_id, final_dist, store_hold, wf)
break
else: final_dist = 0
heading = next_id[current_id][final_dist]
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
#out = open(str(V) + "-" + str(E) + "-out.txt", "w")
# i in range(T):
#print(command[i], file = out, end ="\n")
#out.close
return 0
if __name__ == "__main__":
solve()
``` | output | 1 | 2,255 | 13 | 4,511 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,256 | 13 | 4,512 |
"Correct Solution:
```
"""https://atcoder.jp/contests/hokudai-hitachi2019-1/tasks/hokudai_hitachi2019_1_a
Time Limit: 30 sec / Memory Limit: 1024 MB
# Score
score := time_max**2 * n_deleverd - sum((deleverd_time[i] - ordered_time[i])**2 for i in deleverd)
# Requirements
- time_max = 10_000
- 200 <= n_vertices <= 400
- 1.5*n_vertices <= n_edges <= 2*n_vertices
- 1 <= d <= ceil(4*sqrt(2*n_vertices)) <= 114
# Output
- stay ==> -1
- move x ==> x
"""
import collections
import sys
STAY = -1
BASE_POS = 0
class Order:
def __init__(self, order_id, ordered_time, destination):
self.order_id = order_id
self.ordered_time = ordered_time
self.destination = destination
def __str__(self):
return 'Order' + str((self.order_id, self.ordered_time, self.destination))
class Graph:
def __init__(self, n_vertices, n_edges):
self.n_vertices = n_vertices
self.n_edges = n_edges
self.adjacency_list = [[] for i in range(n_vertices)]
self.distances = [[float('inf')] * (n_vertices)
for _ in range(n_vertices)]
self.transits = [[j for j in range(n_vertices)]
for i in range(n_vertices)]
def add_edge(self, u, v, d):
self.adjacency_list[u].append((v, d))
self.adjacency_list[v].append((u, d))
self.distances[u][v] = d
self.distances[v][u] = d
self.transits[u][v] = v
self.transits[v][u] = u
def floyd_warshall(self):
for i in range(self.n_vertices):
self.distances[i][i] = 0
self.transits[i][i] = i
for k in range(self.n_vertices):
for i in range(self.n_vertices):
for j in range(self.n_vertices):
if self.distances[i][j] > self.distances[i][k] + self.distances[k][j]:
self.distances[i][j] = self.distances[i][k] + \
self.distances[k][j]
self.transits[i][j] = self.transits[i][k]
def get_orders(ordered_time):
n_new_order = int(input()) # 0 <= n_new_order <= 1
orders = []
for _ in range(n_new_order):
# 1 <= order_id <= time_max+1
# 2 <= destination <= n_vertices
order_id, destination = map(int, input().split())
orders.append(Order(order_id, ordered_time, destination-1))
return orders
def get_input():
n_vertices, n_edges = map(int, input().split())
graph = Graph(n_vertices, n_edges)
for _ in range(n_edges):
u, v, d = map(int, input().split())
graph.add_edge(u-1, v-1, d)
graph.floyd_warshall()
# Floyd–Warshall algorithm
time_max = int(input())
orders = []
for time_index in range(time_max):
new_orders = get_orders(time_index)
for order in new_orders:
orders.append(order)
return graph, time_max, orders
def solve(graph, time_max, orders):
car_on_vertex = True
car_pos = BASE_POS
# edge_car_driving = (0, 0)
next_pickup = 0
commands = [-1] * time_max
cargo = []
t = 0
while t < time_max:
# pick up cargos
if car_on_vertex and car_pos == BASE_POS:
while next_pickup < len(orders) and orders[next_pickup].ordered_time <= t:
cargo.append(orders[next_pickup])
next_pickup += 1
if cargo:
cargo.sort(key=lambda x: (t-x.ordered_time +
graph.distances[car_pos][x.destination]) ** 2)
print(','.join([str(c) for c in cargo]), file=sys.stderr)
dist = cargo[0].destination
if time_max <= t + graph.distances[car_pos][dist]:
cargo = cargo[1:] # TODO: 高速化
continue
transit_point = graph.transits[car_pos][dist]
need_time_for_move = graph.distances[car_pos][transit_point]
for i in range(need_time_for_move):
commands[t + i] = transit_point
t += need_time_for_move
car_pos = transit_point
cargo = cargo[1:] # TODO: 高速化
continue
else:
if car_on_vertex:
if car_pos == BASE_POS:
commands[t] = STAY
else:
transit_point = graph.transits[car_pos][BASE_POS]
need_time_for_move = graph.distances[car_pos][transit_point]
if time_max <= t + need_time_for_move:
t = time_max
break
for i in range(need_time_for_move):
commands[t + i] = transit_point
t += need_time_for_move
car_pos = transit_point
continue
else:
pass
commands[t] = STAY
t += 1
return commands
def simulate(graph, time_max, orders, commands):
car_on_vertex = True
car_pos = BASE_POS
return 0
def main():
graph, time_max, orders = get_input()
commands = solve(graph, time_max, orders)
for command in commands:
if command == STAY:
print(STAY)
else:
print(command+1)
if __name__ == "__main__":
main()
``` | output | 1 | 2,256 | 13 | 4,513 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,257 | 13 | 4,514 |
"Correct Solution:
```
def empty(t_max):
return [-1] * t_max
def main():
nv, ne = map(int, input().split())
# graph
graph_dict = dict()
for i in range(nv):
graph_dict[i + 1] = dict()
for _ in range(ne):
u, v, d = map(int, input().split())
graph_dict[u][v] = d
graph_dict[v][u] = d
# orders
t_max = int(input())
order_list = [[] for _ in range(t_max)]
for t in range(t_max):
n_new = int(input())
for _ in range(n_new):
new_id, dst = map(int, input().split())
order_list[t].append([new_id, dst])
res = empty(t_max)
for r in res:
print(r)
if __name__ == "__main__":
main()
``` | output | 1 | 2,257 | 13 | 4,515 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,258 | 13 | 4,516 |
"Correct Solution:
```
import copy
##############################
# 指定した商品データを削除する処理
##############################
def deleteProduct(nowPos):
global product
for i in reversed(range(len(product))):
#削除したので、ループ回数上限を再チェック
# if i >= len(product):
# break
if nowPos == product[i][2]:
del product[i]
# product = [ x for x in product if product[x][2] != nowPos ]
##############################
# 指定の場所までの距離を取得する処理
##############################
def getDistance(x, y):
global route
global temp_node
temp_node.clear()
temp_node = [[] for i in range(V)] # ([経路情報]、確定ノードフラグ、コストi、ノード変更元)
NODE_ROUTE = 0 #経路情報
NODE_DEFINED = 1 #確定ノードフラグ
NODE_COST = 2 #コスト
NODE_CHG_FROM= 3 #どのノードに変更されたか
distance = 100
for i in range(V):
temp_node[i].append(copy.deepcopy(es[i]))#経路情報
temp_node[i].append(0) #確定ノードフラグ
temp_node[i].append(-1) #コスト
temp_node[i].append(0) #ノード変更元
#スタートノードのコストは0
temp_node[y][NODE_COST] = 0
while 1:
#確定ノードを探索
for i in range(V):
if temp_node[i][NODE_DEFINED] == 1 or temp_node[i][NODE_COST] < 0:
continue
else:
break
#全て確定ノードになったら完了
loop_end_flag = 1
for k in range(len(temp_node)):
if temp_node[k][NODE_DEFINED] == 0:
loop_end_flag = 0
if loop_end_flag == 1:
break
#ノードを確定させる
temp_node[i][NODE_DEFINED] = 1
#行先のノード情報を更新する
temp_node_to = 0
temp_node_cost = 0
for j in range(len(temp_node[i][NODE_ROUTE])):
temp_node_to = temp_node[i][NODE_ROUTE][j][0]
temp_node_cost = temp_node[i][NODE_COST] + temp_node[i][NODE_ROUTE][j][1]
if temp_node[temp_node_to][NODE_COST] < 0:
temp_node[temp_node_to][NODE_COST] = temp_node_cost
temp_node[temp_node_to][NODE_CHG_FROM] = i
elif temp_node[temp_node_to][NODE_COST] > temp_node_cost:
temp_node[temp_node_to][NODE_COST] = temp_node_cost
temp_node[temp_node_to][NODE_CHG_FROM] = i
#探索結果から距離とルートを確定
cost=0
route_num = 0
i=x
route.clear()
distance=0
while 1:
cost = cost + temp_node[i][NODE_COST]
if y == i:
distande = cost
break
moto_node = i
i = temp_node[i][NODE_CHG_FROM]#次の行先を取得
route.append([i,0])#次の行先をルートに追加
#行先ルートのコストを取得する
for j in range(len(temp_node[moto_node][0])):#持ってるルート内の
if temp_node[moto_node][0][j][0] == route[route_num][0]:#行先を探索
route[route_num][1]=temp_node[moto_node][0][j][1]
distance = distance + route[route_num][1]
route_num = route_num + 1
return distance
##############################
# 商品リストから目的地を決定する処理
##############################
route = []
def getTargetPos(now_pos):
global product
global pos
global route
#route = [None for i in range(200)]
# pos = -1
# distance = 201
# for i in range(len(product)):
# if distance > getDistance(now_pos,product[i][2]):
# distance = getDistance(now_pos,product[i][1])
# pos = product[i][2]
# for i in range(len(product)):
# break
#とりあえず上から順番に配達する
pos = (product[0][2])
return pos
##############################
# お店で商品を受け取る処理
##############################
product=[]
def getProduct(currentTime):
for i in range(len(order)):
if time_step_befor <= order[i][0] <= time_step:
#if order[i][0] == currentTime:
product.append ( copy.deepcopy(order[i]) )
##############################
# 指定の場所まで車を進める処理
##############################
def gotoVertex(x,y):
global nowPos
global route
global total_move_count
#コマンド出力
i=0
while 1:
if x==y:
print (-1)#移動なし
total_move_count = total_move_count + 1
# 指定時間オーバー
if total_move_count >= T:
return
break
if route[i][0] == y:#ルート先が終着点
for j in range(route[i][1]):
print(route[i][0]+1)
if len(product) != 0:
deleteProduct(route[i][0]) # 通過した場合は荷物を配達する
total_move_count = total_move_count + 1
# 指定時間オーバー
if total_move_count >= T:
return
break
else:#ルート途中
for j in range(route[i][1]):
print (route[i][0]+1)
if len(product) != 0:
deleteProduct(route[i][0]) # 通過した場合は荷物を配達する
total_move_count = total_move_count + 1
# 指定時間オーバー
if total_move_count >= T:
return
i = i + 1
#nowPosを目的地点まで進める
nowPos = y
def initProduct(nowPos):
global temp_node
global product
# プロダクト毎に、ダイクストラをかける
#for i in range(len(product)):
# product[i][3] = getDistance(nowPos, product[i][2])
getDistance(nowPos,V-2)
for i in range(len(product)):
for j in range(len(temp_node)):
if product[i][2] == j:#プロダクトと一致するノードがあったら
product[i][3] = temp_node[j][2]
break
# 出来上がったproductをソート
product = sorted(product,key=lambda x:x[3])
# product = sorted(product,key=lambda x:x[3])
# recieve |V| and |E|
V, E = map(int, input().split())
es = [[] for i in range(V)]
for i in range(E):
# recieve edges
a, b, c = map(int, input().split())
a, b = a-1, b-1
es[a].append([b,c])#(行先、経路コスト)
es[b].append([a,c])#(行先、経路コスト)
T = int(input())
# recieve info
order=[]
temp_node = [[] for i in range(V)] # ([経路情報]、確定ノードフラグ、コストi、ノード変更元)
total_move_count = 0
for i in range(T):
Nnew = int(input())
for j in range(Nnew):
new_id, dst = map(int, input().split())
order.append([i, new_id, (dst-1), 0])#(注文時間,注文ID,配達先,処理フラグ)
# insert your code here to get more meaningful output
# all stay
nowPos = 0 # 現在地
targetPos = -1
time_step=0
time_step_befor=0
for i in range(T) :
if total_move_count >= T:
break
#現在地がお店なら注文の商品を受け取る
if nowPos == 0:
getProduct(time_step)
time_step_befor = time_step
# if i == 0:#初回のみ
if len(product) != 0:
initProduct(nowPos)
else:
print (-1)
time_step = time_step + 1
total_move_count = total_move_count + 1
if total_move_count >= T:
break
continue
#商品が尽きたら終了
#if len(product) == 0:
# while 1:
# gotoVertex(nowPos, 0)
# print (-1)
# if total_move_count>=T:
# break
#一番近いところに向かう
if len(product) != 0:
targetPos = getTargetPos(nowPos);
time_step = time_step + getDistance(nowPos,targetPos)
gotoVertex(nowPos,targetPos)
continue
#持ってる商品情報を削除
# if nowPos == targetPos:
# deleteProduct(nowPos)
#次のところへ向かう 以下ループ
#持っている商品が無くなったらお店へ向かう
if len(product) == 0 and nowPos != 0:
time_step = time_step + getDistance(nowPos,0)
#getDistance(nowPos,0)
gotoVertex(nowPos,0)
continue
#
``` | output | 1 | 2,258 | 13 | 4,517 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,259 | 13 | 4,518 |
"Correct Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
def decide_next_dst(cost, order):
d = 0
c = 0
for key in order:
if cost[key][0] > c:
d = key
c = cost[key][0]
return (d, c)
def solve():
inf = 10000000000
input = sys.stdin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
far = dict()
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i in range(V):
for j in range(V):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
T = int(input())
order = set()
stuck_order = set()
command = [None] * T
heading = 0 #次に向かう地点
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
stuck_cost = [[0, 0] for _ in range(V)]
cost = [[0, 0] for _ in range(V)]
driver_hold = 0
store_hold = 0
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
stuck_cost[dst - 1][0] += (5000 - t) ** 2
stuck_cost[dst - 1][1] += 1
store_hold += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
if store_hold == driver_hold == 0:
command[t] = -1
continue
else:
order |= stuck_order
for key in order:
cost[key][0] += stuck_cost[key][0]
cost[key][1] += stuck_cost[key][1]
driver_hold += stuck_cost[key][1]
stuck_cost[key] = [0, 0]
stuck_order = set()
store_hold = 0
if heading in order and heading > 0: #顧客のいる場所で荷物を積み下ろすとき
order -= {heading}
driver_hold -= cost[heading][1]
cost[heading] = [0, 0]
current_id = heading #現在地の更新
if len(order) > 0: #まだ配達すべき荷物があるとき
if current_id == final_dist: #目的地に到着したときは残りの荷物で先に運ぶべき荷物を選ぶ
final_dist, max_hold = decide_next_dst(cost, order)
if driver_hold < store_hold and current_id > 0: final_dist = 0
else: final_dist = 0 #荷物が無いので店に戻る
heading = next_id[current_id][final_dist]
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
return 0
if __name__ == "__main__":
solve()
``` | output | 1 | 2,259 | 13 | 4,519 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,260 | 13 | 4,520 |
"Correct Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
def decide_final_dst(cost, order, current_id, store_cost, wf, dmax):
d = 0
c = (store_cost * (dmax / wf[current_id][0]) ** 2 if current_id > 0 else 0) * 0.1
for key in order:
if cost[key] * (dmax / wf[current_id][key]) ** 2 > c:
d = key
c = cost[key] * (dmax / wf[current_id][key]) ** 2
return d
def decide_next_dst(cost, order, current_id, pre_id, heading, edge, wf, passed, V, dmax):
c = cost[heading] * (dmax / wf[current_id][heading]) ** 2
if heading in passed:
for e in range(V):
if e != current_id and e != pre_id and wf[current_id][e] < 10000000000:
if cost[e] * (dmax / wf[current_id][e]) ** 2 > c:
heading = e
c = cost[e] * (dmax / wf[current_id][e]) ** 2
return
def solve():
inf = 10000000000
input = sys.stdin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i in range(V):
for j in range(V):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
#グラフの直径を求める
dmax = 0
for i in range(V): dmax = max(dmax, max(wf[i]))
T = int(input())
order = set()
stuck_order = set()
command = [None] * T
heading = 0 #次に向かう地点
pre_id = 0 #前の地点
current_id = 0
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
stuck_cost = [0 for _ in range(V)]
cost = [0 for _ in range(V)]
driver_hold = 0
store_hold = 0
passed = set()
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
stuck_cost[dst - 1] += 1
store_hold += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
passed = set()
if store_hold == driver_hold == 0: #運ぶべき荷物がなければ待機
command[t] = -1
continue
else:
order |= stuck_order
for key in order:
cost[key] += stuck_cost[key]
driver_hold += stuck_cost[key]
stuck_cost[key] = 0
stuck_order = set()
store_hold = 0
if heading in order and heading > 0: #顧客のいる場所で荷物を積み下ろすとき
order -= {heading}
driver_hold -= cost[heading]
cost[heading] = 0
pre_id = current_id #前の地点の更新
current_id = heading #現在地の更新
passed |= {heading}
if len(order) > 0: #まだ配達すべき荷物があるとき
if current_id == final_dist: #目的地に到着したときは残りの荷物で先に運ぶべき荷物を選ぶ
final_dist = decide_final_dst(cost, order, current_id, store_hold, wf, dmax)
else: final_dist = 0 #荷物が無いので店に戻る
heading = next_id[current_id][final_dist]
decide_next_dst(cost, order, current_id, pre_id, heading, edge, wf, passed, V, dmax)
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
return 0
if __name__ == "__main__":
solve()
``` | output | 1 | 2,260 | 13 | 4,521 |
Provide a correct Python 3 solution for this coding contest problem.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | instruction | 0 | 2,261 | 13 | 4,522 |
"Correct Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
def decide_next_dst(cost, order):
d = 0
c = 0
for key in order:
if cost[key][0] > c:
d = key
c = cost[key][0]
return (d, c)
def solve():
inf = 10000000000
input = sys.stdin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i in range(V):
for j in range(V):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
T = int(input())
order = set()
stuck_order = set()
command = [None] * T
heading = 0 #次に向かう地点
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
stuck_cost = [[0, 0] for _ in range(V)]
cost = [[0, 0] for _ in range(V)]
driver_hold = 0
store_hold = 0
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
stuck_cost[dst - 1][0] += (10000 - t) ** 2
stuck_cost[dst - 1][1] += 1
store_hold += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
if store_hold == driver_hold == 0:
command[t] = -1
continue
else:
order |= stuck_order
for key in order:
cost[key][0] += stuck_cost[key][0]
cost[key][1] += stuck_cost[key][1]
driver_hold += stuck_cost[key][1]
stuck_cost[key] = [0, 0]
stuck_order = set()
store_hold = 0
if heading in order and heading > 0: #顧客のいる場所で荷物を積み下ろすとき
order -= {heading}
driver_hold -= cost[heading][1]
cost[heading] = [0, 0]
current_id = heading #現在地の更新
if len(order) > 0: #まだ配達すべき荷物があるとき
if current_id == final_dist: #目的地に到着したときは残りの荷物で先に運ぶべき荷物を選ぶ
final_dist, max_hold = decide_next_dst(cost, order)
if driver_hold < store_hold and current_id > 0: final_dist = 0
else: final_dist = 0 #荷物が無いので店に戻る
heading = next_id[current_id][final_dist]
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
return 0
if __name__ == "__main__":
solve()
``` | output | 1 | 2,261 | 13 | 4,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
def decide_next_dst(cost, order, current_id, store_cost, wf):
d = 0
c = (store_cost * (10000/wf[current_id][0]) if current_id > 0 else 0) * 0.1
for key in order:
if cost[key][1] * (10000 / wf[current_id][key])> c:
d = key
c = cost[key][1] * (10000 / wf[current_id][key])
return d
def solve():
inf = 10000000000
input = sys.stdin.readline
#fin = open("sampleinput.txt", "r")
#input = fin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i in range(V):
for j in range(V):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
T = int(input())
order = set()
stuck_order = set()
command = [None] * T
heading = 0 #次に向かう地点
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
stuck_cost = [0 for _ in range(V)]
cost = [[0, 0] for _ in range(V)]
driver_hold = 0
store_hold = 0
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
stuck_cost[dst - 1] += 1
store_hold += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
if store_hold == driver_hold == 0:
command[t] = -1
continue
else:
order |= stuck_order
for key in order:
cost[key][1] += cost[key][0] * 0.5
cost[key][0] += stuck_cost[key]
cost[key][1] += stuck_cost[key]
driver_hold += stuck_cost[key]
stuck_cost[key] = 0
stuck_order = set()
store_hold = 0
if heading in order and heading > 0: #顧客のいる場所で荷物を積み下ろすとき
order -= {heading}
driver_hold -= cost[heading][0]
cost[heading] = [0, 0]
current_id = heading #現在地の更新
if len(order) > 0: #まだ配達すべき荷物があるとき
if current_id == final_dist: #目的地に到着したときは残りの荷物で先に運ぶべき荷物を選ぶ
final_dist = decide_next_dst(cost, order, current_id, store_hold, wf)
else: final_dist = 0 #荷物が無いので店に戻る
heading = next_id[current_id][final_dist]
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
#out = open(str(V) + "-" + str(E) + "-out.txt", "w")
#for i in range(T):
#print(command[i], file = out, end ="\n")
#out.close
return 0
if __name__ == "__main__":
solve()
``` | instruction | 0 | 2,262 | 13 | 4,524 |
Yes | output | 1 | 2,262 | 13 | 4,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
import copy
##############################
# 指定した商品データを削除する処理
##############################
def deleteProduct(nowPos):
global product
for i in reversed(range(len(product))):
#削除したので、ループ回数上限を再チェック
# if i >= len(product):
# break
if nowPos == product[i][2]:
del product[i]
# product = [ x for x in product if product[x][2] != nowPos ]
##############################
# 指定の場所までの距離を取得する処理
##############################
NODE_ROUTE = 0 # 経路情報
NODE_DEFINED = 1 # 確定ノードフラグ
NODE_COST = 2 # コスト
NODE_CHG_FROM = 3 # どのノードに変更されたか
def getDistance(x, y):
global route
global temp_node
temp_node.clear()
temp_node = [[] for i in range(V)] # ([経路情報]、確定ノードフラグ、コストi、ノード変更元)
distance = 100
for i in range(V):
temp_node[i].append(copy.deepcopy(es[i]))#経路情報
temp_node[i].append(0) #確定ノードフラグ
temp_node[i].append(-1) #コスト
temp_node[i].append(0) #ノード変更元
#スタートノードのコストは0
temp_node[y][NODE_COST] = 0
while 1:
#確定ノードを探索
for i in range(V):
if temp_node[i][NODE_DEFINED] == 1 or temp_node[i][NODE_COST] < 0:
continue
else:
break
#全て確定ノードになったら完了
loop_end_flag = 1
for k in range(len(temp_node)):
if temp_node[k][NODE_DEFINED] == 0:
loop_end_flag = 0
if loop_end_flag == 1:
break
#ノードを確定させる
temp_node[i][NODE_DEFINED] = 1
#行先のノード情報を更新する
temp_node_to = 0
temp_node_cost = 0
for j in range(len(temp_node[i][NODE_ROUTE])):
temp_node_to = temp_node[i][NODE_ROUTE][j][0]
temp_node_cost = temp_node[i][NODE_COST] + temp_node[i][NODE_ROUTE][j][1]
if temp_node[temp_node_to][NODE_COST] < 0:
temp_node[temp_node_to][NODE_COST] = temp_node_cost
temp_node[temp_node_to][NODE_CHG_FROM] = i
elif temp_node[temp_node_to][NODE_COST] > temp_node_cost:
temp_node[temp_node_to][NODE_COST] = temp_node_cost
temp_node[temp_node_to][NODE_CHG_FROM] = i
if temp_node_to == y:
loop_end_flag = 1
#探索結果から距離とルートを確定
distance = decide_route(x,y)
return distance
##############################
# 探索結果から距離とルートを確定
##############################
def decide_route(x,y):
cost=0
route_num = 0
i=x
route.clear()
distance=0
while 1:
cost = cost + temp_node[i][NODE_COST]
if y == i:
distande = cost
break
moto_node = i
i = temp_node[i][NODE_CHG_FROM]#次の行先を取得
route.append([i,0])#次の行先をルートに追加
#行先ルートのコストを取得する
for j in range(len(temp_node[moto_node][0])):#持ってるルート内の
if temp_node[moto_node][0][j][0] == route[route_num][0]:#行先を探索
route[route_num][1]=temp_node[moto_node][0][j][1]
distance = distance + route[route_num][1]
route_num = route_num + 1
return distance
##############################
# 商品リストから目的地を決定する処理
##############################
route = []
def getTargetPos(now_pos):
global product
global pos
global route
global prePos
#route = [None for i in range(200)]
# pos = -1
# distance = 201
# for i in range(len(product)):
# if distance > getDistance(now_pos,product[i][2]):
# distance = getDistance(now_pos,product[i][1])
# pos = product[i][2]
# for i in range(len(product)):
# break
#注文が滞ったら
count = 0
for i in range(len(order)):
#if order[i][0] == currentTime:
if time_step_before < order[i][0] <= time_step:
count = count + 1
#とりあえず上から順番に配達する
if count > len(product)/2:
pos = 0
else:
pos = (product[-1][2])
return pos
##############################
# お店で商品を受け取る処理
##############################
product=[]
def getProduct(currentTime):
for i in range(len(order)):
#if order[i][0] == currentTime:
if time_step_before < order[i][0] <= currentTime:
product.append ( copy.deepcopy(order[i]) )
##############################
# 指定の場所まで車を進める処理
##############################
prePos=0
def gotoVertex(x,y):
global nowPos
global route
global total_move_count
#コマンド出力
prePos = nowPos
nowPos = -1
print (route[0][0]+1)
route[0][1] = route[0][1] - 1
if route[0][1] == 0:
deleteProduct(route[0][0]) # 通過した場合は荷物を配達する
nowPos = route[0][0] # nowPosを目的地点まで進める
del route[0]
##############################
# その場で待機するか、配達に行くか決定する
##############################
def selectWait():
global wait_cost
global go_cost
global result_cost
#次の注文までの待ち時間
for i in range(len(order)):
if time_step < order[i][0]:
wait_cost = order[i][0]-time_step
break
# 行先までのコスト
if len(product) <= 2:#二週目以降は計算しない
go_cost = getDistance(nowPos,product[0][2])
if wait_cost - go_cost > 0:
result_cost = wait_cost - go_cost
else:
result_cost = go_cost - wait_cost
#コスト比較
# if wait_cost < go_cost:
if len(product) > 50:
return 0
elif wait_cost <= 10:
#elif wait_cost < go_cost*2:
return 1
else:
return 0
def initProduct(nowPos):
global temp_node
global product
# プロダクト毎に、ダイクストラをかける
# for i in range(len(product)):
# #product[i][3] = getDistance(nowPos, product[i][2])
# product[i][3] = decide_route(nowPos, product[i][2])
#product[0][3] = getDistance(nowPos,product[0][2])
#for i in range(len(product)-1):
# product[i][3] = getDistance(product[i][2],product[i+1][2])
#product = sorted(product,key=lambda x:x[3])
getDistance(nowPos,product[0][2])
for i in range(len(product)):
for j in range(len(temp_node)):
if product[i][2] == j:#プロダクトと一致するノードがあったら
product[i][3] = temp_node[j][2]
# 出来上がったproductをソート
product = sorted(product,key=lambda x:x[3])
#product.reverse()
# product = sorted(product,key=lambda x:x[3])
# recieve |V| and |E|
V, E = map(int, input().split())
es = [[] for i in range(V)]
for i in range(E):
# recieve edges
a, b, c = map(int, input().split())
a, b = a-1, b-1
es[a].append([b,c])#(行先、経路コスト)
es[b].append([a,c])#(行先、経路コスト)
T = int(input())
# recieve info
order=[]
temp_node = [[] for i in range(V)] # ([経路情報]、確定ノードフラグ、コストi、ノード変更元)
total_move_count = 0
for i in range(T):
Nnew = int(input())
for j in range(Nnew):
new_id, dst = map(int, input().split())
order.append([i, new_id, (dst-1), 0])#(注文時間,注文ID,配達先,処理フラグ)
# insert your code here to get more meaningful output
# all stay
nowPos = 0 # 現在地
targetPos = -1
time_step=0
time_step_before=0
for i in range(T) :
if time_step >= T:
break
#現在地がお店なら注文の商品を受け取る
if nowPos == 0:
getProduct(time_step)
time_step_before = time_step # 以前訪れた時間
# if i == 0:#初回のみ
if len(product) != 0:
if selectWait() == 1:
print(-1)
time_step = time_step + 1
total_move_count = total_move_count + 1
if time_step >= T:
break
continue
else:
time_step = time_step
initProduct(nowPos)
else:
print (-1)
time_step = time_step + 1
total_move_count = total_move_count + 1
if time_step >= T:
break
continue
#商品が尽きたら終了
#if len(product) == 0:
# while 1:
# gotoVertex(nowPos, 0)
# print (-1)
# if total_move_count>=T:
# break
#一番近いところに向かう
if len(product) != 0:
targetPos = getTargetPos(nowPos);
if len(route) == 0:
getDistance(nowPos,targetPos)
gotoVertex(nowPos,targetPos)
time_step = time_step + 1
continue
#持ってる商品情報を削除
# if nowPos == targetPos:
# deleteProduct(nowPos)
#次のところへ向かう 以下ループ
#持っている商品が無くなったらお店へ向かう
if len(product) == 0 and nowPos != 0:
if len(route) == 0:
getDistance(nowPos,0)
gotoVertex(nowPos,0)
time_step = time_step + 1
continue
# vardict = input()
# if vardict == 'NG':
# sys.exit()
# the number of orders that have been delivered at time t.
# Nachive = int(input())
# for j in range(Nachive):
# achive_id = int(input())
``` | instruction | 0 | 2,263 | 13 | 4,526 |
Yes | output | 1 | 2,263 | 13 | 4,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
import sys
from collections import deque
from heapq import heapify, heappop, heappush
def decide_final_dst(cost, order, current_id, store_cost, wf, dav):
d = 0
c = (store_cost * (10000 / wf[current_id][0]) if current_id > 0 else 0) * (1 / dav)
for key in order:
if cost[key] * (10000 / wf[current_id][key]) > c:
d = key
c = cost[key] * (10000 / wf[current_id][key])
return d
def decide_next_dst(cost, order, current_id, pre_id, heading, edge, wf, passed, V):
c = cost[heading] * (10000 / wf[current_id][heading])
if heading in passed or c == 0:
for e in range(V):
if e != current_id and wf[current_id][e] < 10000000000:
if cost[e] * (10000 / wf[current_id][e]) > c:
heading = e
c = cost[e]* (10000 / wf[current_id][e])
return
def solve():
inf = 10000000000
input = sys.stdin.readline
V, E = map(int, input().split())
edge = dict()
wf = dict()
next_id = dict() #iからjに行くときにiの次に訪れる地点
for i in range(V):
edge[i] = dict()
wf[i] = dict()
next_id[i] = dict()
for j in range(V):
edge[i][j] = (0 if i == j else inf)
next_id[i][j] = j
wf[i][j] = (0 if i == j else inf)
for _ in range(E):
u, v, d = map(int, input().split())
edge[u - 1][v - 1] = d
edge[v - 1][u - 1] = d
wf[u - 1][v - 1] = d
wf[v - 1][u - 1] = d
#全頂点最短経路と目的の頂点に向かうとき次に行くべき頂点の復元
for k in range(V):
for i in range(V):
for j in range(V):
if wf[i][j] > wf[i][k] + wf[k][j]:
wf[i][j] = wf[i][k] + wf[k][j]
next_id[i][j] = next_id[i][k]
#店からの平均距離
daverage = sum(wf[0]) / (V - 1)
T = int(input())
order = set()
stuck_order = set()
command = [None] * T
heading = 0 #次に向かう地点
pre_id = 0 #前の地点
current_id = 0
dist_left = 0 #次に向かう地点までの残り距離
final_dist = 0
stuck_cost = [0 for _ in range(V)]
cost = [0 for _ in range(V)]
driver_hold = 0
store_hold = 0
passed = set()
for t in range(T):
N = int(input()) #注文の発生
if N == 1:
new_id, dst = map(int, input().split())
stuck_order |= {dst - 1}
stuck_cost[dst - 1] += 1
store_hold += 1
if dist_left > 0: #移動中の場合そのまま移動を続ける
command[t] = heading + 1
dist_left -= 1
else:
if heading == 0: #店にいるときの処理
passed = set()
if store_hold == driver_hold == 0: #運ぶべき荷物がなければ待機
command[t] = -1
continue
else:
order |= stuck_order
for key in order:
cost[key] += stuck_cost[key]
driver_hold += stuck_cost[key]
stuck_cost[key] = 0
stuck_order = set()
store_hold = 0
if heading in order and heading > 0: #顧客のいる場所で荷物を積み下ろすとき
order -= {heading}
driver_hold -= cost[heading]
cost[heading] = 0
pre_id = current_id #前の地点の更新
current_id = heading #現在地の更新
passed |= {heading}
if len(order) > 0: #まだ配達すべき荷物があるとき
if current_id == final_dist: #目的地に到着したときは残りの荷物で先に運ぶべき荷物を選ぶ
final_dist = decide_final_dst(cost, order, current_id, store_hold, wf, daverage)
else: final_dist = 0 #荷物が無いので店に戻る
heading = next_id[current_id][final_dist]
decide_next_dst(cost, order, current_id, pre_id, heading, edge, wf, passed, V)
dist_left = edge[current_id][heading] - 1
command[t] = heading + 1
for i in range(T): print(command[i])
return 0
if __name__ == "__main__":
solve()
``` | instruction | 0 | 2,264 | 13 | 4,528 |
Yes | output | 1 | 2,264 | 13 | 4,529 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dijkstra(s):
d = [float("inf")]*n
pre = [None]*n
d[s] = 0
q = [(0,s)]
while q:
dx,x = heappop(q)
for y,w in v[x]:
nd = dx+w
if nd < d[y]:
d[y] = nd
pre[y] = x
heappush(q,(nd,y))
path = [[i] for i in range(n)]
for i in range(n):
while path[i][-1] != s:
path[i].append(pre[path[i][-1]])
path[i] = path[i][::-1][1:]
return d,path
n,m = LI()
v = [[] for i in range(n)]
for i in range(m):
a,b,d = LI()
a -= 1
b -= 1
v[a].append((b,d))
v[b].append((a,d))
d = [None]*n
path = [None]*n
for s in range(n):
d[s],path[s] = dijkstra(s)
t = I()
q = deque()
for i in range(t):
N = I()
if N == 0:
continue
a,y = LI()
y -= 1
q.append((i,y))
x = 0
dx = 0
dy = 0
query = deque()
dst = 0
go = []
f = 0
time = [None]*n
fl = [0]*n
for i in range(t):
while go and not fl[go[0]]:
go.pop(0)
while q and q[0][0] == i:
k,l = q.popleft()
query.append(l)
if time[l] == None:
time[l] = k
if not f:
if x == 0:
if not query:
print(-1)
else:
f = 1
while query:
dst = query.popleft()
go.append(dst)
fl[dst] = 1
go = list(set(go))
go.sort(key = lambda a:time[a])
time = [None]*n
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
print(y+1)
dx = 1
dy = d[x][y]
if dx == dy:
fl[y] = 0
x = y
dx = 0
if x == dst:
if go:
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
f = 0
dst = 0
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
y = p.pop(0)
dy = d[x][y]
else:
print(y+1)
dx += 1
if dx == dy:
fl[y] = 0
x = y
dx = 0
if p:
y = p.pop(0)
dy = d[x][y]
else:
print(y+1)
dx += 1
if dx == dy:
fl[y] = 0
x = y
dx = 0
if x == dst:
if go:
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
f = 0
dst = 0
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
y = p.pop(0)
dy = d[x][y]
return
#Solve
if __name__ == "__main__":
solve()
``` | instruction | 0 | 2,265 | 13 | 4,530 |
Yes | output | 1 | 2,265 | 13 | 4,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
import sys
import copy
# recieve |V| and |E|
V, E = map(int, input().split())
es = [[] for i in range(V)]
for i in range(E):
# recieve edges
#es[point][edgenumber]: 頂点pointにedgenumber本の辺がある
#値はつながっている頂点とその距離
a, b, c = map(int, input().split())
a, b = a-1, b-1
es[a].append((b,c))
es[b].append((a,c))
#頂点iから頂点j(0 <= i <= V-1, 0 <= j <= V-1)の最短時間をリストアップする
#shortest_time[i][j]: 頂点iから頂点jまでの最短時間が記録されている
shortest_time = [[sys.maxsize for j in range(V)] for i in range(V)]
#頂点iから頂点j(0 <= i <= V-1, 0 <= j <= V-1)の最短経路をリストアップする
#shortest_route[i][j]: 頂点iから頂点jまでの経路のリストが取得できる
shortest_route = [[[] for j in range(V)] for i in range(V)]
#最短時間と最短経路をリストアップする関数を作る
def make_shortest_time_and_route(current, point, t, ic):
#既に追加されている時間以上であればバックする
if shortest_time[current][point] < t:
return
#行き先が自分の頂点であるときの距離は0にする
if current == point:
shortest_time[current][point] = 0
for edge_tuple in es[point]:
if shortest_time[current][edge_tuple[0]] > t+edge_tuple[1]:
#既に追加されている時間よりも小さかったら代入する
shortest_time[current][edge_tuple[0]] = t+edge_tuple[1]
#途中経路を記録していく
ic.append(edge_tuple[0])
#最短時間でいける経路を記録していく
#新しく最短経路が見つかれば上書きされる
shortest_route[current][edge_tuple[0]] = copy.copy(ic)
#再帰呼び出し
make_shortest_time_and_route(current, edge_tuple[0], t+edge_tuple[1], ic)
#新しい経路のために古いものを削除しておく
del ic[-1]
for i in range(V):
interchange = []
make_shortest_time_and_route(i, i, 0, interchange)
T = int(input())
# recieve info
#受け取った情報をリストアップしていく
#oder_time: key: 注文id, value: 注文時間t
oder_time = {}
#oder_list[t][i]: 時間tに発生したi番目の注文情報
oder_list = [[] for i in range(T)]
for i in range(T):
Nnew = int(input())
for j in range(Nnew):
new_id, dst = map(int, input().split())
oder_time[new_id] = i
oder_list[i].append((new_id, dst-1))
#配達に向かう目的地をリストに入れる
def get_destination(d, l):
for i in range(V):
if l[i]:
d.append(i)
#時間s+1からtまでに注文された荷物を受け取る関数
def get_luggage(l, s, t):
for i in range(s+1, t+1):
for oder in oder_list[i]:
l[oder[1]].append(oder[0])
return t
#配達場所までの最短経路になるようにソートする関数
def get_route(start, start_index, d):
if start_index >= len(d)-1:
return
min = sys.maxsize
v = -1
for i in range(start_index, len(d)):
if min > shortest_time[start][d[i]]:
min = shortest_time[start][d[i]]
v = i
w = d[start_index]
d[start_index] = d[v]
d[v] = w
get_route(d[start_index], start_index+1, d)
LEVEL = 4 #読みきる深さ
#最適解を探索する
#t: 時間, level: 読んでいる深さ, vehicle: 車の位置, score: 得点, shipping: 最後にお店に立ち寄った時間, dst_list: 配達に向かう順番, luggage: 荷物
def search(t, level, vehicle, score, shipping, dst_list, luggage):
#t >= Tmax のときscoreを返す
if t >= T:
return score
#levelが読みきる深さになったとき
if level >= LEVEL:
return score
luggage_copy = copy.deepcopy(luggage)
dst_list_copy = copy.copy(dst_list)
#車がお店にいるとき
if vehicle == 0:
#時間tまでに受けた注文idを受け取る
shipping = get_luggage(luggage_copy, shipping, t)
#配達場所(複数の目的地)までの最短経路を計算する
#もしdst_listが空ではなかったら空にする
if dst_list_copy != None:
dst_list_copy.clear()
#配達に向かう場所を記憶する
get_destination(dst_list_copy, luggage_copy)
#dst_listが最短経路でソートされる
get_route(0, 0, dst_list_copy)
#comp = search(配達に行く場合)
max_score = sys.maxsize
if dst_list_copy:
max_score = search(t+shortest_time[vehicle][dst_list_copy[0]], level+1, dst_list_copy[0], score, shipping, dst_list_copy, luggage_copy)
#comp = search(店にとどまる場合)
comp = search(t+1, level+1, vehicle, score, shipping, dst_list_copy, luggage_copy)
#comp > max のとき now_score = comp
if comp > max_score:
max_score = comp
#return max
return max_score
#車が今積んでいるすべての荷物を配達完了したとき
elif dst_list_copy.index(vehicle) == len(dst_list_copy) - 1:
for i in luggage_copy[vehicle]:
#得点計算
waitingTime = t - oder_time[i]
score += T*T - waitingTime*waitingTime
luggage_copy[vehicle].clear()
#return search(店に戻る, 計算した得点を引数に渡す)
return search(t+shortest_time[vehicle][0], level+1, 0, score, shipping, dst_list_copy, luggage_copy)
#車が途中の配達まで完了したとき
else:
for i in luggage_copy[vehicle]:
#得点計算
waitingTime = t - oder_time[i]
score += T*T - waitingTime*waitingTime
luggage_copy[vehicle].clear()
#comp = search(次の配達場所に向かう, 計算した得点を引数に渡す)
max_score = search(t+shortest_time[vehicle][dst_list_copy[dst_list_copy.index(vehicle)+1]], level+1, dst_list_copy[dst_list_copy.index(vehicle)+1], score, shipping, dst_list_copy, luggage_copy)
#comp = search(店に戻る, 計算した得点を引数に渡す)
comp = search(t+shortest_time[vehicle][0], level+1, 0, score, shipping, dst_list_copy, luggage_copy)
#comp > max のとき max = comp
if comp > max_score:
max_score = comp
#return max
return max_score
#車に積んである荷物を記録していく
#key: 目的地, value: 注文idのリスト
real_l = {key: [] for key in range(V)}
#車の目的地を記録していく
real_d = []
#index
index = 0
#次の行動
next_move = -1
#次の目的地
next_dst = 0
#車の現在地
real_v = 0
#最後に店に訪れた時間
shipping_time = -1
#次の頂点につくまでのカウンター
count = 0
# insert your code here to get more meaningful output
# all stay
#with open('result.out', 'w') as f:
for i in range(T) :
#次の目的地と車の現在地が等しいとき
if real_v == next_dst:
count = 0
#車が店にいるとき
if real_v == 0:
index = 0
#荷物を受け取る関数
shipping_time = get_luggage(real_l, shipping_time, i)
#新しく目的地のリストを作る
if real_d != None:
real_d.clear()
get_destination(real_d, real_l)
#複数の目的地のルートを受け取る関数
get_route(0, 0, real_d)
#とどまる場合
max_score = search(i+1, 0, real_v, 0, shipping_time, real_d, real_l)
next_dst = 0
next_move = -2
#いく場合
comp = -1
if real_d:
comp = search(i+shortest_time[real_v][real_d[index]], 0, real_d[index], 0, shipping_time, real_d, real_l)
if comp > max_score:
next_dst = real_d[index]
next_move = shortest_route[real_v][next_dst][0]
index += 1
#車が今ある荷物をすべて配達したとき
elif index >= len(real_d) - 1:
real_d.clear()
real_l[real_v].clear()
next_dst = 0
next_move = shortest_route[real_v][next_dst][0]
#車が途中の配達場所まで配達完了したとき
else:
real_l[real_v].clear()
#店にもどる
max_score = search(i+shortest_time[real_v][0], 0, 0, 0, shipping_time, real_d, real_l)
next_dst = 0
next_move = shortest_route[real_v][next_dst][0]
#次の目的地に行く
comp = search(i+shortest_time[real_v][real_d[index]], 0, real_d[index], 0, shipping_time, real_d, real_l)
if comp > max_score:
next_dst = real_d[index]
next_move = shortest_route[real_v][next_dst][0]
index += 1
#次の行動を出力する
print(next_move+1)
#次の頂点まで移動中のとき
else:
if count >= shortest_time[real_v][next_move]-1:
if next_move == next_dst:
real_v = next_dst
count += 1
print(next_move+1)
continue
count = 0
real_v = next_move
next_move = shortest_route[real_v][next_dst][0]
count += 1
print(next_move+1)
``` | instruction | 0 | 2,266 | 13 | 4,532 |
No | output | 1 | 2,266 | 13 | 4,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
def warshall_floid(graph):
"""warshall-floid法: 各頂点から各頂点への最短距離を求める
重み付きグラフgraphは隣接リストで与えられる
計算量: O(|N|^3)
"""
n = len(graph)
INF = 10**18
dp = [[INF]*n for i in range(n)]
for i in range(n):
dp[i][i] = 0
for i in range(n):
for j, cost in graph[i]:
dp[i][j] = cost
dp[j][i] = cost
for k in range(n):
for i in range(n):
for j in range(n):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
return dp
def trace_route(start, goal):
"""warshall-floid法で求めた最短距離を通るための経路を復元する
計算量: O(|N|^2)
"""
pos = start
ans = []
while pos != goal:
ans.append(pos)
for next_pos, _ in graph[pos]:
if dp[pos][next_pos] + dp[next_pos][goal] == dp[pos][goal]:
pos = next_pos
break
ans.append(goal)
return ans
# 値を入力する
n, m = map(int, input().split())
info = [list(map(int, input().split())) for i in range(m)]
t_max = int(input())
query = [None] * t_max
for i in range(t_max):
tmp = int(input())
query[i] = [list(map(int, input().split())) for i in range(tmp)]
# グラフを構築
graph = [[] for i in range(n)]
for a, b, cost in info:
a -= 1
b -= 1
graph[a].append((b, cost))
graph[b].append((a, cost))
# 最短距離を求める
dp = warshall_floid(graph)
visited = [False] * n
visited[0] = True
route = [0]
pos = 0
total_cost = 0
while True:
kyori = 10**9
next_pos = -1
for next_p, cost in enumerate(dp[pos]):
if visited[next_p]:
continue
if cost < kyori:
kyori = cost
next_pos = next_p
if next_pos == -1:
break
else:
visited[next_pos] = True
route.append(next_pos)
pos = next_pos
total_cost += kyori
route.append(0)
# ans: スタートから全部の頂点を通ってスタートに帰るときのコマンド
ans = []
for i in range(n):
pos = route[i]
next_pos = route[i+1]
tmp = trace_route(pos, next_pos)
for j in range(len(tmp)-1):
for _ in range(dp[tmp[j]][tmp[j+1]]):
ans.append(tmp[j+1] + 1)
#path_w = './output.txt'
#f = open(path_w, mode='w')
cnt = 0
while True:
for i in ans:
cnt += 1
print(i)
#f.write(str(i) + "\n")
if cnt == t_max:
exit()
``` | instruction | 0 | 2,267 | 13 | 4,534 |
No | output | 1 | 2,267 | 13 | 4,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5
Submitted Solution:
```
from collections import defaultdict
import random
from logging import getLogger, StreamHandler, DEBUG, ERROR
from functools import lru_cache
logger = getLogger(__name__)
handler = StreamHandler()
handler.setLevel(DEBUG)
logger.setLevel(ERROR)
logger.addHandler(handler)
logger.propagate = False
logger.debug("HEADER")
class Maps(object):
def __init__(self):
self.readinputs()
# recieve |V| and |E|
def readinputs(self):
self.V, self.E = map(int, input().split())
self.es = [[] for i in range(self.V)]
self.Mes = [[0]*self.V for i in range(self.V)]
self.graph = Graph()
self.car = Car()
self.here = ('v', 0)
self.plan = []
for _ in range(self.E):
# recieve edges
a, b, c = map(int, input().split())
a, b = a-1, b-1
self.es[a].append((b,c))
self.es[b].append((a,c))
self.Mes[a][b] = c
self.Mes[b][a] = c
self.graph.add_edge(a,b,c)
self.T = int(input())
# recieve info
self.info = [[] for i in range(self.T)]
for t in range(self.T):
Nnew = int(input())
for _ in range(Nnew):
new_id, dst = map(int, input().split())
dst = dst-1
self.info[t].append((new_id, dst))
logger.debug("Set status")
logger.debug("Info :")
logger.debug(self.info)
def get_plan(self):
return self.plan
def has_plan(self):
if self.plan == []:
return False
else:
return True
def get_here(self):
return self.here
def set_here(self, here):
self.here = here
def next_place(self, here, command):
if command == -1:
return here
else:
to = command
if here[0] == 'v':
dist = self.Mes[here[1]][to]
if dist == 0:
raise ValueError('Dist has not 0')
elif dist == 1:
return ('v', to)
else:
return ('e', here[1], to, 1) # You can move 1m per time
elif here[0] == 'e':
if here[2] == to:
if here[3] + 1 < self.Mes[here[1]][here[2]]:
return ('e', here[1], here[2], here[3] + 1)
elif here[3] + 1 == self.Mes[here[1]][here[2]]:
return ('v', here[2])
else:
raise ValueError('Distance error!')
elif here[1] == to:
if here[3] - 1 > 0:
return ('e', here[1], here[2], here[3] - 1)
elif here[3] - 1 == 0:
return ('v', here[1])
else:
raise ValueError('Distance error!')
else:
raise ValueError('Here has vertex or edge status')
def get_command(self, here, plan):
if here[0] == 'v':
# you are in vertex
if plan == []:
# stay at 0
return -1
elif here[1] == plan[-1]:
# arrive goal
return -1
else:
return plan[plan.index(here[1]) + 1]
elif here[0] == 'e':
# you are in edge
return here[2]
else:
raise ValueError('Here has vertex or edge status')
def move(self):
where = [('v', 0)] # ('v', here) or ('e', from, to, dist)
self.path = [0]*self.T
last_stay_0 = 0
for t in range(self.T):
now_where = where[-1]
logger.debug("----------Time----------")
logger.debug(t)
logger.debug("Here is :")
logger.debug(now_where)
logger.debug("parcel :")
logger.debug(self.info[t])
if now_where[0] == 'v':
# 荷物を拾ったりおろしたり
if now_where[1] == 0:
logger.debug("Car Parameter :")
logger.debug("Last stay at 0 :")
logger.debug(last_stay_0)
logger.debug("Picking up parcel is :")
for parcel in self.info[last_stay_0: t + 1]:
logger.debug(parcel)
self.car.pickup(parcel)
last_stay_0 = t + 1
else:
self.car.unload(now_where[1])
logger.debug("Car Box :")
logger.debug(self.car.box)
if self.car.box == []:
logger.debug("Car Box is vacant")
if now_where[0] == 'v' and now_where[1] == 0:
self.path[t] = -1
where.append(('v', 0))
logger.debug("Time " + str(t) + " command is :")
logger.debug(self.path[t])
logger.debug("No parcel and stay at 1. Continue")
continue
if not self.has_plan():
logger.debug("--Set plan--")
logger.debug("-Now-")
logger.debug(now_where)
logger.debug("-Dests-")
logger.debug(self.car.show_dest())
if now_where[1] != 0:
goal = 0
else:
goal = self.select_goal(now_where[1], self.car.show_dest())
logger.debug("Set Goal is :")
logger.debug(goal)
self.plan = wrap_dijsktra(self.graph, now_where[1], goal)
logger.debug("Time " + str(t) + " plan is :")
logger.debug(self.plan)
if self.plan == []:
logger.debug("Time " + str(t) + " has no plan")
self.path[t] = -1
continue
command = self.get_command(now_where, self.plan)
self.path[t] = command
logger.debug("Time " + str(t) + " command is :")
logger.debug(command)
where.append(self.next_place(now_where, command))
logger.debug("Time " + str(t) + " next place is :")
logger.debug(where[-1])
if where[-1][0] == 'v' and where[-1][1] == self.plan[-1]:
logger.debug("Time " + str(t) + " we arrive at goal !")
self.plan = []
def select_goal(self, here, dests):
# logger.debug('--select goal--')
# logger.debug('Here is : ')
# logger.debug(here)
dist = dict()
for dest in dests:
# logger.debug("Dest is : ")
# logger.debug(dest)
path = wrap_dijsktra(self.graph, here, dest)
# logger.debug("path is : ")
# logger.debug(path)
dist[dest] = self.dist_path(path)
nearby = min(dist, key=dist.get)
return nearby
def dist_path(self, path):
distance = 0
for n in range(len(path)-1):
distance += self.Mes[path[n]][path[n+1]]
return distance
def output(self):
for t in range(self.T) :
print(self.path[t] + 1)
class Graph():
def __init__(self):
"""
self.edges is a dict of all possible next nodes
e.g. {'X': ['A', 'B', 'C', 'E'], ...}
self.weights has all the weights between two nodes,
with the two nodes as a tuple as the key
e.g. {('X', 'A'): 7, ('X', 'B'): 2, ...}
"""
self.edges = defaultdict(list)
self.weights = {}
def add_edge(self, from_node, to_node, weight):
# Note: assumes edges are bi-directional
self.edges[from_node].append(to_node)
self.edges[to_node].append(from_node)
self.weights[(from_node, to_node)] = weight
self.weights[(to_node, from_node)] = weight
class Car(object):
def __init__(self):
self.box = []
# self.dest = set()
def pickup(self, parcel):
# parcel [] or [(new_id, dst)]
if parcel == []:
pass
else:
self.box.append(parcel[0])
# self.dest.add(parcel[0])
def unload(self, vertex):
self.box = [x for x in self.box if x[1] != vertex]
# self.dest = {x for x in self.box if x[1] != vertex}
def show_dest(self):
dest = set()
for x in self.box:
# show dst only.
dest.add(x[1])
if len(dest) == 0:
dest.add(0)
return list(dest)
def wrap_dijsktra(graph, initial, end):
if initial == end:
return []
elif initial < end:
return dijsktra(graph, initial, end)
else:
return dijsktra(graph, end, initial)[::-1]
@lru_cache(maxsize=80000)
def dijsktra(graph, initial, end):
# shortest paths is a dict of nodes
# whose value is a tuple of (previous node, weight)
shortest_paths = {initial: (None, 0)}
current_node = initial
visited = set()
while current_node != end:
visited.add(current_node)
destinations = graph.edges[current_node]
weight_to_current_node = shortest_paths[current_node][1]
for next_node in destinations:
weight = graph.weights[(current_node, next_node)] + weight_to_current_node
if next_node not in shortest_paths:
shortest_paths[next_node] = (current_node, weight)
else:
current_shortest_weight = shortest_paths[next_node][1]
if current_shortest_weight > weight:
shortest_paths[next_node] = (current_node, weight)
next_destinations = {node: shortest_paths[node] for node in shortest_paths if node not in visited}
if not next_destinations:
return "Route Not Possible"
# next node is the destination with the lowest weight
current_node = min(next_destinations, key=lambda k: next_destinations[k][1])
# Work back through destinations in shortest path
path = []
while current_node is not None:
path.append(current_node)
next_node = shortest_paths[current_node][0]
current_node = next_node
# Reverse path
path = path[::-1]
return path
if __name__ == "__main__":
def main():
M = Maps()
M.move()
M.output()
main()
``` | instruction | 0 | 2,268 | 13 | 4,536 |
No | output | 1 | 2,268 | 13 | 4,537 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.