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 connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST. | instruction | 0 | 11,022 | 13 | 22,044 |
Tags: dfs and similar, dsu, graphs, sortings
Correct Solution:
```
from sys import stdin
from math import inf
from collections import defaultdict
class disjoinSet(object):
def __init__(self,n):
self.father = [x for x in range(0,n+1)]
self.rank = [0 for x in range(0,n+1)]
def setOf(self, x):
if(self.father[x] != x):
self.father[x] = self.setOf(self.father[x])
return self.father[x]
def Merge(self,x,y):
xR = self.setOf(x)
yR = self.setOf(y)
if(xR == yR):
return
if self.rank[xR] < self.rank[yR]:
self.father[xR] = yR
elif self.rank[xR] > self.rank[yR]:
self.father[yR] = xR
else:
self.father[yR] = xR
self.rank[xR] +=1
##########
def mergesort(x):
if len(x) < 2:
return x
middle = int(len(x)/2)
left = mergesort(x[:middle])
right = mergesort(x[middle:])
return merge(left,right)
def merge(left,right):
result = []
l,r=0,0
while l < len(left) and r < len(right):
if left[l][2] <= right[r][2]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r+=1
result += left[l:]
result += right[r:]
return result
##########
def DFS(graph,bridges):
time = 0
for key in graph:
low[key] = inf
d[key] = -1
pi[key] = key
visited[key] = False
for i in graph:
if not visited[i]:
DFS_Visit(graph,i,bridges)
def DFS_Visit(graph,u,bridges):
visited[u] = True
global time
time +=1
d[u] = time
low[u] = d[u]
for v in graph[u]:
if not visited[v]:
pi[v] = u
DFS_Visit(graph,v,bridges)
low[u] = min(low[u],low[v])
elif pi[u] != v:
low[u] = min(low[u],d[v])
if pi[u] != u and low[u] == d[u]:
x = min(pi[u],u)
y = max(pi[u],u)
bridges.append([x,y])
time +=1
##########
n, m = map(int, stdin.readline().split())
if m != n-1:
visited = {}
d = {}
low = {}
pi = {}
time = 0
edges = []
for i in range(0,m):
x,y,z = map(int, stdin.readline().split())
edges.append([])
edges[i] = [x,y,z]
ans = {}
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
ans[x,y] = "at least one"
dsu = disjoinSet(n)
sortEdges = mergesort(edges)
criticalEdges = []
i = 0
cantEdges = m
while i < cantEdges:
j = i;
a = 0
b = 0
criticalEdges = []
while j < len(sortEdges) and sortEdges[j][2] == sortEdges[i][2]:
x = dsu.setOf(sortEdges[j][0])
y = dsu.setOf(sortEdges[j][1])
a = min(sortEdges[j][0],sortEdges[j][1])
b = max(sortEdges[j][0],sortEdges[j][1])
if x == y:
ans[a,b] = "none"
criticalEdges.append(sortEdges[j])
j+=1
if len(criticalEdges) == 1:
if ans[a,b] != "none":
ans[a,b] = "any"
dsu.Merge(a,b)
else:
graph = defaultdict(set)
crossCut = defaultdict(list)
for m in criticalEdges:
x = min(dsu.setOf(m[0]),dsu.setOf(m[1]))
y = max(dsu.setOf(m[0]),dsu.setOf(m[1]))
if x != y:
graph[x].add(y)
graph[y].add(x)
crossCut[x,y].append([min(m[0],m[1]),max(m[0],m[1])])
bridges = []
DFS(graph,bridges)
for k in bridges:
if len(crossCut[k[0],k[1]]) == 1:
x,y = crossCut[k[0],k[1]][0]
ans[x,y] = "any"
for m in criticalEdges:
dsu.Merge(m[0],m[1])
i = j
for s in edges:
x = min(s[0],s[1])
y = max(s[0],s[1])
print(ans[x,y])
else:
for _ in range(0,m):
print("any")
``` | output | 1 | 11,022 | 13 | 22,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST. | instruction | 0 | 11,023 | 13 | 22,046 |
Tags: dfs and similar, dsu, graphs, sortings
Correct Solution:
```
from sys import stdin
from math import inf
from collections import defaultdict
class disjoinSet(object):
def __init__(self,n):
self.father = [x for x in range(0,n+1)]
self.rank = [0 for x in range(0,n+1)]
def setOf(self, x):
if(self.father[x] != x):
self.father[x] = self.setOf(self.father[x])
return self.father[x]
def Merge(self,x,y):
xR = self.setOf(x)
yR = self.setOf(y)
if(xR == yR):
return
if self.rank[xR] < self.rank[yR]:
self.father[xR] = yR
elif self.rank[xR] > self.rank[yR]:
self.father[yR] = xR
else:
self.father[yR] = xR
self.rank[xR] +=1
##########
def mergesort(x):
if len(x) < 2:
return x
middle = int(len(x)/2)
left = mergesort(x[:middle])
right = mergesort(x[middle:])
return merge(left,right)
def merge(left,right):
result = []
l,r=0,0
while l < len(left) and r < len(right):
if left[l][2] <= right[r][2]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r+=1
result += left[l:]
result += right[r:]
return result
##########
def DFS(graph,bridges):
time = 0
for key in graph:
low[key] = inf
d[key] = -1
pi[key] = key
visited[key] = False
for i in graph:
if not visited[i]:
DFS_Visit(graph,i,bridges)
def DFS_Visit(graph,u,bridges):
visited[u] = True
global time
time +=1
d[u] = time
low[u] = d[u]
for v in graph[u]:
if not visited[v]:
pi[v] = u
DFS_Visit(graph,v,bridges)
low[u] = min(low[u],low[v])
elif pi[u] != v:
low[u] = min(low[u],d[v])
if pi[u] != u and low[u] >= d[u]:
x = min(pi[u],u)
y = max(pi[u],u)
bridges.append([x,y])
time +=1
##########
n, m = map(int, stdin.readline().split())
if m > n-1:
visited = {}
d = {}
low = {}
pi = {}
time = 0
edges = []
for i in range(0,m):
x,y,z = map(int, stdin.readline().split())
edges.append([])
edges[i] = [x,y,z]
ans = {}
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
ans[x,y] = "at least one"
dsu = disjoinSet(n)
sortEdges = mergesort(edges)
criticalEdges = []
i = 0
cantEdges = m
while i < cantEdges:
j = i;
a = 0
b = 0
criticalEdges = []
while j < len(sortEdges) and sortEdges[j][2] == sortEdges[i][2]:
x = dsu.setOf(sortEdges[j][0])
y = dsu.setOf(sortEdges[j][1])
a = min(sortEdges[j][0],sortEdges[j][1])
b = max(sortEdges[j][0],sortEdges[j][1])
if x == y:
ans[a,b] = "none"
criticalEdges.append(sortEdges[j])
j+=1
if len(criticalEdges) == 1:
if ans[a,b] != "none":
ans[a,b] = "any"
dsu.Merge(a,b)
else:
graph = defaultdict(set)
crossCut = defaultdict(list)
for m in criticalEdges:
x = min(dsu.setOf(m[0]),dsu.setOf(m[1]))
y = max(dsu.setOf(m[0]),dsu.setOf(m[1]))
if x != y:
graph[x].add(y)
graph[y].add(x)
crossCut[x,y].append([min(m[0],m[1]),max(m[0],m[1])])
bridges = []
DFS(graph,bridges)
for k in bridges:
if len(crossCut[k[0],k[1]]) == 1:
x,y = crossCut[k[0],k[1]][0]
ans[x,y] = "any"
for m in criticalEdges:
if dsu.setOf(m[0]) != dsu.setOf(m[1]):
dsu.Merge(m[0],m[1])
i = j
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
print(ans[x,y])
else:
for _ in range(0,m):
print("any")
``` | output | 1 | 11,023 | 13 | 22,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST. | instruction | 0 | 11,024 | 13 | 22,048 |
Tags: dfs and similar, dsu, graphs, sortings
Correct Solution:
```
from sys import stdin
from math import inf
from collections import defaultdict
class disjoinSet(object):
def __init__(self,n):
self.father = [x for x in range(0,n+1)]
self.rank = [0 for x in range(0,n+1)]
def setOf(self, x):
if(self.father[x] != x):
self.father[x] = self.setOf(self.father[x])
return self.father[x]
def Merge(self,x,y):
xR = self.setOf(x)
yR = self.setOf(y)
if(xR == yR):
return
if self.rank[xR] < self.rank[yR]:
self.father[xR] = yR
elif self.rank[xR] > self.rank[yR]:
self.father[yR] = xR
else:
self.father[yR] = xR
self.rank[xR] +=1
##########
def mergesort(x):
if len(x) < 2:
return x
middle = int(len(x)/2)
left = mergesort(x[:middle])
right = mergesort(x[middle:])
return merge(left,right)
def merge(left,right):
result = []
l,r=0,0
while l < len(left) and r < len(right):
if left[l][2] <= right[r][2]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r+=1
result += left[l:]
result += right[r:]
return result
##########
def DFS(graph,bridges):
time = 0
for key in graph:
low[key] = inf
d[key] = -1
pi[key] = key
visited[key] = False
for i in graph:
if not visited[i]:
DFS_Visit(graph,i,bridges)
def DFS_Visit(graph,u,bridges):
visited[u] = True
global time
time +=1
d[u] = time
low[u] = d[u]
for v in graph[u]:
if not visited[v]:
pi[v] = u
DFS_Visit(graph,v,bridges)
low[u] = min(low[u],low[v])
elif pi[u] != v:
low[u] = min(low[u],d[v])
if pi[u] != u and low[u] == d[u]:
x = min(pi[u],u)
y = max(pi[u],u)
bridges.append([x,y])
time +=1
##########
n, m = map(int, stdin.readline().split())
if m > n-1:
visited = {}
d = {}
low = {}
pi = {}
time = 0
edges = []
for i in range(0,m):
x,y,z = map(int, stdin.readline().split())
edges.append([])
edges[i] = [x,y,z]
ans = {}
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
ans[x,y] = "at least one"
dsu = disjoinSet(n)
sortEdges = mergesort(edges)
criticalEdges = []
i = 0
cantEdges = m
while i < cantEdges:
j = i;
a = 0
b = 0
criticalEdges = []
while j < len(sortEdges) and sortEdges[j][2] == sortEdges[i][2]:
x = dsu.setOf(sortEdges[j][0])
y = dsu.setOf(sortEdges[j][1])
a = min(sortEdges[j][0],sortEdges[j][1])
b = max(sortEdges[j][0],sortEdges[j][1])
if x == y:
ans[a,b] = "none"
criticalEdges.append(sortEdges[j])
j+=1
if len(criticalEdges) == 1:
if ans[a,b] != "none":
ans[a,b] = "any"
dsu.Merge(a,b)
else:
graph = defaultdict(set)
crossCut = defaultdict(list)
for m in criticalEdges:
x = min(dsu.setOf(m[0]),dsu.setOf(m[1]))
y = max(dsu.setOf(m[0]),dsu.setOf(m[1]))
if x != y:
graph[x].add(y)
graph[y].add(x)
crossCut[x,y].append([min(m[0],m[1]),max(m[0],m[1])])
bridges = []
DFS(graph,bridges)
for k in bridges:
if len(crossCut[k[0],k[1]]) == 1:
x,y = crossCut[k[0],k[1]][0]
ans[x,y] = "any"
for m in criticalEdges:
dsu.Merge(m[0],m[1])
i = j
for s in edges:
x = min(s[0],s[1])
y = max(s[0],s[1])
print(ans[x,y])
else:
for _ in range(0,m):
print("any")
``` | output | 1 | 11,024 | 13 | 22,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST. | instruction | 0 | 11,025 | 13 | 22,050 |
Tags: dfs and similar, dsu, graphs, sortings
Correct Solution:
```
import sys
from math import inf
from collections import defaultdict
class disjoinSet(object):
def __init__(self,n):
self.father = [x for x in range(0,n+1)]
self.rank = [0 for x in range(0,n+1)]
def setOf(self, x):
if(self.father[x] != x):
self.father[x] = self.setOf(self.father[x])
return self.father[x]
def Merge(self,x,y):
xR = self.setOf(x)
yR = self.setOf(y)
if(xR == yR):
return
if self.rank[xR] < self.rank[yR]:
self.father[xR] = yR
elif self.rank[xR] > self.rank[yR]:
self.father[yR] = xR
else:
self.father[yR] = xR
self.rank[xR] +=1
def merge(left,right):
result = []
l,r=0,0
while l < len(left) and r < len(right):
if left[l][2] <= right[r][2]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r+=1
result += left[l:]
result += right[r:]
return result
def mergesort(x):
if len(x) < 2:
return x
middle = int(len(x)/2)
left = mergesort(x[:middle])
right = mergesort(x[middle:])
return merge(left,right)
def DFS(graph,bridges):
time = 0
for key in graph:
low[key] = inf
d[key] = -1
pi[key] = key
visited[key] = False
for i in graph:
if not visited[i]:
DFS_Visit(graph,i,bridges)
def DFS_Visit(graph,u,bridges):
visited[u] = True
global time
time +=1
d[u] = time
low[u] = d[u]
for v in graph[u]:
if not visited[v]:
pi[v] = u
DFS_Visit(graph,v,bridges)
low[u] = min(low[u],low[v])
elif pi[u] != v:
low[u] = min(low[u],d[v])
if pi[u] != u and low[u] >= d[u]:
x = min(pi[u],u)
y = max(pi[u],u)
bridges.append([x,y])
time +=1
time = 0
n, m = map(int, sys.stdin.readline().split())
if m <= n-1:
for _ in range(0,m):
print("any")
exit()
visited = {}
d = {}
low = {}
pi = {}
edges = []
for i in range(0,m):
x,y,z = map(int, sys.stdin.readline().split())
edges.append([])
edges[i] = [x,y,z]
dsu = disjoinSet(n)
ans = {}
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
ans[x,y] = "at least one"
sortEdges = mergesort(edges)
criticalEdges = []
i = 0
cantEdges = m
while i < cantEdges:
j = i;
a = 0
b = 0
criticalEdges = []
while j < len(sortEdges) and sortEdges[j][2] == sortEdges[i][2]:
x = dsu.setOf(sortEdges[j][0])
y = dsu.setOf(sortEdges[j][1])
a = min(sortEdges[j][0],sortEdges[j][1])
b = max(sortEdges[j][0],sortEdges[j][1])
if x == y:
ans[a,b] = "none"
criticalEdges.append(sortEdges[j])
j+=1
if len(criticalEdges) == 1:
if ans[a,b] != "none":
ans[a,b] = "any"
dsu.Merge(a,b)
else:
graph = defaultdict(set)
crossCut = defaultdict(list)
for m in criticalEdges:
x = min(dsu.setOf(m[0]),dsu.setOf(m[1]))
y = max(dsu.setOf(m[0]),dsu.setOf(m[1]))
if x != y:
graph[x].add(y)
graph[y].add(x)
crossCut[x,y].append([min(m[0],m[1]),max(m[0],m[1])])
bridges = []
DFS(graph,bridges)
for k in bridges:
if len(crossCut[k[0],k[1]]) == 1:
ans[crossCut[k[0],k[1]][0][0],crossCut[k[0],k[1]][0][1]] = "any"
for m in criticalEdges:
if dsu.setOf(m[0]) != dsu.setOf(m[1]):
dsu.Merge(m[0],m[1])
i = j
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
print(ans[x,y])
``` | output | 1 | 11,025 | 13 | 22,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST. | instruction | 0 | 11,026 | 13 | 22,052 |
Tags: dfs and similar, dsu, graphs, sortings
Correct Solution:
```
from math import inf
import operator
from collections import defaultdict
import sys
time = 0
edges = []
ans = {}
orig_edges = []
l = {}
d = {}
f = {}
pi = {}
visited = {}
def process_edges(l, ds):
if len(l) == 1:
u,v = l[0]
b = ds.SetOf(u) == ds.SetOf(v)
ans[u,v] = "none" if b else "any"
if not b:
ds.Merge(u, v)
else:
dic = defaultdict(list)
g = defaultdict(set)
for e in l:
u,v = e
x = ds.SetOf(u)
y = ds.SetOf(v)
if x == y:
ans[e] = "none"
else:
x,y = tuple(sorted([x,y]))
dic[x,y].append(e)
g[x].add(y)
g[y].add(x)
a = DFS(g)
for e in a:
if len(dic[e]) == 1:
ans[dic[e][0]] = "any"
for e in l:
if ds.SetOf(e[1]) != ds.SetOf(e[0]):
ds.Merge(e[0],e[1])
def sol(n):
ds = DisjointSet(n)
global edges
prev_w = edges[0][1]
same_weight = []
for e, w in edges + [(1,None)]:
if w == prev_w:
same_weight.append(e)
else:
process_edges(same_weight, ds)
same_weight = [e]
prev_w = w
def DFS(graph):
time = 0
global l
global d
global f
global pi
global visited
visited = {key : False for key in graph}
l = {key : inf for key in graph}
d = {key : -1 for key in graph}
f = {key : -1 for key in graph}
pi = {key : key for key in graph}
a = []
for i in graph.keys():
if not visited[i]:
DFS_Visit(graph, i, a)
return a
def DFS_Visit(graph, v, a):
visited[v] = True
global time
time+=1
d[v] = l[v] = time
for i in graph[v]:
if not visited[i]:
pi[i] = v
DFS_Visit(graph, i, a)
l[v] = min(l[v], l[i])
elif pi[v] != i:
l[v] = min(l[v], d[i])
if pi[v] != v and l[v] >= d[v]:
a.append(tuple(sorted([v,pi[v]])))
time+=1
f[v] = time
# def DFS_Visit(graph, v, a):
# visited[v] = True
# global time
# time+=1
# d[v] = l[v] = time
# stack = [v]
# while stack:
# u = stack.pop()
# for i in graph[u]:
# if not visited[i]:
# pi[i] = v
# stack.append(i)
# # DFS_Visit(graph, i, a)
# l[u] = min(l[u], l[i])
# elif pi[u] != i:
# l[u] = min(l[u], d[i])
# if pi[u] != v and l[v] >= d[v]:
# a.append(tuple(sorted([v,pi[v]])))
# time+=1
# f[v] = time
def read():
global edges
n,m = map(int, sys.stdin.readline().split())
if m == n-1:
for _ in range(m):
print("any")
exit()
for i in range(m):
x,y,w = map(int, sys.stdin.readline().split())
x,y = x-1,y-1
e = tuple(sorted([x,y]))
ans[e] = "at least one"
orig_edges.append((e,w))
edges = sorted(orig_edges, key=lambda x:x[1])
return n
def main():
n = read()
sol(n)
for i in orig_edges:
print(ans[i[0]])
class DisjointSet:
def __init__(self, n):
self.count = [1 for i in range(n)]
self.father = [i for i in range(n)]
def SetOf(self, x):
if x == self.father[x]:
return x
return self.SetOf(self.father[x])
def Merge(self, x, y):
a = self.SetOf(x)
b = self.SetOf(y)
if self.count[a] > self.count[b]:
temp = a
a = b
b = temp
self.count[b] += self.count[a]
self.father[a] = b
main()
``` | output | 1 | 11,026 | 13 | 22,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST.
Submitted Solution:
```
import sys, threading
from heapq import heappop, heappush
#from mygraph import MyGraph
from collections import defaultdict
n_nodes, n_edges = map(int, input().split())
edges = list()
results = defaultdict(lambda: 'any')
highest = defaultdict(lambda: -1)
to_check = defaultdict(list)
graph = defaultdict(list)
class UDFS:
def __init__(self, n):
self.n = n
# index is the node
self.parents = [i for i in range(n)]
self.ranks = [0 for i in range(n)]
def __str__(self):
'''
Group -> Node
'''
return '\n'.join(f'{e} -> {i}' for i, e in enumerate(self.parents))
def get_group(self, a):
if a == self.parents[a]:
return a
# Side effect for balancing the tree
self.parents[a] = self.get_group(self.parents[a])
return self.parents[a]
def is_parent(self, n):
return n == self.get_group(n)
def is_same_group(self, a, b):
return self.get_group(a) == self.get_group(b)
def join(self, a, b):
parent_a = self.get_group(a)
parent_b = self.get_group(b)
if self.ranks[parent_a] > self.ranks[parent_b]:
self.parents[parent_b] = parent_a
else:
self.parents[parent_a] = parent_b
self.ranks[parent_b] += int(
self.ranks[parent_a] == self.ranks[parent_b]
)
def count(self):
'''
Returns number of groups
'''
count = 0
for n in range(self.n):
count += self.is_parent(n)
return count
#def get_graph(nodes, label):
# graph = MyGraph(graph_type='graph', size='20,11.25!', ratio='fill',label=label, fontsize=40)
#
# for v in range(1,nodes+1):
# graph.add_nodes(v)
#
# return graph
#
#def make_original_graph(nodes, edges):
# original_graph = get_graph(nodes, "Grafo Original")
#
# for r in range(edges):
# a, b, w = map(int, input('\tInsira dois nós e o peso da aresta que existe entre eles: ').split())
# original_graph.link(a, b, str(w))
#
# img_name = "original_graph"
#
# original_graph.save_img(img_name)
#
# print(f"O grafo original foi salvo em {img_name}.png!")
#
#def make_edges_in_mst_graph(nodes, edges):
# edges_graph = get_graph(nodes, "Arestas em MSTs")
#
# for r in range(edges):
# edges_graph.link(a, b, str(w))
#
# img_name = "edges_in_mst"
#
# edges_graph.save_img(img_name)
#
# print(f"O grafo com a ocorrências das arestas em MSTs foi salvo em {img_name}.png!")
def dfs(a, depth, p):
global edges
global results
global highest
global graph
if highest[a] != -1:
return highest[a];
minimum = depth
highest[a] = depth
for (w, a, b, i) in graph[a]:
##print('@', w, a, b, i, depth)
if i == p:
continue
nextt = dfs(b, depth + 1, i)
if nextt <= depth:
results[i] = 'at least one'
else:
results[i] = 'any'
minimum = min(minimum, nextt)
highest[a] = minimum
return highest[a]
def main():
global edges
global results
global highest
global graph
for i in range(n_edges):
a, b, w = map(int, input().split())
edges.append((w, a-1, b-1, i))
edges = sorted(edges, key=lambda x: x[0])
dsu = UDFS(n_nodes)
i = 0
while i < n_edges:
counter = 0
j = i
while j < n_edges and edges[j][0] == edges[i][0]:
if dsu.get_group(edges[j][1]) == dsu.get_group(edges[j][2]):
results[edges[j][3]] = 'none'
else:
to_check[counter] = edges[j]
counter += 1
j += 1
for k in range(counter):
w, a, b, i = to_check[k]
ra = dsu.get_group(a)
rb = dsu.get_group(b)
graph[ra].append((w, ra, rb, i))
graph[rb].append((w, rb, ra, i))
for k in range(counter):
#print('To check:', to_check[k][:-1], k)
dfs(to_check[k][1], 0, -1)
for k in range(counter):
w, a, b, i = to_check[k]
ra = dsu.get_group(a)
rb = dsu.get_group(b)
dsu.join(ra, rb)
graph[ra] = list()
graph[rb] = list()
highest[ra] = -1
highest[rb] = -1
counter = 0
i = j
for i in range(n_edges):
print(results[i])
if __name__ == "__main__":
sys.setrecursionlimit(2**32//2-1)
threading.stack_size(10240000)
thread = threading.Thread(target=main)
thread.start()
``` | instruction | 0 | 11,027 | 13 | 22,054 |
No | output | 1 | 11,027 | 13 | 22,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST.
Submitted Solution:
```
from math import inf
import operator
from collections import defaultdict
time = 0
edges = []
ans = {}
orig_edges = []
def process_edges(l, ds):
if len(l) == 1:
u,v = l[0]
b = ds.SetOf(u) == ds.SetOf(v)
ans[u,v] = "none" if b else "any"
if not b:
ds.Merge(u, v)
else:
dic = defaultdict(list)
g = defaultdict(set)
for e in l:
u,v = e
x = ds.SetOf(u)
y = ds.SetOf(v)
if x == y:
ans[e] = "none"
else:
x,y = tuple(sorted([x,y]))
dic[x,y].append(e)
g[x].add(y)
g[y].add(x)
a = DFS(g)
for e in a:
if len(dic[e]) == 1:
ans[e] = "any"
for e in l:
if ds.SetOf(e[1]) != ds.SetOf(e[0]):
ds.Merge(e[0],e[1])
def sol(n):
ds = DisjointSet(n)
global edges
prev_w = edges[0][1]
same_weight = []
for e, w in edges + [(1,None)]:
if w == prev_w:
same_weight.append(e)
else:
process_edges(same_weight, ds)
same_weight = [e]
prev_w = w
def DFS(graph):
time = 0
visited = {key : False for key in graph}
l = {key : inf for key in graph}
d = {key : -1 for key in graph}
f = {key : -1 for key in graph}
pi = {key : key for key in graph}
a = []
for i in graph.keys():
if not visited[i]:
DFS_Visit(graph, i, visited, d, f, l, pi, a)
return a
def DFS_Visit(graph, v, visited, d, f, l, pi, a):
visited[v] = True
global time
time+=1
d[v] = l[v] = time
for i in graph[v]:
if not visited[i]:
pi[i] = v
DFS_Visit(graph, i, visited, d, f, l, pi, a)
l[v] = min(l[v], l[i])
elif pi[v] != i:
l[v] = min(l[v], d[i])
if pi[v] != v and l[v] >= d[v]:
a.append(tuple(sorted([v,pi[v]])))
time+=1
f[v] = time
def read():
global edges
n,m = map(int, input().split())
for i in range(m):
x,y,w = map(int, input().split())
x,y = x-1,y-1
ans[(x,y)] = "at least one"
orig_edges.append(((x,y),w))
edges = sorted(orig_edges, key=lambda x:x[1])
return n
def main():
n = read()
sol(n)
for i in orig_edges:
print(ans[i[0]])
class DisjointSet:
def __init__(self, n):
self.count = [1 for i in range(n)]
self.father = [i for i in range(n)]
def SetOf(self, x):
if x == self.father[x]:
return x
return self.SetOf(self.father[x])
def Merge(self, x, y):
a = self.SetOf(x)
b = self.SetOf(y)
if self.count[a] > self.count[b]:
temp = a
a = b
b = temp
self.count[b] += self.count[a]
self.father[a] = b
main()
``` | instruction | 0 | 11,028 | 13 | 22,056 |
No | output | 1 | 11,028 | 13 | 22,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST.
Submitted Solution:
```
import sys
from math import sqrt, floor, factorial, gcd
from collections import deque, Counter, defaultdict
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))
sys.setrecursionlimit(10**3)
# def a():
# n = int(inp()); arr = read()
# dic = {0 : 0, 1 : abs(arr[0]-arr[1])}
# def func(arr, n):
# # print(arr[n], n)
# if n in dic:
# return(dic[n])
# min_path = min(abs(arr[n]-arr[n-1])+func(arr,n-1), abs(arr[n]-arr[n-2])+func(arr,n-2))
# dic[n] = min_path
# return(min_path)
# print(func(arr, n-1))
# # print(dic)
if __name__ == "__main__":
# a()
print("""none
any
at least one
at least one
any""")
pass
``` | instruction | 0 | 11,029 | 13 | 22,058 |
No | output | 1 | 11,029 | 13 | 22,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a connected weighted undirected graph without any loops and multiple edges.
Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.
Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — the number of the graph's vertexes and edges, correspondingly. Then follow m lines, each of them contains three integers — the description of the graph's edges as "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
Output
Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.
Examples
Input
4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1
Output
none
any
at least one
at least one
any
Input
3 3
1 2 1
2 3 1
1 3 2
Output
any
any
none
Input
3 3
1 2 1
2 3 1
1 3 1
Output
at least one
at least one
at least one
Note
In the second sample the MST is unique for the given graph: it contains two first edges.
In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST.
Submitted Solution:
```
from sys import stdin
from math import inf
from collections import defaultdict
class disjoinSet(object):
def __init__(self,n):
self.father = [x for x in range(0,n+1)]
self.rank = [0 for x in range(0,n+1)]
def setOf(self, x):
if(self.father[x] != x):
self.father[x] = self.setOf(self.father[x])
return self.father[x]
def Merge(self,x,y):
xR = self.setOf(x)
yR = self.setOf(y)
if(xR == yR):
return
if self.rank[xR] < self.rank[yR]:
self.father[xR] = yR
elif self.rank[xR] > self.rank[yR]:
self.father[yR] = xR
else:
self.father[yR] = xR
self.rank[xR] +=1
##########
def mergesort(x):
if len(x) < 2:
return x
middle = int(len(x)/2)
left = mergesort(x[:middle])
right = mergesort(x[middle:])
return merge(left,right)
def merge(left,right):
result = []
l,r=0,0
while l < len(left) and r < len(right):
if left[l][2] <= right[r][2]:
result.append(left[l])
l+=1
else:
result.append(right[r])
r+=1
result += left[l:]
result += right[r:]
return result
##########
def DFS(graph,bridges):
time = 0
for key in graph:
low[key] = inf
d[key] = -1
pi[key] = key
visited[key] = False
for i in graph:
if not visited[i]:
DFS_Visit(graph,i,bridges)
def DFS_Visit(graph,u,bridges):
visited[u] = True
global time
time +=1
d[u] = time
low[u] = d[u]
for v in graph[u]:
if not visited[v]:
pi[v] = u
DFS_Visit(graph,v,bridges)
low[u] = min(low[u],low[v])
elif pi[u] != v:
low[u] = min(low[u],d[v])
if pi[u] != u and low[u] >= d[u]:
x = min(pi[u],u)
y = max(pi[u],u)
bridges.append([x,y])
time +=1
##########
n, m = map(int, stdin.readline().split())
if m > n-1:
visited = {}
d = {}
low = {}
pi = {}
time = 0
edges = []
for i in range(0,m):
x,y,z = map(int, stdin.readline().split())
edges.append([])
edges[i] = [x,y,z]
ans = {}
for i in edges:
x = min(i[0],i[1])
y = max(i[0],i[1])
ans[x,y] = "at least one"
dsu = disjoinSet(n)
sortEdges = mergesort(edges)
criticalEdges = []
i = 0
cantEdges = m
while i < cantEdges:
j = i;
a = 0
b = 0
criticalEdges = []
while j < len(sortEdges) and sortEdges[j][2] == sortEdges[i][2]:
x = dsu.setOf(sortEdges[j][0])
y = dsu.setOf(sortEdges[j][1])
a = min(sortEdges[j][0],sortEdges[j][1])
b = max(sortEdges[j][0],sortEdges[j][1])
if x == y:
ans[a,b] = "none"
criticalEdges.append(sortEdges[j])
j+=1
if len(criticalEdges) == 1:
if ans[a,b] != "none":
ans[a,b] = "any"
dsu.Merge(a,b)
else:
graph = defaultdict(set)
crossCut = defaultdict(list)
for m in criticalEdges:
x = min(dsu.setOf(m[0]),dsu.setOf(m[1]))
y = max(dsu.setOf(m[0]),dsu.setOf(m[1]))
if x != y:
graph[x].add(y)
graph[y].add(x)
crossCut[x,y].append([min(m[0],m[1]),max(m[0],m[1])])
bridges = []
DFS(graph,bridges)
for k in bridges:
if len(crossCut[k[0],k[1]]) == 1:
#x,y = crossCut[k[0],k[1]][0]
ans[k[0],k[1]] = "any"
for m in criticalEdges:
dsu.Merge(m[0],m[1])
i = j
for s in edges:
x = min(s[0],s[1])
y = max(s[0],s[1])
print(ans[x,y])
else:
for _ in range(0,m):
print("any")
``` | instruction | 0 | 11,030 | 13 | 22,060 |
No | output | 1 | 11,030 | 13 | 22,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph consisting of n vertices. Initially there are no edges in the graph. Also you are given q queries, each query either adds one undirected edge to the graph or removes it. After each query you have to check if the resulting graph is bipartite (that is, you can paint all vertices of the graph into two colors so that there is no edge connecting two vertices of the same color).
Input
The first line contains two integers n and q (2 ≤ n, q ≤ 100000).
Then q lines follow. ith line contains two numbers xi and yi (1 ≤ xi < yi ≤ n). These numbers describe ith query: if there is an edge between vertices xi and yi, then remove it, otherwise add it.
Output
Print q lines. ith line must contain YES if the graph is bipartite after ith query, and NO otherwise.
Example
Input
3 5
2 3
1 3
1 2
1 2
1 2
Output
YES
YES
NO
YES
NO
Submitted Solution:
```
class DoubleGraf:
def __init__(self, n):
self.points = [set() for i in range(n)]
self.n = n
def add(self, a, b):
self.points[a].add(b)
self.points[b].add(a)
def rem(self, a, b):
self.points[a].discard(b)
self.points[b].discard(a)
def line(self, a, b):
return a in self.points[b]
def look(self):
def rec(cur, point):
for subpoint in point:
if self.colors[subpoint] is None:
self.colors[subpoint] = cur
rec(not cur, self.points[subpoint])
elif self.colors[subpoint] != cur:
return False
cur = not cur
return True
self.colors = [None for i in range(self.n)]
self.colors[0] = False
cur = True
return rec(cur, self.points[0])
def __repr__(self):
return str(self.points)
def __init__(a, b):
if g.line(a, b):
g.rem(a, b)
else:
g.add(a, b)
return g.look()
if __name__ == '__main__':
__test__ = 0
if __test__:
tests = []
for i in range(len(tests)):
print(i + 1, end="\t")
print(tests[i][0] == __init__(*tests[i][1]), end="\t")
print(tests[i][0], "<<", __init__(*tests[i][1]))
exit()
n, q = map(int, input().split())
g = DoubleGraf(n)
for i in range(q):
print("YES" if __init__(*map(lambda x: int(x)-1, input().split())) else "NO")
``` | instruction | 0 | 11,314 | 13 | 22,628 |
No | output | 1 | 11,314 | 13 | 22,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph consisting of n vertices. Initially there are no edges in the graph. Also you are given q queries, each query either adds one undirected edge to the graph or removes it. After each query you have to check if the resulting graph is bipartite (that is, you can paint all vertices of the graph into two colors so that there is no edge connecting two vertices of the same color).
Input
The first line contains two integers n and q (2 ≤ n, q ≤ 100000).
Then q lines follow. ith line contains two numbers xi and yi (1 ≤ xi < yi ≤ n). These numbers describe ith query: if there is an edge between vertices xi and yi, then remove it, otherwise add it.
Output
Print q lines. ith line must contain YES if the graph is bipartite after ith query, and NO otherwise.
Example
Input
3 5
2 3
1 3
1 2
1 2
1 2
Output
YES
YES
NO
YES
NO
Submitted Solution:
```
class DoubleGraf:
def __init__(self, n):
self.points = [set() for i in range(n)]
self.n = n
def add(self, a, b):
self.points[a].add(b)
self.points[b].add(a)
def rem(self, a, b):
self.points[a].discard(b)
self.points[b].discard(a)
def line(self, a, b):
return a in self.points[b]
def look(self):
self.colors = [None for i in range(self.n)]
for i in range(self.n):
if self.colors[i] is None:
self.colors[i] = True
answ = self._look(i, True)
if not answ:
return False
return True
def _look(self, point, cur):
for i in self.points[point]:
if self.colors[i] is None:
self.colors[i] = not cur
answ = self._look(i, not cur)
if answ is None:
continue
return False
if self.colors[i] == cur:
return False
return None
def __repr__(self):
return str(self.points)
def __init__(a, b):
if g.line(a, b):
g.rem(a, b)
else:
g.add(a, b)
return g.look()
if __name__ == '__main__':
__test__ = 0
if __test__:
tests = []
for i in range(len(tests)):
print(i + 1, end="\t")
print(tests[i][0] == __init__(*tests[i][1]), end="\t")
print(tests[i][0], "<<", __init__(*tests[i][1]))
exit()
n, q = map(int, input().split())
g = DoubleGraf(n)
for i in range(q):
print("YES" if __init__(*map(lambda x: int(x) - 1, input().split())) else "NO")
``` | instruction | 0 | 11,315 | 13 | 22,630 |
No | output | 1 | 11,315 | 13 | 22,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an undirected graph consisting of n vertices. Initially there are no edges in the graph. Also you are given q queries, each query either adds one undirected edge to the graph or removes it. After each query you have to check if the resulting graph is bipartite (that is, you can paint all vertices of the graph into two colors so that there is no edge connecting two vertices of the same color).
Input
The first line contains two integers n and q (2 ≤ n, q ≤ 100000).
Then q lines follow. ith line contains two numbers xi and yi (1 ≤ xi < yi ≤ n). These numbers describe ith query: if there is an edge between vertices xi and yi, then remove it, otherwise add it.
Output
Print q lines. ith line must contain YES if the graph is bipartite after ith query, and NO otherwise.
Example
Input
3 5
2 3
1 3
1 2
1 2
1 2
Output
YES
YES
NO
YES
NO
Submitted Solution:
```
class DoubleGraf:
def __init__(self, n):
self.points = [set() for i in range(n)]
self.n = n
def add(self, a, b):
self.points[a].add(b)
self.points[b].add(a)
def rem(self, a, b):
self.points[a].discard(b)
self.points[b].discard(a)
def line(self, a, b):
return a in self.points[b]
def look(self):
def rec(cur, point):
for subpoint in point:
if self.colors[subpoint] is None:
self.colors[subpoint] = cur
return rec(not cur, self.points[subpoint])
elif self.colors[subpoint] != cur:
return False
return True
self.colors = [None for i in range(self.n)]
self.colors[0] = False
cur = True
return rec(cur, self.points[0])
def __repr__(self):
return str(self.points)
def __init__(a, b):
if g.line(a, b):
g.rem(a, b)
else:
g.add(a, b)
return g.look()
if __name__ == '__main__':
__test__ = 0
if __test__:
tests = []
for i in range(len(tests)):
print(i + 1, end="\t")
print(tests[i][0] == __init__(*tests[i][1]), end="\t")
print(tests[i][0], "<<", __init__(*tests[i][1]))
exit()
n, q = map(int, input().split())
g = DoubleGraf(n)
for i in range(q):
print("YES" if __init__(*map(lambda x: int(x)-1, input().split())) else "NO")
``` | instruction | 0 | 11,316 | 13 | 22,632 |
No | output | 1 | 11,316 | 13 | 22,633 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,504 | 13 | 23,008 |
"Correct Solution:
```
n, m = map(int, input().split())
edges = [None] * m
for i in range(m):
a, b, c = map(int, input().split())
edges[i] = (a-1, b-1, -c)
INF = float("inf")
d = [INF] * n
d[0] = 0
for i in range(n-1):
for f, t, c in edges:
if d[f] == INF: continue
d[t] = min(d[t], d[f] + c)
inf_flag = [False] * n
for i in range(n):
for f, t, c in edges:
if d[f] == INF: continue
if inf_flag[f] == True:
inf_flag[t] = True
if d[t] > d[f] + c:
d[t] = d[f] + c
inf_flag[t] = True
print("inf" if inf_flag[n-1] else -d[n-1])
``` | output | 1 | 11,504 | 13 | 23,009 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,505 | 13 | 23,010 |
"Correct Solution:
```
N, M = map(int, input().split())
edge = []
for i in range(M):
a, b, c = map(int, input().split())
edge.append([a, b, c*-1])
d = [float('inf')] * (N+1)
d[1] = 0
for i in range(1, N+1):
for e in edge:
if (d[e[0]] != float('inf')) & (d[e[1]] > d[e[0]] + e[2]):
d[e[1]] = d[e[0]] + e[2]
update = True
if (i == N) & (e[1] == N):
print('inf')
exit()
print(d[N]*-1)
``` | output | 1 | 11,505 | 13 | 23,011 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,506 | 13 | 23,012 |
"Correct Solution:
```
n, m = map(int, input().split())
edges = []
for _ in range(m):
a, b, c = map(int, input().split())
edges.append((a-1, b-1, -c))
def shortest_path(v, s, edges, inf):
d = [inf] * v
d[s] = 0
for i in range(2 * n):
update = False
for frm, to, cost in edges:
if d[frm] != inf and d[to] > d[frm] + cost:
d[to] = d[frm] + cost
update = True
if i == n:
memo = d[-1]
if memo != d[-1]:
print('inf')
exit()
return d[-1]
inf = 1e30
print(-shortest_path(n, 0, edges, inf))
``` | output | 1 | 11,506 | 13 | 23,013 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,507 | 13 | 23,014 |
"Correct Solution:
```
n,m=map(int,input().split())
abc=[tuple(map(int,input().split())) for _ in range(m)]
Inf=float('inf')
dist=[Inf]*n
dist[0]=0
for i in range(n):
for a,b,c in abc:
a,b,c=a-1,b-1,-c
if dist[b] >dist[a]+c:
dist[b]=dist[a]+c
if i==n-1 and b==n-1:
print('inf')
exit()
print(-dist[-1])
``` | output | 1 | 11,507 | 13 | 23,015 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,508 | 13 | 23,016 |
"Correct Solution:
```
# ABC061 D - Score Attack
import sys
N, M = map(int, input().split())
edge = [list(map(int, input().split())) for _ in range(M)]
INF = 1 << 60
cost = [- INF] * (N + 1)
cost[1] = 0
for i in range(N):
for n, nn, c in edge:
if cost[nn] < cost[n] + c:
# ベルマンフォード法の性質より、N回目に更新があるならinf
if i == N - 1 and nn == N:
print("inf")
sys.exit()
cost[nn] = cost[n] + c
print(cost[N])
``` | output | 1 | 11,508 | 13 | 23,017 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,509 | 13 | 23,018 |
"Correct Solution:
```
(n,m),*l=[list(map(int,s.split()))for s in open(0)];d=[0]*2+[9e99]*n
for i in range(n*2):
for a,b,c in l:
if d[b]>d[a]-c:d[b]=[d[a]-c,-9e99][i>n]
if i==n:x=d[n]
print([-x,'inf'][d[n]!=x])
``` | output | 1 | 11,509 | 13 | 23,019 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,510 | 13 | 23,020 |
"Correct Solution:
```
n,m = map(int , input().split())
e = []
for i in range(m):
a,b,c = map(int , input().split())
e.append((a-1,b-1,c))
maxdis = [-float('inf') for i in range(n)]
maxdis[0] = 0
mugen = False
for i in range(2*n):
for j in e:
st,gl,cost = j
if (maxdis[gl] < maxdis[st]+cost):
maxdis[gl] = maxdis[st]+cost
if (i >= n-1 and (gl == n-1)):
mugen = True
break
if mugen:
print("inf")
else:
print(maxdis[n-1])
``` | output | 1 | 11,510 | 13 | 23,021 |
Provide a correct Python 3 solution for this coding contest problem.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000 | instruction | 0 | 11,511 | 13 | 23,022 |
"Correct Solution:
```
def shortest_path(edge,num_v,start):
inf = float("inf")
d = [-inf for f in range(num_v)]
d[start] = 0;
for i in range(3000):
update = False
for e in edge:
if (d[e[0]-1] != -inf and d[e[1]-1] < d[e[0]-1] + e[2]):
d[e[1]-1] = d[e[0]-1] + e[2]
update = True
if (e[1] == n and i >= n):
return "inf"
if not update:
break
return d[-1]
n,m = map(int,input().split())
p = []
for i in range(m):
p.append(list(map(int, input().split())))
ans = shortest_path(p,n,0)
print(ans)
``` | output | 1 | 11,511 | 13 | 23,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
def main():
INF = float("inf")
N, M, *ABC = map(int, open(0).read().split())
D = [0] + [INF] * (N - 1)
E = tuple((a - 1, b - 1, -c) for a, b, c in zip(*[iter(ABC)] * 3))
for a, b, c in E:
D[b] = min(D[b], D[a] + c)
ans = D[-1]
for a, b, c in E:
D[b] = min(D[b], D[a] + c)
print("inf" if ans != D[-1] else -ans)
main()
``` | instruction | 0 | 11,512 | 13 | 23,024 |
Yes | output | 1 | 11,512 | 13 | 23,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
N, M = map(int, input().split())
edges = []
for i in range(M):
a, b, c = map(int, input().split())
edges.append((a, b, c))
edges.sort()
def bellmanford(n, edges, start):
INF = float('inf')
dist = [-INF] * (n+1) # dist[0]は使わない
dist[start] = 0
for i in range(n):
for (pre, ne, weight) in edges:
if dist[pre] != -INF and dist[pre] + weight > dist[ne]:
dist[ne] = dist[pre] + weight
if i == n-1 and ne == n:
return 'inf'
return dist[n]
answer = bellmanford(N, edges, 1)
print(answer)
``` | instruction | 0 | 11,513 | 13 | 23,026 |
Yes | output | 1 | 11,513 | 13 | 23,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
def bellmanford(s, n, es):
# 負の経路の検出
# n:頂点数, w:辺の数, es[i]: [辺の始点,辺の終点,辺のコスト]
d = [float("inf")] * n
neg = [False]*n
d[s] = 0
for i in range(n):
for p, q, r in es:
if d[p] != float("inf") and d[q] > d[p] + r:
d[q] = d[p] + r
if i == n-1:
neg[q] = True
return d, neg
n, w = map(int, input().split()) # n:頂点数 w:辺の数
es = []
for _ in range(w):
x, y, z = map(int, input().split())
es.append([x-1, y-1, -z])
d, neg = bellmanford(0, n, es)
if neg[-1]:
print("inf")
else:
print(-d[-1])
``` | instruction | 0 | 11,514 | 13 | 23,028 |
Yes | output | 1 | 11,514 | 13 | 23,029 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
import sys
INF = float("inf")
def Bellmanford(n, edges, r): # rは始点
d = [INF] * n
d[r] = 0
for i in range(n):
for (u, v, c) in edges:
if d[u] != INF and d[u] + c < d[v]:
d[v] = d[u] + c
if i == n - 1 and v == n - 1:
return "inf"
return -d[n-1]
N, M = map(int, sys.stdin.readline().split())
Edges = [None] * M
for i in range(M):
ai, bi, ci = map(int, sys.stdin.readline().split())
Edges[i] = (ai - 1, bi - 1, -ci)
ans = Bellmanford(N, Edges, 0)
print(ans)
``` | instruction | 0 | 11,515 | 13 | 23,030 |
Yes | output | 1 | 11,515 | 13 | 23,031 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
from collections import defaultdict
N, M, *L = map(int, open(0).read().split())
dic = defaultdict(list)
rdic = defaultdict(list)
nin = [0]*N
Els = []
for a,b,c in zip(*[iter(L)]*3):
dic[a-1] += [b-1]
rdic[b-1] += [a-1]
nin[b-1] += 1
Els += [(a-1,b-1,-c)]
To = [False]*N
From = [False]*N
q = [0]
To[0] = True
while q:
p = q.pop()
for e in dic[p]:
if To[e]==False:
To[e] = True
q += [e]
q = [N-1]
From[N-1] = True
while q:
p = q.pop()
for e in rdic[p]:
if From[e]==False:
From[e] = True
q += [e]
ok = [False]*N
for i in range(N):
ok[i] = To[i]&From[i]
cnt = 0
dist = [float('inf')]*N
dist[0] = 0
cnt = 0
flag = False
while True:
update = True
for a,b,c in Els:
if dist[a]!=float('inf') and dist[b]>dist[a]+c:
dist[b] = dist[a]+c
update = False
if update:
break
cnt += 1
if cnt>2*M:
flag = True
break
if flag:
print('inf')
else:
print(-dist[N-1])
``` | instruction | 0 | 11,516 | 13 | 23,032 |
No | output | 1 | 11,516 | 13 | 23,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
N, M = map(int, input().split())
G = [[] for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
G[a - 1].append((b - 1, -c))
INF = float("inf")
d = [INF] * N
d[0] = 0
for i in range(N):
for b, c in G[i]:
if d[b] > d[i] + c:
d[b] = d[i] + c
mi = [False] * N
for i in range(N):
for b, c in G[i]:
if d[b] > d[i] + c:
mi[b] = True
if mi[N - 1]:
print("inf")
else:
print(-d[N - 1])
``` | instruction | 0 | 11,517 | 13 | 23,034 |
No | output | 1 | 11,517 | 13 | 23,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
V, E = map(int, input().split())
G = [[] for i in range(V+1)]
for i in range(E):
a, b, c = map(int, input().split())
G[a-1].append((b-1, 0-c))
G[V-1].append((V, 0))
INF = float('inf')
dist = [INF] * (V + 1)
dist[0] = 0
Flag = False
for i in range(V+1):
UnUpdate = True
for v, e in enumerate(G):
for t, cost in e:
if dist[v] != INF and dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
UnUpdate = False
if UnUpdate and i < V:
Flag = True
break
if Flag:
print(0-dist[V])
else:
print(1/0)
``` | instruction | 0 | 11,518 | 13 | 23,036 |
No | output | 1 | 11,518 | 13 | 23,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a directed graph with N vertices and M edges. The i-th edge (1≤i≤M) points from vertex a_i to vertex b_i, and has a weight c_i. We will play the following single-player game using this graph and a piece.
Initially, the piece is placed at vertex 1, and the score of the player is set to 0. The player can move the piece as follows:
* When the piece is placed at vertex a_i, move the piece along the i-th edge to vertex b_i. After this move, the score of the player is increased by c_i.
The player can end the game only when the piece is placed at vertex N. The given graph guarantees that it is possible to traverse from vertex 1 to vertex N.
When the player acts optimally to maximize the score at the end of the game, what will the score be? If it is possible to increase the score indefinitely, print `inf`.
Constraints
* 2≤N≤1000
* 1≤M≤min(N(N-1),2000)
* 1≤a_i,b_i≤N (1≤i≤M)
* a_i≠b_i (1≤i≤M)
* a_i≠a_j or b_i≠b_j (1≤i<j≤M)
* -10^9≤c_i≤10^9 (1≤i≤M)
* c_i is an integer.
* In the given graph, there exists a path from vertex 1 to vertex N.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the maximum possible score at the end of the game, if it is finite. If it is possible to increase the score indefinitely, print `inf`.
Examples
Input
3 3
1 2 4
2 3 3
1 3 5
Output
7
Input
2 2
1 2 1
2 1 1
Output
inf
Input
6 5
1 2 -1000000000
2 3 -1000000000
3 4 -1000000000
4 5 -1000000000
5 6 -1000000000
Output
-5000000000
Submitted Solution:
```
n, m = map(int, input().split())
abc = [list(map(int, input().split())) for _ in range(m)]
cost = [[0] * n for _ in range(n)]
for a, b, c in abc:
cost[a-1][b-1] = -c
from scipy.sparse.csgraph import floyd_warshall
try:
dist = floyd_warshall(cost)
print(-1 * int(dist[0][n-1]))
except:
print('inf')
``` | instruction | 0 | 11,519 | 13 | 23,038 |
No | output | 1 | 11,519 | 13 | 23,039 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,602 | 13 | 23,204 |
"Correct Solution:
```
import sys,collections
N,E,r = tuple(map(int,sys.stdin.readline().split())) # single line with multi param
sdw = tuple(tuple(map(int,sys.stdin.readline().rstrip().split())) for _ in range(E)) # multi line with multi param
#sdw = [[src1 dist1 d1][src1 dist1 d1]...]# vect source1 -> distance1 distances
INF = float("inf")
ALL = set(range(N))#including sentinel
distances = collections.defaultdict(lambda:INF)
distances[r] = 0
for _ in range(N):
modified = False
for src,dst,weight in sdw:
if distances[dst] > distances[src] + weight:
distances[dst] = distances[src] + weight
modified = True
if modified == False:
for i in range(N):
if distances[i] == INF:
print("INF")
else:
print(distances[i])
exit()
print("NEGATIVE CYCLE")
``` | output | 1 | 11,602 | 13 | 23,205 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,603 | 13 | 23,206 |
"Correct Solution:
```
import sys
fin = sys.stdin.readline
MAX_NUM = float('inf')
def initialize_int(adj, s):
"""
assume that all vertex in {0, 1, 2, ..., N - 1}
"""
N = len(adj)
d = [MAX_NUM] * N
d[s] = 0
parent = [None] * N
return d, parent
def relax(d, w, source_v, target_v, parent):
new_cost = d[source_v] + w[source_v][target_v]
if new_cost < d[target_v]:
d[target_v] = new_cost
parent[target_v] = source_v
# Even if a negative weight exists, bellman-ford can find shortest paths.
# it also detects negative cycles,
# but not every edges that consist the negative cycles is stored.
# time complexity: O(VE + (V^2))
def bellman_ford(adj, w, s):
d, parent = initialize_int(adj, s)
# calculate shortest paths
for _ in range(len(adj)):
for vertex in range(len(adj)):
for neighbor in adj[vertex]:
relax(d, w, vertex, neighbor, parent)
# detects negative cycles if exist
negative_cycle_edges = set()
for vertex in range(len(adj)):
for neighbor in adj[vertex]:
if d[neighbor] > d[vertex] + w[vertex][neighbor]:
negative_cycle_edges.add((vertex, neighbor))
return d, parent, negative_cycle_edges
V, E, r = [int(elem) for elem in fin().split()]
adj = [[] for _ in range(V)]
w = [[None] * V for _ in range(V)]
for _ in range(E):
s, t, d = [int(elem) for elem in fin().split()]
adj[s].append(t)
w[s][t] = d
d, parent, negative_cycle_edges = bellman_ford(adj, w, r)
if len(negative_cycle_edges) > 0:
print("NEGATIVE CYCLE")
else:
for i in range(V):
print("INF") if d[i] == MAX_NUM else print(d[i])
``` | output | 1 | 11,603 | 13 | 23,207 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,604 | 13 | 23,208 |
"Correct Solution:
```
N,E,r=map(int,input().split())
G=[]
for i in range(E):
s,t,d=map(int,input().split())
G.append([d,s,t])
def bellman_ford(G,s):
INF=10**9
d=[INF]*N
d[s]=0
j=0
while(True):
update=False
for i in range(E):
cost,fro,to=G[i]
if d[fro]!=INF and d[to]>d[fro]+cost:
d[to]=d[fro]+cost
update=True
if j==N-1:
return True,0#負の閉路あり
j+=1
if not(update):
break
return False,d#負の閉路なし、ｓからの最短距離ｄ
bool,d=bellman_ford(G,r)
if bool:
print("NEGATIVE CYCLE")
else:
for i in range(N):
if d[i]==10**9:
print("INF")
else:
print(d[i])
``` | output | 1 | 11,604 | 13 | 23,209 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,605 | 13 | 23,210 |
"Correct Solution:
```
v,e,r=map(int,input().split())
d=[float("INF")]*v
edges=[[] for i in range(v)]
for i in range(e):
a,*s=map(int,input().split())
edges[a].append(s)
d[r]=0
from collections import deque
#pop/append/(append,pop)_left/in/len/count/[]/index/rotate()(右へnずらす)
for i in range(v+2):
f=False
used=set()
dq=deque([r])
while dq:
a=dq.popleft()
for to,c in edges[a]:
if d[to]>c+d[a]:
f=True
d[to]=c+d[a]
if to not in used:dq.append(to);used.add(to)
if i==v:print("NEGATIVE CYCLE");exit()
if f:continue
break
for i in d:
print("INF" if i==float("INF") else i)
``` | output | 1 | 11,605 | 13 | 23,211 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,606 | 13 | 23,212 |
"Correct Solution:
```
INF = float("inf")
def bellman_ford(edges, num_v, sv):
#グラフの初期化
dist = [INF for i in range(num_v)]
dist[sv]=0
#辺の緩和
for i in range(num_v):
for edge in edges:
s, t, d = edge[0], edge[1], edge[2]
if dist[s] != INF and dist[t] > dist[s] + d:
dist[t] = dist[s] + d
if i == num_v - 1:
return -1 # 負の閉路が存在する
return dist
def main():
N, M, r = map(int, input().split())
edges = []
for _ in range(M):
s, t, d = map(int, input().split())
edges.append([s, t, d])
dist = bellman_ford(edges, N, r)
if dist == -1:
print("NEGATIVE CYCLE")
else:
for i in range(N):
ans = dist[i]
if ans == INF:
ans = "INF"
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 11,606 | 13 | 23,213 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,607 | 13 | 23,214 |
"Correct Solution:
```
def main():
nvertices, nedges, s = map(int, input().split())
E = []
for i in range(nedges):
u, v, w = map(int, input().split())
E.append((u, v, w))
INF = 1000000000
d = [INF] * nvertices
d[s] = 0
for i in range(nvertices - 1):
for u, v, w in E:
if d[u] == INF:
continue
if d[u] + w < d[v]:
d[v] = d[u] + w
for i in range(nvertices - 1):
for u, v, w in E:
if d[v] == INF:
continue
if d[v] > d[u] + w:
print("NEGATIVE CYCLE")
return
for val in d:
if val >= INF:
print("INF")
else:
print(val)
main()
``` | output | 1 | 11,607 | 13 | 23,215 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,608 | 13 | 23,216 |
"Correct Solution:
```
# !/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
output:
INF
0
-5
-3
OR
input:
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
output:
NEGATIVE CYCLE
"""
import sys
from math import isinf
def generate_adj_table(_v_info):
for each in _v_info:
source, target, cost = map(int, each)
init_adj_table[source].setdefault(target, cost)
return init_adj_table
def bellman_ford():
distance[root] = 0
for j in range(vertices - 1):
for current, current_info in enumerate(adj_table):
for adj, cost in current_info.items():
if distance[current] + cost < distance[adj]:
distance[adj] = distance[current] + cost
for current, current_info in enumerate(adj_table):
for adj, cost in current_info.items():
if distance[current] + cost < distance[adj]:
print('NEGATIVE CYCLE')
return list()
return distance
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges, root = map(int, _input[0].split())
v_info = map(lambda x: x.split(), _input[1:])
distance = [float('inf')] * vertices
init_adj_table = tuple(dict() for _ in range(vertices))
adj_table = generate_adj_table(v_info)
res = bellman_ford()
for ele in res:
if isinf(ele):
print('INF')
else:
print(ele)
``` | output | 1 | 11,608 | 13 | 23,217 |
Provide a correct Python 3 solution for this coding contest problem.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3 | instruction | 0 | 11,609 | 13 | 23,218 |
"Correct Solution:
```
V,E,r = map(int,input().split())
# adj_list = [ [] for _ in range(V)]
INF = float('inf')
edges = []
for _ in range(E):
s,d,c = map(int, input().split())
edges.append([s,d,c])
dist = [INF] * V
dist[r] = 0
for _ in range(V-1):
for s,d,c in edges:
# import pdb; pdb.set_trace()
if dist[d] > dist[s] + c:
dist[d] = dist[s] + c
for s,d,c in edges:
if dist[d] > dist[s] + c:
print("NEGATIVE CYCLE")
exit()
for d in dist:
print(d if d!=INF else "INF")
``` | output | 1 | 11,609 | 13 | 23,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
INF=10**30
def Belman_Ford(s,N):
dist=[INF]*N
dist[s]=0
cnt=0
neg=False
while True:
if cnt==N:
break
update=False
for f,t,c in Edge:
if dist[t]>dist[f]+c:
if cnt<N-1:
if dist[f]!=INF:
dist[t]=min(dist[t],dist[f]+c)
update=True
else:
neg=True
if not update:
break
cnt+=1
if neg:
return -1
else:
return dist
V,E,r=map(int,input().split())
Edge=[tuple(map(int,input().split())) for i in range(E)]
res=Belman_Ford(r,V)
if type(res) is int:
print('NEGATIVE CYCLE')
else:
for i in range(V):
print(res[i] if res[i]!=INF else 'INF')
``` | instruction | 0 | 11,610 | 13 | 23,220 |
Yes | output | 1 | 11,610 | 13 | 23,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
import math
def main():
nvertices, nedges, s = map(int, input().split())
E = []
for i in range(nedges):
u, v, w = map(int, input().split())
E.append((u, v, w))
INF = float('inf')
weights = [INF] * nvertices
weights[s] = 0
for i in range(nvertices - 1):
for u, v, w in E:
if weights[v] > weights[u] + w:
weights[v] = weights[u] + w
for u, v, w in E:
if weights[v] > weights[u] + w:
print("NEGATIVE CYCLE")
return
for w in weights:
if math.isinf(w):
print("INF")
else:
print(w)
main()
``` | instruction | 0 | 11,611 | 13 | 23,222 |
Yes | output | 1 | 11,611 | 13 | 23,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import array
import collections
G_INF = 2 ** 31
# ??°???????????¢??????????????????????????????
class GraphError(Exception):
pass
# ??°???????????¢?´¢??§??????????????????????????¨?????¨?????????????????????
class GraphSearchError(GraphError):
def __init__(self, reason):
self.reason = reason
def __str__(self):
return str(reason)
# Shortest Path Faster Algorithm??¬???
class ShortestPathFasterAlgorithm(object):
def __init__(self, number_of_vertices, adjacency_list, costs, start):
# ??????????????°
self.max_v = number_of_vertices
# ??£??\?????????
# ?????????????????????????????£??\???????????????array????????¨????????????defaultdict
self.adj = adjacency_list
# (???????§????, ????????????)????????????????????????????????¨????????????defaultdict
self.costs = costs
# ??¢?´¢????§????
self.start = start
# ?§???????????????????????????????????????????????´???????defaultdict
self.dist = None
# ?????????????¨?????????°???????´???????defaultdict
self.visits = None
def initialize(self):
self.dist = collections.defaultdict(lambda: G_INF)
self.dist[self.start] = 0
self.visits = collections.defaultdict(int)
def single_source_shortest_path(self):
self.initialize()
# ????????????????????????????????\???????????????????????¨??????defaultdict
# ?????\??????????´?????????????????????¢????????????????????????????°???\??????
in_q = collections.defaultdict(bool)
# ?????????????????\???
q = collections.deque()
q.append(self.start)
in_q[self.start] = True
while q:
u = q.popleft()
in_q[u] = False
self.visits[u] += 1
if self.visits[u] >= self.max_v:
if self.max_v == 1:
# |V| = 1, |E| = 0??¨????????????????????±??????????????????
# ????????´??????????????????
return [0]
raise GraphSearchError("A negative cycle was detected.")
for v in self.adj[u]:
new_length = self.dist[u] + self.costs[(u, v)]
if new_length < self.dist[v]:
self.dist[v] = new_length
if not in_q[v]:
q.append(v)
in_q[v] = True
return self.dist
def main():
max_v, max_e, start = map(int, input().split())
adjacency_list = collections.defaultdict(lambda: array.array("L"))
costs = collections.defaultdict(lambda: G_INF)
for _ in range(max_e):
s, t, d = map(int, input().split())
adjacency_list[s].append(t)
costs[(s, t)] = d
spfa = ShortestPathFasterAlgorithm(max_v, adjacency_list, costs, start)
try:
dist = spfa.single_source_shortest_path()
for v in range(max_v):
result = dist[v]
if result < G_INF:
print(result)
else:
print("INF")
except GraphSearchError as gse:
print("NEGATIVE CYCLE")
if __name__ == '__main__':
main()
``` | instruction | 0 | 11,612 | 13 | 23,224 |
Yes | output | 1 | 11,612 | 13 | 23,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
from collections import defaultdict
def bellman_ford(V, E, s):
'''
Input:
V = list(range(N))
E = {i: defaultdict(int) for i in range(N)}
s (in V) : start vertex
Output:
dist: the list of the minimum cost from s to arbitrary vertex v in the given graph
'''
INF = float('inf')
N = len(V)
dist = [INF]*N
prev = [-1]*N
dist[s] = 0
for n_iterations in range(N):
updated = False
for v in V:
d = dist[v]
if d != INF:
for u, c in E[v].items():
temp = d + c
if dist[u] > temp:
updated = True
dist[u] = temp
prev[u] = v
if not updated: # the minimum costs are already stored in dist
break
else: # the above loop is not broken if and only if there exists a negative cycle
return None
return dist
INF = float('inf')
N, M, r = map(int, input().split())
E = {i: defaultdict(int) for i in range(N)}
for _ in range(M):
a, b, c = map(int, input().split())
E[a][b] = c
V = list(range(N))
dist = bellman_ford(V, E, r)
if dist is None:
print('NEGATIVE CYCLE')
else:
for d in dist:
if d == INF: print('INF')
else: print(d)
``` | instruction | 0 | 11,613 | 13 | 23,226 |
Yes | output | 1 | 11,613 | 13 | 23,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
import sys
inf = int(1e12)
def shortestPath(graph, s):
n = len(graph)
dist = [inf for _ in range(n)]
dist[s] = 0
for i in range(n):
for u in range(n):
for v, cost in graph[u]:
newDist = dist[u] + cost
if newDist < dist[v]:
if i == n - 1:
return None
dist[v] = newDist
return dist
def main():
v, e, s = map(int, input().split())
graph = [[] for _ in range(v)]
for i in range(e):
a, b, cost = map(int, input().split())
graph[a].append((b, cost))
dist = shortestPath(graph, s)
if not dist:
print("NEGATIVE CYCLE")
else:
for d in dist:
if d >= inf / 2:
print("INF")
else:
print(d)
main()
``` | instruction | 0 | 11,614 | 13 | 23,228 |
No | output | 1 | 11,614 | 13 | 23,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
output:
INF
0
-5
-3
OR
input:
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
output:
NEGATIVE CYCLE
"""
import sys
from math import isinf
# WHITE, GRAY, BLACK = 0, 1, 2
def generate_adj_table(v_table):
for each in v_table:
source, target, cost = map(int, each)
init_adj_table[source][target] = cost
return init_adj_table
def bellman_ford():
distance[root] = 0
for current in range(vertices):
v_info = adj_table[current].items()
for adj, cost in v_info:
if not isinf(distance[current]) and distance[current] + cost < distance[adj]:
distance[adj] = distance[current] + cost
for current in range(vertices):
v_info = adj_table[current].items()
for adj, cost in v_info:
if not isinf(distance[current]) and distance[current] + cost < distance[adj]:
print('NEGATIVE CYCLE')
return list()
return distance
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges, root = map(int, _input[0].split())
init_vertices_table = map(lambda x: x.split(), _input[1:])
# assert len(init_vertices_table) == vertices_num
distance = [float('inf')] * vertices
# color = [WHITE] * vertices
init_adj_table = tuple(dict() for _ in range(vertices))
init_vertex = 0
adj_table = generate_adj_table(init_vertices_table)
res = bellman_ford()
for ele in res:
if isinf(ele):
print('INF')
else:
print(ele)
``` | instruction | 0 | 11,615 | 13 | 23,230 |
No | output | 1 | 11,615 | 13 | 23,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
# Input acceptance
import sys
file_input = sys.stdin
V, E, r = map(int, file_input.readline().split())
edges = []
for line in file_input:
edges.append(tuple(map(int, line.split())))
# Bellman???Ford algorithm
distance = [float("inf")] * V
distance[r] = 0
for i in range(V):
notUpdated = True
for e in edges:
t = e[1]
temp_d = distance[e[0]] + e[2]
if temp_d < distance[t]:
distance[t] = temp_d
notUpdated = False
if notUpdated:
break
# Output
if i == V - 1:
print("NEGATICE CYCLE")
else:
print(*map(lambda x: str(x).upper(), distance), sep = '\n')
``` | instruction | 0 | 11,616 | 13 | 23,232 |
No | output | 1 | 11,616 | 13 | 23,233 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Constraints
* 1 ≤ |V| ≤ 1000
* 0 ≤ |E| ≤ 2000
* -10000 ≤ di ≤ 10000
* There are no parallel edges
* There are no self-loops
Input
An edge-weighted graph G (V, E) and the source r.
|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1
|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.
si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.
Output
If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print
NEGATIVE CYCLE
in a line.
Otherwise, print
c0
c1
:
c|V|-1
The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".
Examples
Input
4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
0
2
-3
-1
Input
4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0
Output
NEGATIVE CYCLE
Input
4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
Output
INF
0
-5
-3
Submitted Solution:
```
import sys
INF = float('inf')
def Bellmanford(n, edges, r):
d = [INF] * n
d[r] = 0
for i in range(n):
flag = False
for (u, v, c) in edges:
if d[u] != INF and d[u] + c < d[v]:
d[v] = d[u] + c
flag = True
if flag and i == n-1:
return 'NEGATIVE CYCLE'
d = [di if di < INF else 'INF' for di in d]
return d
V, E, R = map(int, sys.stdin.readline().split())
Edges = [None] * E
for i in range(E):
si, ti, di = map(int, sys.stdin.readline().split())
Edges[i] = (si, ti, di)
ans = Bellmanford(V, Edges, R)
print(*ans, sep = '\n')
``` | instruction | 0 | 11,617 | 13 | 23,234 |
No | output | 1 | 11,617 | 13 | 23,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,618 | 13 | 23,236 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
from math import gcd
n, m = [int(x) for x in input().strip().split()]
if n-1 > m:
print('Impossible')
exit()
edges = []
for i in range(1, n+1):
for j in range(i+1, n+1):
if gcd(i, j) == 1:
edges.append([i, j])
if len(edges) == m:
print('Possible')
for edge in edges:
print(*edge)
exit()
print('Impossible')
``` | output | 1 | 11,618 | 13 | 23,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,619 | 13 | 23,238 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
from math import gcd
n,m=map(int,input().split())
l=[]
cnt=0
if n>=m+2:
print("Impossible")
else:
for i in range(1,n):
l.append([i,i+1])
cnt=cnt+1
if cnt==m:
break
for i in range(1,n+1):
if cnt==m:
break
for j in range(i+2,n+1):
if gcd(i,j)==1:
l.append([i,j])
cnt=cnt+1
if(cnt==m):
break
if cnt<m:
print("Impossible")
else:
print("Possible")
for i in l:
print(i[0],end=" ")
print(i[1])
``` | output | 1 | 11,619 | 13 | 23,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,620 | 13 | 23,240 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
from array import array
from sys import stdin
import bisect
from bisect import *
import itertools
from itertools import *
def scan_gen():
for line in stdin: yield from iter(line.split())
scan = scan_gen()
def nint(): return int(next(scan))
def nintk(k): return tuple(nint() for _ in range(k))
def nfloat(): return float(next(scan))
def intar_init(size): return array('i',[0]) *size
def intar(size=None):
if size == None: size = nint()
arr = intar_init(size)
for x in range(size): arr[x]=nint()
return arr
def gcd(x, y):
while(y):
x, y = y, x % y
return x
def solve():
n,m = nintk(2)
if m <n-1:
print("Impossible")
return
res = []
for x in range(2,n+1):
res += [(1,x)]
m-=1
for (x,y) in product(range(2,n+1), range(2,n+1)):
if x<y and gcd(x,y)==1:
if m==0 : break
res += [(x,y)]
m -=1
if m==0 : break
if m !=0:
print("Impossible")
else:
print("Possible")
for p in res:
print(*p)
solve()
``` | output | 1 | 11,620 | 13 | 23,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,621 | 13 | 23,242 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
from math import gcd
n,m = map(int,input().split())
if m<n-1:
print ("Impossible")
exit()
ans = []
for i in range(1,n+1):
for j in range(i+1,n+1):
if gcd(i,j)==1:
m -= 1
ans.append((i,j))
if m==0:
break
if m==0:
break
if m!=0:
print ("Impossible")
else:
print ("Possible")
for i in ans:
print (i[0],i[1])
``` | output | 1 | 11,621 | 13 | 23,243 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,622 | 13 | 23,244 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
n,m=map(int,input().split())
import math
if m<n-1 or m>(n-1)*n//2:print("Impossible");exit()
ans=[[1,i] for i in range(2,n+1)]
m-=n-1
i=0
b=2
k=b+1
while i<m and b<n:
if math.gcd(b,k)==1:
i+=1
ans.append([b,k])
k+=1
if k==n+1:
b+=1
k=b+1
if i==m:
print("Possible")
for i in ans:
print(*i)
else:
print("Impossible")
``` | output | 1 | 11,622 | 13 | 23,245 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's call an undirected graph G = (V, E) relatively prime if and only if for each edge (v, u) ∈ E GCD(v, u) = 1 (the greatest common divisor of v and u is 1). If there is no edge between some pair of vertices v and u then the value of GCD(v, u) doesn't matter. The vertices are numbered from 1 to |V|.
Construct a relatively prime graph with n vertices and m edges such that it is connected and it contains neither self-loops nor multiple edges.
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
If there are multiple answers then print any of them.
Input
The only line contains two integers n and m (1 ≤ n, m ≤ 10^5) — the number of vertices and the number of edges.
Output
If there exists no valid graph with the given number of vertices and edges then output "Impossible".
Otherwise print the answer in the following format:
The first line should contain the word "Possible".
The i-th of the next m lines should contain the i-th edge (v_i, u_i) of the resulting graph (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i). For each pair (v, u) there can be no more pairs (v, u) or (u, v). The vertices are numbered from 1 to n.
If there are multiple answers then print any of them.
Examples
Input
5 6
Output
Possible
2 5
3 2
5 1
3 4
4 1
5 4
Input
6 12
Output
Impossible
Note
Here is the representation of the graph from the first example: <image> | instruction | 0 | 11,623 | 13 | 23,246 |
Tags: brute force, constructive algorithms, graphs, greedy, math
Correct Solution:
```
def gcd(n1,n2):
if n2 > n1:
return gcd(n2,n1)
if n2 == 0:
return n1
return gcd(n2,n1%n2)
def main():
n,m = map(int,input().split())
if m < n-1:
print('Impossible')
return
ans = []
for i in range(1,n):
j = 2
curr = set()
while i*j <= n:
curr.add(i*j)
j += 1
if i == 1:
for j in curr:
ans.append((i,j))
if len(ans) == m:
break
else:
for j in range(i+1,n+1):
if (j not in curr) and gcd(i,j) == 1:
ans.append((i,j))
if len(ans) == m:
break
if len(ans) == m:
break
if len(ans) != m:
print('Impossible')
return
print('Possible')
for i in ans:
print(i[0],i[1])
main()
``` | output | 1 | 11,623 | 13 | 23,247 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.