input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
ABC = [list(map(int, input().split())) for i in range(n)]
# i日目にjを選択した後の幸福度 dp[i][j]
dp = [[0 for j in range(3)] for i in range(n + 1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + ABC[i][k])
print((max(dp[-1])))
| import sys
def input():
return sys.stdin.readline().strip()
n = int(eval(input()))
ABC = [list(map(int, input().split())) for i in range(n)]
# i日目にjを選択した後の幸福度 dp[i][j]
dp = [[0 for j in range(3)] for i in range(n + 1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + ABC[i][k])
print((max(dp[-1])))
| p03162 |
n = int(eval(input()))
dp = list(list(map(int, input().split())) for _ in range(n))
for i in range(1, n):
dp[i][0] += max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] += max(dp[i - 1][2], dp[i - 1][0]);
dp[i][2] += max(dp[i - 1][0], dp[i - 1][1]);
print((max(dp[n - 1])))
| import sys
readline = sys.stdin.readline
n = int(eval(input()))
dp = list(list(map(int, readline().split())) for _ in range(n))
for i in range(1, n):
dp[i][0] += max(dp[i - 1][1], dp[i - 1][2]);
dp[i][1] += max(dp[i - 1][2], dp[i - 1][0]);
dp[i][2] += max(dp[i - 1][0], dp[i - 1][1]);
print((max(dp[n - 1])))
| p03162 |
def MAP(): return list(map(int,input().split()))
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
MOD = 10**9+7
n = INT()
a = [MAP() for _ in range(n)]
dp = [[0,0,0] for _ in range(n+1)]
for i in range(n):
for j in range(3):
for k in range(3):
if j==k:
continue
dp[i+1][k] = max(dp[i+1][k],dp[i][j]+a[i][k])
print((max(dp[n]))) | n = int(eval(input()))
dp = [[0]*3 for i in range(n+1)]
a = []
for i in range(n):
a.append(list(map(int,input().split())))
for i in range(n):
for j in range(3):
for k in range(3):
if j==k:
continue
dp[i+1][j] = max(dp[i+1][j],dp[i][k] + a[i][j])
print((max(dp[n])))
| p03162 |
n=int(eval(input()))
al=[0]+[list(map(int,input().split())) for _ in range(n)]
dp=[[0,0,0] for _ in range(n+1)]
for day in range(1,n+1):
for i in range(3):
for j in range(3):
if i==j:continue
dp[day][i]=max(dp[day-1][j]+al[day][i],dp[day][i])
print((max(dp[-1]))) | import sys
input=sys.stdin.readline
n=int(eval(input()))
l=[[float("INF")]*3 for i in range(n)]
l[0]=list(map(int,input().split()))
for day in range(1,n):
f=list(map(int,input().split()))
for choice in range(3):
l[day][choice]=max(l[day-1][j]+f[choice] for j in range(3) if j!=choice)
print((max(l[-1]))) | p03162 |
#import sys
#input = sys.stdin.readline
n = int(eval(input()))
abc = []
for i in range(n):
abc.append([int(i) for i in input().split()])
dp = [[float("inf") for i in range(3)] for i in range(n)]
dp[0] = abc[0]
for i in range(n-1):
dp[i+1][0] = abc[i+1][0] + max(dp[i][1], dp[i][2])
dp[i+1][1] = abc[i+1][1] + max(dp[i][0], dp[i][2])
dp[i+1][2] = abc[i+1][2] + max(dp[i][0], dp[i][1])
print((max(dp[-1])))
| #import sys
#input = sys.stdin.readline
n = int(eval(input()))
for i in range(n):
if i == 0:
dp = [int(i) for i in input().split()]
else:
abc = [int(i) for i in input().split()]
dp[0], dp[1], dp[2] = abc[0] + max(dp[1], dp[2]), abc[1] + max(dp[0], dp[2]), abc[2] + max(dp[0], dp[1])
print((max(dp)))
| p03162 |
N=int(eval(input()))
act=[]
for i in range(N):
act.append(list(map(int,input().split())))
dp=[[0]*3 for i in range(N+1)]
for i in range(1,N+1):
for j in range(3):
for k in range(3):
if(j!=k):
dp[i][j]=max(dp[i][j],dp[i-1][k]+act[i-1][j])
print((max([dp[N][0],dp[N][1],dp[N][2]]))) | N=int(eval(input()))
dp=[[0,0,0] for i in range(N+1)]
for i in range(1,N+1):
a,b,c=list(map(int,input().split()))
dp[i][0]=max(dp[i-1][1]+a,dp[i-1][2]+a)
dp[i][1]=max(dp[i-1][0]+b,dp[i-1][2]+b)
dp[i][2]=max(dp[i-1][0]+c,dp[i-1][1]+c)
print((max(dp[N]))) | p03162 |
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
abc = [0] * N
for i in range(N):
abc[i] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(N)]
dp[0] = abc[0]
for i, (a, b, c) in enumerate(abc[1:], start=1):
dp[i][0] = max(dp[i - 1][1], dp[i - 1][2]) + a
dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + b
dp[i][2] = max(dp[i - 1][0], dp[i - 1][1]) + c
ans = max(dp[-1])
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
abc = [0] * N
for i in range(N):
abc[i] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(N)]
dp[0] = abc[0]
for i, (a, b, c) in enumerate(abc[1:], start=1):
dp_i = dp[i]
dp_im = dp[i - 1]
dp_i[0] = max(dp_im[1], dp_im[2]) + a
dp_i[1] = max(dp_im[0], dp_im[2]) + b
dp_i[2] = max(dp_im[0], dp_im[1]) + c
ans = max(dp[-1])
print(ans)
if __name__ == "__main__":
main()
| p03162 |
N=int(eval(input()))
dp=[[0 for i in range(3)] for j in range(N+1)]
for i in range(N):
a,b,c=list(map(int,input().split()))
dp[i+1][0]=max(dp[i][1]+a,dp[i][2]+a)
dp[i+1][1]=max(dp[i][0]+b,dp[i][2]+b)
dp[i+1][2]=max(dp[i][1]+c,dp[i][0]+c)
print((max(dp[N])))
| import sys
readline = sys.stdin.readline
N = int(readline())
dp = [[0] * 3 for i in range(N + 1)]
for i in range(N):
a,b,c = list(map(int,readline().split()))
dp[i + 1][0] = max(dp[i][1],dp[i][2]) + a
dp[i + 1][1] = max(dp[i][2],dp[i][0]) + b
dp[i + 1][2] = max(dp[i][0],dp[i][1]) + c
print((max(dp[N]))) | p03162 |
n=int(eval(input()))
a=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*3 for i in range(n)]
dp[0][0]=a[0][0]
dp[0][1]=a[0][1]
dp[0][2]=a[0][2]
for i in range(1,n):
dp[i][0]=a[i][0]+max(dp[i-1][1],dp[i-1][2])
dp[i][1]=a[i][1]+max(dp[i-1][0],dp[i-1][2])
dp[i][2]=a[i][2]+max(dp[i-1][1],dp[i-1][0])
print((max(dp[n-1]))) | n=int(eval(input()))
dp=[[0]*3 for _ in range(n)]
dp[0]=list(map(int,input().split()))
for i in range(1,n):
l=list(map(int,input().split()))
dp[i][0]=l[0]+max(dp[i-1][1],dp[i-1][2])
dp[i][1]=l[1]+max(dp[i-1][0],dp[i-1][2])
dp[i][2]=l[2]+max(dp[i-1][0],dp[i-1][1])
print((max(dp[-1]))) | p03162 |
n=int(eval(input()))
a=[0]*n
b=[0]*n
c=[0]*n
for i in range(n):
a[i],b[i],c[i]=list(map(int,input().split()))
dp=[[0,0,0] for _ in range(n+1)]
for i in range(1,n+1):
dp[i][0] = max(dp[i-1][1],dp[i-1][2])+a[i-1]
dp[i][1] = max(dp[i-1][0],dp[i-1][2])+b[i-1]
dp[i][2] = max(dp[i-1][0],dp[i-1][1])+c[i-1]
print((max(dp[n]))) | n=int(eval(input()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*3 for _ in range(n)]
dp[0]=l[0]
for i in range(n-1):
for j in range(3):
dp[i+1][j]=max(dp[i][(j+1)%3],dp[i][(j+2)%3])+l[i+1][j]
print((max(dp[n-1]))) | p03162 |
from pprint import pprint
n=int(eval(input()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*3 for _ in range(n)]
dp[0]=l[0]
for i in range(1,n):
for j in range(3):
dp[i][j]=max(dp[i-1][(j+1)%3]+l[i][j],dp[i-1][(j+2)%3]+l[i][j])
print((max(dp[n-1])))
# pprint(dp) | n=int(eval(input()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*3 for _ in range(n)]
dp[0]=l[0]
for i in range(n-1):
for j in range(3):
dp[i+1][j]=max(dp[i][(j+1)%3]+l[i+1][j],dp[i][(j+2)%3]+l[i+1][j])
print((max(dp[n-1]))) | p03162 |
N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in range(N)]
dp = [[0 for i in range(3)] for j in range(N)]
dp[0][0]= ABC[0][0]
dp[0][1]= ABC[0][1]
dp[0][2]= ABC[0][2]
for i in range(1,N):
for toi in range(3):
s = 0
for fromi in range(3):
if toi==fromi:
continue
s = max(s, dp[i-1][fromi] + ABC[i][toi])
dp[i][toi] = s
print((max(dp[-1]))) | N = int(eval(input()))
ABC = [list(map(int,input().split())) for _ in range(N)]
dp = [[0 for i in range(3)] for j in range(N)]
# 1日目の初期化
dp[0]= ABC[0]
for i in range(1,N):
# 次ステップでA,B,Cに行く場合、
for toi in range(3):
s = 0
# どこから来るのが最大か求める
for fromi in range(3):
# 同じ行動はとらない
if toi==fromi:
continue
s = max(s, dp[i-1][fromi] + ABC[i][toi])
dp[i][toi] = s
print((max(dp[-1]))) | p03162 |
N=int(eval(input()))
p=list(map(int,input().split()))
for i in range(1,N):
add=list(map(int,input().split()))
temp=[[] for j in range(3)]
for j in range(3):
pnt=p[j]
for k in range(3):
if j==k:continue
else:
temp[k].append(pnt+add[k])
for j in range(3):
p[j]=max(temp[j])
print((max(p))) | N=int(eval(input()))
p=list(map(int,input().split()))
for i in range(1,N):
add=list(map(int,input().split()))
p0=p[0]
p1=p[1]
p2=p[2]
p[0]=max(add[0]+p1,add[0]+p2)
p[1]=max(add[1]+p2,add[1]+p0)
p[2]=max(add[2]+p0,add[2]+p1)
print((max(p)))
| p03162 |
n = int(eval(input()))
a, b, c = [0] * n, [0] * n, [0] * n
for i in range(n):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[0] * 3 for _ in range(n)]
dp[-1] = [a[-1], b[-1], c[-1]]
for i in range(n - 2, -1, -1):
dp[i][0] = a[i] + max(dp[i + 1][1], dp[i + 1][2])
dp[i][1] = b[i] + max(dp[i + 1][2], dp[i + 1][0])
dp[i][2] = c[i] + max(dp[i + 1][0], dp[i + 1][1])
print((max(dp[0]))) | n = int(eval(input()))
a, b, c = [0] * n, [0] * n, [0] * n
for i in range(n):
a[i], b[i], c[i] = list(map(int, input().split()))
dp = [[0] * n for _ in range(3)]
dp[0][-1], dp[1][-1], dp[2][-1] = a[-1], b[-1], c[-1]
for i in range(n - 2, -1, -1):
dp[0][i] = a[i] + max(dp[1][i + 1], dp[2][i + 1])
dp[1][i] = b[i] + max(dp[2][i + 1], dp[0][i + 1])
dp[2][i] = c[i] + max(dp[0][i + 1], dp[1][i + 1])
print((max(dp[0][0], dp[1][0], dp[2][0])))
| p03162 |
n = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(n)]
def chmax(a, b):
if a > b:
return a
else:
return b
dp = [[ 0 for _ in range(3)]for _ in range(n+10)]
for i in range(3):
dp[0][i] = A[0][i]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = chmax(dp[i][k], dp[i-1][j]+A[i][k])
print((max(dp[n-1]))) | n = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(n)]
dp = [[ 0 for _ in range(3)]for _ in range(n+10)]
for i in range(3):
dp[0][i] = A[0][i]
for i in range(1, n):
for j in range(3):
for k in range(3):
if j != k:
dp[i][k] = max(dp[i][k], dp[i-1][j]+A[i][k])
print((max(dp[n-1]))) | p03162 |
n = int(eval(input()))
A = [[int(i) for i in input().split()] for i in range(n)]
dp = [0, 0, 0]
for i in range(n):
dp = [A[i][0] + max(dp[1], dp[2]), A[i][1] + max(dp[0], dp[2]), A[i][2] + max(dp[0], dp[1])]
print((max(dp))) | n = int(eval(input()))
dp = [int(i) for i in input().split()]
for i in range(n-1):
a, b, c = list(map(int, input().split()))
dp = [max(dp[1], dp[2]) + a, max(dp[0], dp[2]) + b, max(dp[0], dp[1]) + c]
print((max(dp))) | p03162 |
from sys import stdin
import math
import fractions
from collections import deque
INF = 10 ** 10
N = int(stdin.readline().rstrip())
abc = [list(map(int, stdin.readline().rstrip().split())) for _ in range(N)]
# add dummy
abc = abc + [[-INF, -INF, -INF]]
# i日目に(0, 1, 2):=(a, b, c)の行動を行った時の幸福度の最大値
dp = [[-INF] * 3 for _ in range(N+10)]
a, b, c = abc[0]
dp[0][0] = a
dp[0][1] = b
dp[0][2] = c
for i in range(N):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][j] = max(dp[i+1][j], dp[i][k]+abc[i+1][j])
print((max(dp[N-1])))
| from sys import stdin
import math
import fractions
from collections import deque
INF = 10 ** 10
N = int(stdin.readline().rstrip())
abc = [list(map(int, stdin.readline().rstrip().split())) for _ in range(N)]
# i日目に(0, 1, 2):=(a, b, c)の行動を行った時の幸福度の最大値
dp = [[-INF] * 3 for _ in range(N+10)]
a, b, c = abc[0]
dp[0][0] = a
dp[0][1] = b
dp[0][2] = c
for i in range(N-1):
for j in range(3):
for k in range(3):
if j == k:
continue
dp[i+1][j] = max(dp[i+1][j], dp[i][k]+abc[i+1][j])
print((max(dp[N-1])))
| p03162 |
N = int(eval(input()))
L = []
for i in range(N):
l = list(map(int,input().split()))
L.append(l)
dp = [[0,0,0] for i in range(N)]
dp[0] = [L[0][0],L[0][1],L[0][2]]
for i in range(1,N):
for j in range(3):
dp[i][j] = max(dp[i - 1][(j + 1) % 3],dp[i - 1][(j + 2) % 3]) + L[i][j]
print((max(dp[N - 1]))) | N = int(eval(input()))
L = [list(map(int,input().split())) for i in range(N)]
dp = [[0,0,0] for i in range(N)]
dp[0] = L[0]
for i in range(1,N):
for j in range(3):
dp[i][j] = max(dp[i - 1][(j + 1) % 3],dp[i - 1][(j + 2) % 3]) + L[i][j]
print((max(dp[-1]))) | p03162 |
N=int(eval(input()))
dp=[[0 for i in range(N+1)] for i in range(3)]
for j in range(N):
abc=list(map(int,input().split()))
for i in range(3):
if j==0:
dp[i][j]=abc[i]
else:
dp[i][j]=max([dp[k][j-1]+abc[i] for k in range(3) if k!=i])
print((max([dp[i][N-1] for i in range(3)]))) | N = int(eval(input()))
dp = list(map(int, input().split()))
for i in range(1, N):
a, b, c = list(map(int, input().split()))
newDP = [0] * 3
newDP[0] = max(dp[1], dp[2]) + a
newDP[1] = max(dp[0], dp[2]) + b
newDP[2] = max(dp[0], dp[1]) + c
dp = newDP[::]
ans = max(dp)
print(ans)
| p03162 |
N = int(eval(input()))
A, B, C = [], [], []
for n in range(N):
a, b, c = list(map(int, input().split()))
A.append(a)
B.append(b)
C.append(c)
a, b, c = 0, 0, 0
for n in range(N):
a, b, c = A[n] + max(b, c), B[n] + max(c, a), C[n] + max(a, b)
print((max(a, b, c)))
| N = int(eval(input()))
a, b, c = 0, 0, 0
for n in range(N):
an, bn, cn = list(map(int, input().split()))
a, b, c = an + max(b, c), bn + max(c, a), cn + max(a, b)
print((max(a, b, c)))
| p03162 |
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: list(map(int,input().split()))
alele = lambda: list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
#def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7
def Y(c): print((["NO","YES"][c]))
def y(c): print((["no","yes"][c]))
def Yy(c): print((["No","Yes"][c]))
x,y,z = 0,0,0
for _ in range(int(eval(input()))):
a,b,c = ilele()
if x == y == z == 0:
x,y,z = a,b,c
else:
d = a + max(y,z)
e = b + max(x,z)
f = c + max(x,y)
x,y,z = d,e,f
print((max(x,y,z)))
| import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: list(map(int,input().split()))
alele = lambda: list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
#def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
MOD = 1000000000 + 7
def Y(c): print((["NO","YES"][c]))
def y(c): print((["no","yes"][c]))
def Yy(c): print((["No","Yes"][c]))
x,y,z = 0,0,0
for _ in range(int(eval(input()))):
a,b,c = ilele()
d = a + max(y,z)
e = b + max(x,z)
f = c + max(x,y)
x,y,z = d,e,f
print((max(x,y,z)))
| p03162 |
"""
解説PDFを見ながら実装
https://img.atcoder.jp/abc075/editorial.pdf
"""
def dfs(v, graph, visited, n):
# 出発点
visited[v] = True
for i in range(n):
# 辺がない
if graph[v][i] == False:
continue
# 訪問済み
if visited[i] == True:
continue
# 辺があったらそこから訪問する
dfs(i, graph, visited, n)
def main():
N, M = list(map(int, input().split()))
graph = []
for _ in range(N):
row = [False] * N
graph.append(row)
A = []
B = []
for _ in range(M):
a, b = list(map(int, input().split()))
a = a - 1
b = b - 1
A.append(a)
B.append(b)
graph[a][b] = True
graph[b][a] = True
# print(graph)
ans = 0
for i in range(M):
# 辺を削除
graph[A[i]][B[i]] = False
graph[B[i]][A[i]] = False
visited = [False] * N
# 常に0番目の頂点から出発
dfs(0, graph, visited, N)
bridge = False
for j in range(N):
if visited[j] == False:
bridge = True
if bridge:
ans += 1
# 辺を戻す
graph[A[i]][B[i]] = True
graph[B[i]][A[i]] = True
print(ans)
if __name__ == "__main__":
main() |
def main():
N, M = list(map(int, input().split()))
AB = []
for _ in range(M):
a, b = list(map(int, input().split()))
AB.append([a-1, b-1])
# グラフを表現する（辺のある・なし）
graph = []
for _ in range(N):
graph.append([False] * N)
for a, b in AB:
graph[a][b] = True
graph[b][a] = True
visited = [False] * N
def dfs(v):
"""v（頂点）からスタートする"""
# 到達済みだったらreturn
if visited[v]:
return
# 到達した印
visited[v] = True
# そのさきへ（vと繋がっている）
edges = graph[v]
for i, e in enumerate(edges):
if e:
dfs(i)
return
ans = 0
# 辺を一つずつ消してみて、橋かどうかを調べる
for a, b in AB:
graph[a][b] = False
graph[b][a] = False
visited = [False] * N
dfs(0)
# 全てTrueというわけではない（Falseが一つでもある場合）
if not all(visited):
ans += 1
graph[a][b] = True
graph[b][a] = True
print(ans)
if __name__ == "__main__":
main() | p03575 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)
N, M = LI()
A, B = [], []
for i in range(M):
a, b = LI()
A.append(a)
B.append(b)
"""
頂点ごとにみる。
その頂点につながっている辺を洗い出す
洗い出した辺の頂点同士がつながっているか確認する
最終的に自分のもとに戻ってこれるか。
dfsで全経路を洗い出す
1とそれ以外が全部つながるか。
2とそれ以外が全部つながるかを調査すればよい
"""
def dfs(reached_nodes, lines):
print('df', reached_nodes, lines, file=sys.stderr)
# 最初に与えられた線からたどっていって、すべての線を洗い出す。すべての頂点が入っていればおK
# このノードにつながっている辺をみつける
for line in lines:
if line[0] in reached_nodes or line[1] in reached_nodes:
# 既に到達しているnodeに入っている場合
new_lines = [l for l in lines if l != line]
if not dfs(reached_nodes + line, new_lines):
# 全部つながることが確認された場合
return False
else:
# 一回もひかからなかったので終了
print('r', reached_nodes, file=sys.stderr)
if len(set(reached_nodes)) < N:
print('True', file=sys.stderr)
# 無理でした。
return True
else:
return False
ans = 0
for idx in range(N):
# idx番目の線をなくす
lines = []
for m in range(M):
if m == idx:
continue
else:
lines.append([A[m], B[m]])
print(idx, lines, file=sys.stderr)
# 各頂点が全頂点とつながっているか確認
# ただたんに全頂点が入っているだけでは断絶の可能性があるので不十分
if dfs(lines[0][:1], lines):
ans += 1
print(ans)
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)
N, M = LI()
A, B = [], []
for i in range(M):
a, b = LI()
A.append(a)
B.append(b)
"""
頂点ごとにみる。
その頂点につながっている辺を洗い出す
洗い出した辺の頂点同士がつながっているか確認する
最終的に自分のもとに戻ってこれるか。
dfsで全経路を洗い出す
1とそれ以外が全部つながるか。
2とそれ以外が全部つながるかを調査すればよい
"""
# def dfs(reached_nodes, lines):
# print('df', reached_nodes, lines, file=sys.stderr)
# # 最初に与えられた線からたどっていって、すべての線を洗い出す。すべての頂点が入っていればおK
# # このノードにつながっている辺をみつける
# for line in lines:
# if line[0] in reached_nodes or line[1] in reached_nodes:
# # 既に到達しているnodeに入っている場合
# new_lines = [l for l in lines if l != line]
# if not dfs(reached_nodes + line, new_lines):
# # 全部つながることが確認された場合
# return False
# else:
# # 一回もひかからなかったので終了
# print('r', reached_nodes, file=sys.stderr)
# if len(set(reached_nodes)) < N:
# print('True', file=sys.stderr)
# # 無理でした。
# return True
# else:
# return False
def dfs(visited_nodes, lines):
print(visited_nodes, file=sys.stderr)
if len(set(visited_nodes)) == N:
print('False',file=sys.stderr)
return False
# 現在のノード
for l in lines:
if l[0] in visited_nodes or l[1] in visited_nodes:
if not (l[0] in visited_nodes and l[1] in visited_nodes):
return dfs(visited_nodes + l, lines)
else:
# 全部見たけどなかった。橋なのでTrue
print('True', file=sys.stderr)
return True
ans = 0
for idx in range(M):
# idx番目の線をなくす
lines = []
for m in range(M):
if m == idx:
continue
else:
lines.append([A[m], B[m]])
print('idx, lines', idx, lines, file=sys.stderr)
# 各頂点が全頂点とつながっているか確認
# ただたんに全頂点が入っているだけでは断絶の可能性があるので不十分
# if dfs(lines[0][:1], lines):
if len(lines) == 0:
print(1)
exit()
if dfs(lines[0], lines):
ans += 1
print(ans)
| p03575 |
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
def dfs(x):
for i in tree[x]:
if al[i]<0:
al[i]=0
dfs(i)
n,m=MI()
lis=[LI() for i in range(m)]
#print(lis)
cou=0
for i in range(m):
tree=[[] for i in range(n)]
for j in range(m):
if i!=j:
tree[lis[j][0]-1].append(lis[j][1]-1)
tree[lis[j][1]-1].append(lis[j][0]-1)
count=0
for k in range(n):
al=[-1]*n
al[k]=0
dfs(k)
#print(al)
if sum(al)==0:
count+=1
if count!=n:
cou+=1
print(cou) | #dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
def dfs(x):
for i in tree[x]:
if al[i]<0:
al[i]=0
dfs(i)
n,m=MI()
lis=[LI() for i in range(m)]
#print(lis)
cou=0
for i in range(m):
tree=[[] for i in range(n)]
for j in range(m):
if i!=j:
tree[lis[j][0]-1].append(lis[j][1]-1)
tree[lis[j][1]-1].append(lis[j][0]-1)
count=0
for k in range(n):
al=[-1]*n
al[k]=0
dfs(k)
#print(al)
if not -1 in al:
count+=1
if count!=n:
cou+=1
print(cou) | p03575 |
#dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
def dfs(x):
for i in tree[x]:
if al[i]<0:
al[i]=0
dfs(i)
n,m=MI()
lis=[LI() for i in range(m)]
#print(lis)
cou=0
for i in range(m):
tree=[[] for i in range(n)]
for j in range(m):
if i!=j:
tree[lis[j][0]-1].append(lis[j][1]-1)
tree[lis[j][1]-1].append(lis[j][0]-1)
count=0
for k in range(n):
al=[-1]*n
al[k]=0
dfs(k)
#print(al)
if not -1 in al:
count+=1
if count!=n:
cou+=1
print(cou) | #dpでできないかな？
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
def dfs(x,tree,al):
for i in tree[x]:
if al[i]<0:
al[i]=0
dfs(i,tree,al)
def main():
n,m=MI()
lis=[LI() for i in range(m)]
#print(lis)
cou=0
for i in range(m):
tree=[[] for i in range(n)]
for j in range(m):
if i!=j:
tree[lis[j][0]-1].append(lis[j][1]-1)
tree[lis[j][1]-1].append(lis[j][0]-1)
count=0
for k in range(n):
al=[-1]*n
al[k]=0
dfs(k,tree,al)
#print(al)
if not -1 in al:
count+=1
if count!=n:
cou+=1
print(cou)
if __name__ == '__main__':
main() | p03575 |
N, M = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(M)]
graph = [[0] * N for _ in range(N)]
for a, b in edges:
graph[a - 1][b - 1] = 1
graph[b - 1][a - 1] = 1
def dfs(v):
visited[v] = 1
for v2 in range(N):
if graph[v][v2]==0 or visited[v2]==1:#vとv2が隣接していない or すでに訪れている場合
continue
dfs(v2)#隣接していて、まだ訪れていない場合
ans = 0
for a, b in edges:
graph[a - 1][b - 1] = 0
graph[b - 1][a - 1] = 0
visited = [0] * N
dfs(0)
bridge = 0
if sum(visited) < N :
bridge = 1
ans+=1
graph[a - 1][b - 1] = 1
graph[b - 1][a - 1] = 1
print(ans) | N,M=list(map(int,input().split()))
ab=list(list(map(int,input().split())) for _ in range(M))
graph=list([0]*N for _ in range(N))
ans=0
for a,b in ab:
graph[a - 1][b - 1] = 1
graph[b - 1][a - 1] = 1
def dfs(s):
visited[s]=1
for i in range(N):
if graph[s][i] == 0 or visited[i] == 1:
continue
dfs(i)
for a,b in ab:
graph[a - 1][b - 1] = 0
graph[b - 1][a - 1] = 0
visited=[0]*N
dfs(0)
graph[a - 1][b - 1] = 1
graph[b - 1][a - 1] = 1
if sum(visited)<N:
ans+=1
print(ans) | p03575 |
N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
cnt = 0
for i in range(M):
par = list(range(N + 1))
rank = [0] * (N + 1)
for j, (u, v) in enumerate(X):
if i == j:
continue
unite(u, v)
res = True
for j in range(1, N + 1):
for k in range(1, N + 1):
res &= find(j) == find(k)
cnt += int(not res)
print(cnt)
| N, M = list(map(int, input().split()))
X = [list(map(int, input().split())) for _ in range(M)]
graph = [[False] * N for _ in range(N)]
for a, b in X:
graph[a - 1][b - 1] = True
graph[b - 1][a - 1] = True
def dfs(u):
visited[u] = True
for v in range(N):
if visited[v] or not graph[u][v]:
continue
dfs(v)
res = 0
for i in range(M):
a, b = X[i]
a -= 1
b -= 1
graph[a][b] = False
graph[b][a] = False
visited = [False] * N
dfs(0)
res += int(not all(visited))
graph[a][b] = True
graph[b][a] = True
print(res)
| p03575 |
import sys
input=sys.stdin.readline
import math
def get_edges_include_node(i, Edges): # 頂点 i を含む辺のリストを返す
es = []
for e in Edges:
if i in e:
es.append(e)
return es
def dfs(i, e0, goal, Edges): # 頂点 i から頂点 j にたどり着けるかどうか
if e0 in Edges:
Edges.remove(e0)
for e1 in get_edges_include_node(i, Edges):
if goal in e1:
return True
else:
ni = e1[1] if e1[0] == i else e1[0]
if dfs(ni, e1, goal, Edges):
return True
return False
def main():
N,M = list(map(int, input().split()))
Edges = []
for _ in range(M):
a,b = list(map(int, input().split()))
Edges.append((a,b))
ans = 0
for e in Edges:
tmp = []
for e2 in Edges:
tmp.append((e2[0], e2[1]))
if not dfs(e[0], e, e[1], tmp):
ans += 1
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def main():
N, M = list(map(int, input().split()))
E = []
for i in range(M):
a, b = list(map(int, input().split()))
E.append((a-1, b-1))
ans = 0
# i 番目の辺を取り除いても、全ての頂点が連結しているか？
# Union-Find で連結グラフか判定する
for i in range(M):
uf = UnionFind(N) # 最初、全ての頂点が非連結の状態
for j in range(M):
if i == j:
pass # i 番目の辺を無視する
else:
# 要素が同じ集合にある＝頂点が連結している
uf.union(E[j][0], E[j][1])
# グラフ全体が連結なら、任意の頂点を含む集合のサイズが N のはず
if uf.size(0) != N:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03575 |
# ABC075C - Bridge
# find the number of bridges in a given undirected connected graph
# bridge := an edge whose removal disconnects a graph
import sys
from copy import deepcopy
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
def dfs(v: int) -> None:
seen[v] = 1 # make vertex v searched
for u in g[v]:
if not seen[u]:
dfs(u)
def main(): # O(M(N + M))
global g, seen
N, M = tuple(map(int, input().split()))
E = tuple(tuple(map(int, input().split())) for _ in range(M))
G = [[] for _ in range(N + 1)] # N+1: 1-idx
for v, u in E: # construct a undirected graph
G[v] += [u]
G[u] += [v]
bridges = 0
for v, u in E:
g = deepcopy(G) # subgraph of G except E(v, u)
g[v].remove(u)
g[u].remove(v)
seen = [0] * (N + 1)
dfs(1) # search from vertex 1
bridges += 1 if 0 in seen[1:] else 0
print(bridges)
if __name__ == "__main__":
main() | # ABC075C - Bridge
# find the number of bridges in a given undirected connected graph
# bridge := an edge whose removal disconnects a graph
def dfs(start: int) -> None:
seen[start] = 1 # make vertex v searched
stack = [start]
while stack:
v = stack.pop()
for u in g[v]:
if not seen[u]:
seen[u] = 1
stack.append(u)
def main(): # O(M(N + M))
global g, seen
N, M, *E = list(map(int, open(0).read().split()))
G = [[] for _ in range(N + 1)]
for v, u in zip(*[iter(E)] * 2):
G[v].append(u), G[u].append(v)
bridges = 0
for v, u in zip(*[iter(E)] * 2):
g = [v.copy() for v in G] # subgraph of G except E(v, u)
g[v].remove(u), g[u].remove(v)
seen = [0] * (N + 1)
dfs(1) # search from vertex 1
bridges += 1 if 0 in seen[1:] else 0
print(bridges)
if __name__ == "__main__":
main() | p03575 |
from collections import deque
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
def make_dict(x,y):
for i in ll:
if i[x] in list(d.keys()):
d[i[x]]+=[i[y]]
else:
d[i[x]]=[i[y]]
cnt=0
for i in range(m):
ll=l[:i]+l[i+1:]
# print(ll)
d={}
make_dict(0,1)
make_dict(1,0)
# print(d)
k_l=list(d.keys())
v_l=list(d.values())
# print(k_l)
x=0
sk=k_l[x]
dq=deque()
dq.append(sk)
# while dq:
# print(dq)
# x=0
seen=[]
while dq:
# while n<10:
k=dq.pop()
k_ll=d[k]
seen.append(k)
# print(k_ll)
for i in k_ll:
if i not in seen:
dq.append(i)
# d=d.pop(sk)
# print(dq)
x+=1
# print(set(seen),len(set(seen)))
if len(set(seen))!=n:
cnt+=1
print(cnt) | from collections import deque
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
def make_dict(x,y):
for i in ll:
if i[x] in list(d.keys()):
d[i[x]]+=[i[y]]
else:
d[i[x]]=[i[y]]
cnt=0
for i in range(m):
ll=l[:i]+l[i+1:]
d={}
make_dict(0,1)
make_dict(1,0)
k_l=list(d.keys())
x=0
sk=k_l[x]
dq=deque()
dq.append(sk)
seen=[]
while dq:
k=dq.pop()
k_ll=d[k]
seen.append(k)
for i in k_ll:
if i not in seen:
dq.append(i)
x+=1
if len(set(seen))!=n:
cnt+=1
print(cnt) | p03575 |
from collections import deque
from copy import deepcopy
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
def BFS(m):
t_l=deepcopy(l)
del t_l[m]
tree=[[] for j in range(n)]
for a,b in t_l:
a-=1
b-=1
tree[a].append(b)
tree[b].append(a)
dist=[-1 for i in range(n)]
dist[0]=0
que=deque()
que.append(0)
while que:
x=que.popleft()
for i in tree[x]:
if dist[i]==-1:
que.append(i)
dist[i]=dist[x]+1
global ans
if -1 in dist:
ans+=1
ans=0
for i in range(m):
BFS(i)
print(ans) | from collections import deque
from copy import deepcopy
n,m=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]
def DFS(m):
t_l=deepcopy(l)
del t_l[m]
tree=[[] for j in range(n)]
for a,b in t_l:
a-=1
b-=1
tree[a].append(b)
tree[b].append(a)
seen=set()
seen.add(0)
dq=deque()
dq.append(0)
while dq:
x=dq.pop()
for i in tree[x]:
if i not in seen:
dq.append(i)
seen.add(i)
return seen
ans=0
for i in range(m):
st=DFS(i)
if len(st)!=n:
ans+=1
print(ans) | p03575 |
def wf(this_graf):
s = len(graf)
for k in range(s):
for i in range(s):
for j in range(s):
this_graf[i][j] = min(this_graf[i][j], this_graf[i][k] + this_graf[k][j])
return this_graf
n, m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(m)]
graf = [[10 ** 10 for i in range(n)] for j in range(n)]
for i, j in ab:
graf[i - 1][j - 1] = 1
graf[j - 1][i - 1] = 1
import copy
cnt = 0
for i, j in ab:
this_graf = copy.deepcopy(graf)
tmp = 0
this_graf[i - 1][j - 1] = 10 ** 10
this_graf[j - 1][i - 1] = 10 ** 10
this_graf = wf(this_graf)
for i in range(n):
for j in range(n):
if this_graf[i][j] == 10 ** 10:
tmp = 1
break
if tmp:
break
cnt += tmp
print(cnt) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def sample():
uf = UnionFind(6)
print(uf.parents)
uf.union(0, 2)
print(uf.parents)
uf.union(1, 3)
print(uf.parents)
uf.union(4, 5)
print(uf.parents)
def atc001():
n, q = map(int, input().split())
uf = UnionFind(n)
for i in range(q):
p, a, b = map(int, input().split())
if p == 0:
uf.union(a, b)
else:
if uf.same(a, b):
print("Yes")
else:
print("No")
def abc049():
n, k, l = map(int, input().split())
road = UnionFind(n)
train = UnionFind(n)
for i in range(k):
p, q = map(int, input().split())
road.union(p - 1, q - 1)
for i in range(l):
p, q = map(int, input().split())
train.union(p - 1, q - 1)
pair = []
pair_cnt = {}
for i in range(n):
t, r = road.find(i), train.find(i)
pair.append([t, r])
key = t * (10 ** 6) + r
if key in pair_cnt:
pair_cnt[key] += 1
else:
pair_cnt[key] = 1
for i in range(n):
[t, r] = pair[i]
key = t * (10 ** 6) + r
print(pair_cnt[key], end = " ")
def arc097():
n, m = map(int, input().split())
p = list(map(int, input().split()))
pair = UnionFind(n)
for i in range(m):
x, y = map(int, input().split())
pair.union(x - 1, y - 1)
cnt = 0
for i in range(n):
if pair.same(i, p[i] - 1):
cnt += 1
print(cnt)
def arc032():
n, m = map(int, input().split())
road = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
road.union(a - 1, b - 1)
print(road.group_count() - 1)
def abc075():
n, m = map(int, input().split())
input_list = [list(map(int, input().split())) for _ in range(m)]
cnt = 0
for i in range(m):
road = UnionFind(n)
for j in range(m):
p1 = input_list[j][0] - 1
p2 = input_list[j][1] - 1
if i != j:
road.union(p1, p2)
if road.group_count() >= 2:
cnt += 1
print(cnt)
abc075()
| p03575 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
class UnionFind:
def __init__(self,n):
self.par = [i for i in range(n+1)] # 親のノード番号
self.rank = [0]*(n+1)
def find(self,x): # xの根のノード番号
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self,x,y): # x,yが同じグループか否か
return self.find(x) == self.find(y)
def unite(self,x,y): # x,yの属するグループの併合
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
x,y = y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
N,M = MI()
edges = [tuple(MI()) for _ in range(M)]
ans = 0
for i in range(M):
U = UnionFind(N)
for j in range(M):
if j != i:
a,b = edges[j]
U.unite(a,b)
x,y = edges[i]
if not U.same_check(x,y):
ans += 1
print(ans)
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
class UnionFind:
def __init__(self,n):
self.par = [i for i in range(n+1)] # 親のノード番号
self.rank = [0]*(n+1)
def find(self,x): # xの根のノード番号
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def same_check(self,x,y): # x,yが同じグループか否か
return self.find(x) == self.find(y)
def unite(self,x,y): # x,yの属するグループの併合
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
x,y = y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
N,M = MI()
edges = [tuple(MI()) for _ in range(M)]
ans = 0
for i in range(M):
U = UnionFind(N)
for j in range(M):
if j != i:
a,b = edges[j]
U.unite(a,b)
x,y = edges[i]
if not U.same_check(x,y):
ans += 1
print(ans)
| p03575 |
import sys
import copy
readline = sys.stdin.readline
def dfs(p, x):
global graphtmp, check
to = graphtmp[x]
check[x] = 1
for t in to:
if p == t or check[t] == 1:
continue
dfs(x, t)
def main():
global graphtmp, check
N, M = list(map(int, readline().split()))
graph = [[] for _ in range(N)]
nodelist = []
for _ in range(M):
a, b = list(map(int, readline().split()))
a -= 1; b-= 1
nodelist.append([a, b])
graph[a].append(b)
graph[b].append(a)
ans = 0
for nodetmp in nodelist:
check = [0]*N
graphtmp = copy.deepcopy(graph)
graphtmp[nodetmp[0]].remove(nodetmp[1])
graphtmp[nodetmp[1]].remove(nodetmp[0])
dfs(-1, 0)
if 0 in check:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.rank = [0] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
else:
self.parents[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
N, M = list(map(int, readline().split()))
nodelist = []
for _ in range(M):
a, b = list(map(int, readline().split()))
a -= 1; b -= 1
nodelist.append([a, b])
ans = 0
for i in range(M):
uf = UnionFind(N)
for j, node in enumerate(nodelist):
if j == i:
continue
uf.union(node[0], node[1])
parent = []
for k in range(N):
parent.append(uf.find(k))
if len(set(parent)) > 1:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p03575 |
def warshall_floyd(d, n):
# d: 隣接行列(正方行列)
# n: 頂点数
# i -> j の最短距離を計算する
for k in range(n):
for i in range(n):
for j in range(n):
# i -> k -> j と頂点kを挟む
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
# -------------------------------------------------------------------#
import copy
def main():
# n: 頂点数
# w: 辺の数
n, w = list(map(int, input().split()))
# v -> v ; cost: 0
d = [[float("Inf")] * n for i in range(n)]
for i in range(n):
d[i][i] = 0
# d[u][v] : 辺u-vのコスト(if not: inf)
e = []
for i in range(w):
# edge: u -> v ; cost : z
u, v = [int(x) - 1 for x in input().split()]
e.append([u, v])
# 無向グラフを想定
d[u][v] = 1
d[v][u] = 1
ans = 0
for (u, v) in e:
dd = copy.deepcopy(d)
dd[u][v] = float("Inf")
dd[v][u] = float("Inf")
wd = warshall_floyd(dd, n)
for res in wd:
if float("Inf") in res:
ans += 1
break
print(ans)
if __name__ == "__main__":
main()
| import copy
def main():
# n: 頂点数
# w: 辺の数
n, w = list(map(int, input().split()))
# v -> v ; cost: 0
d = [[False] * n for i in range(n)]
# d[u][v] : 辺u-vのコスト(if not: inf)
e = []
for i in range(w):
# edge: u -> v ; cost : z
u, v = [int(x) - 1 for x in input().split()]
e.append([u, v])
# 無向グラフを想定
d[u][v] = True
d[v][u] = True
def dfs(graph, visited, x):
if visited[x]:
return
visited[x] = True
for i in range(n):
if graph[x][i]:
dfs(graph, visited, i)
ans = 0
for (u, v) in e:
graph = copy.deepcopy(d)
graph[u][v] = False
graph[v][u] = False
for i in range(n):
visited = [False for _ in range(n)]
dfs(graph, visited, i)
if not all(visited):
ans += 1
break
print(ans)
if __name__ == "__main__":
main()
| p03575 |
import copy
def main():
# n: 頂点数
# w: 辺の数
n, w = list(map(int, input().split()))
# v -> v ; cost: 0
d = [[False] * n for i in range(n)]
# d[u][v] : 辺u-vのコスト(if not: inf)
e = []
for i in range(w):
# edge: u -> v ; cost : z
u, v = [int(x) - 1 for x in input().split()]
e.append([u, v])
# 無向グラフを想定
d[u][v] = True
d[v][u] = True
def dfs(graph, visited, x):
if visited[x]:
return
visited[x] = True
for i in range(n):
if graph[x][i]:
dfs(graph, visited, i)
ans = 0
for (u, v) in e:
graph = copy.deepcopy(d)
graph[u][v] = False
graph[v][u] = False
for i in range(n):
visited = [False for _ in range(n)]
dfs(graph, visited, i)
if not all(visited):
ans += 1
break
print(ans)
if __name__ == "__main__":
main()
| def main():
n, m, *ab = list(map(int, open(0).read().split()))
e = [[] for _ in range(n)]
for u, v in zip(*[iter(ab)] * 2):
e[u - 1].append(v - 1)
e[v - 1].append(u - 1)
ans = 0
for _ in range(m):
count = 0
for i, x in enumerate(e):
if len(x) == 1:
e[i] = []
e[x[0]].remove(i)
count += 1
if count:
ans += count
else:
break
print(ans)
if __name__ == "__main__":
main()
| p03575 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parent = [i for i in range(self.n)]
self.rank = [0] * self.n
def find_root(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find_root(self.parent[x])
return self.parent[x]
def unite(self, x, y):
rx = self.find_root(x)
ry = self.find_root(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]:
self.parent[rx] = ry
else:
self.parent[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.find_root(x) == self.find_root(y)
N, M = list(map(int, input().split()))
edge = []
bridge = 0
for _ in range(M):
e = list([int(x)-1 for x in input().split()])
edge.append(e)
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j == i:
continue
uf.unite(edge[j][0], edge[j][1])
root = uf.find_root(0)
for i in range(1, N):
if root != uf.find_root(i):
bridge += 1
break
print(bridge) | class UnionFind():
def __init__(self, n):
self.n = n
self.parent = [i for i in range(self.n)]
self.rank = [0] * self.n
def find_root(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.find_root(self.parent[x])
return self.parent[x]
def unite(self, x, y):
rx = self.find_root(x)
ry = self.find_root(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]:
self.parent[rx] = ry
else:
self.parent[ry] = rx
if self.rank[rx] == self.rank[ry]:
self.rank[rx] += 1
def is_same(self, x, y):
return self.find_root(x) == self.find_root(y)
N, M = list(map(int, input().split()))
edge = []
bridge = 0
for _ in range(M):
e = list([int(x)-1 for x in input().split()])
edge.append(e)
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j == i:
continue
uf.unite(edge[j][0], edge[j][1])
if uf.find_root(edge[i][0]) != uf.find_root(edge[i][1]):
bridge += 1
print(bridge) | p03575 |
import copy
n, m = list(map(int, input().split()))
array = [[int(x) for x in input().split()] for y in range(m)]
t = copy.copy(array)
def solver(start, array, visited, cnt):
if visited[start]:
return cnt
else:
visited[start] = True
for i in array[start]:
if len(set(visited)) == 1:
return 1
else:
cnt = solver(i, array, visited, cnt)
return cnt
res2 = 0
for i in range(m):
tmp = array[:i] + array[i + 1:]
modify = [[] for x in range(n + 1)]
for value1, value2 in tmp:
modify[value1].append(value2)
modify[value2].append(value1)
visited = [False if x != 0 and x != 1 else True for x in range(n + 1)]
if not modify[1]:
continue
res = 0
for i in modify[1]:
res += solver(i, modify, visited, 0)
else:
res2 += 1 if res > 0 else 0
print((m - res2))
| n, m = list(map(int, input().split()))
ab_array = [[int(x) for x in input().split()] for y in range(m)]
graph = [[] for x in range(n + 1)]
def dfs(graph, now, a, b):
visited[now] = True
for next in graph[now]:
if (now == a and next == b) or (now == b and next == a):
continue
if not visited[next]:
dfs(graph, next, a, b)
return visited.count(False) == 1
for a, b in ab_array:
graph[a].append(b)
graph[b].append(a)
ans = 0
for a, b in ab_array:
start = a
end = b
visited = [False for x in range(n + 1)]
if dfs(graph, 1, a, b):
ans += 1
print((m - ans))
| p03575 |
def dfs(now):
if vis[now]==1:
return 0
vis[now]=1
for i in range(n):
if graph[now][i]==1:
dfs(i)
n,m=list(map(int,input().split()))
edge=[[int(i) for i in input().split()]for i in range(m)]
graph=[[0 for i in range(n)]for i in range(n)]
vis=[0]*n
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=1
graph[edge[i][1]-1][edge[i][0]-1]=1
ans=0
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=0
graph[edge[i][1]-1][edge[i][0]-1]=0
vis=[0]*n
dfs(0)
connect=False
for j in range(n):
if vis[j]==0:
connect=True
if connect:
ans+=1
graph[edge[i][0]-1][edge[i][1]-1]=1
graph[edge[i][1]-1][edge[i][0]-1]=1
print(ans)
| def dfs(now):
if vis[now]==1:#既に訪問済みであればreturn
return 0
vis[now]=1#訪問した記録をつける
for i in range(n):
if graph[now][i]==1:#接続していれば、移動
dfs(i)
n,m=list(map(int,input().split()))
edge=[[int(i) for i in input().split()]for i in range(m)]#入力値を受け取る
graph=[[0 for i in range(n)]for i in range(n)]
vis=[0]*n#既にある頂点を訪問したか管理する配列
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=1#グラフを生成
graph[edge[i][1]-1][edge[i][0]-1]=1
ans=0
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=0#ある辺を消去
graph[edge[i][1]-1][edge[i][0]-1]=0
vis=[0]*n
dfs(0)
connect=False#全ての点が繋がっているか判断する値
for j in range(n):
if vis[j]==0:#訪問していない点があればcout
connect=True
if connect:
ans+=1
graph[edge[i][0]-1][edge[i][1]-1]=1#消した辺をもとに戻す
graph[edge[i][1]-1][edge[i][0]-1]=1
print(ans)
| p03575 |
def dfs(now):
if vis[now]==1:#既に訪問済みであればreturn
return 0
vis[now]=1#訪問した記録をつける
for i in range(n):
if graph[now][i]==1:#接続していれば、移動
dfs(i)
n,m=list(map(int,input().split()))
edge=[[int(i) for i in input().split()]for i in range(m)]#入力値を受け取る
graph=[[0 for i in range(n)]for i in range(n)]
vis=[0]*n#既にある頂点を訪問したか管理する配列
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=1#グラフを生成
graph[edge[i][1]-1][edge[i][0]-1]=1
ans=0
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=0#ある辺を消去
graph[edge[i][1]-1][edge[i][0]-1]=0
vis=[0]*n
dfs(0)
connect=False#全ての点が繋がっているか判断する値
for j in range(n):
if vis[j]==0:#訪問していない点があればcout
connect=True
if connect:
ans+=1
graph[edge[i][0]-1][edge[i][1]-1]=1#消した辺をもとに戻す
graph[edge[i][1]-1][edge[i][0]-1]=1
print(ans)
| def dfs(now):
if vis[now]:
return 0
vis[now]=1
for i in range(n):
if graph[now][i]:
dfs(i)
n,m=list(map(int,input().split()))
edge=[[int(i) for i in input().split()]for i in range(m)]
graph=[[0 for i in range(n)]for i in range(n)]
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=1
graph[edge[i][1]-1][edge[i][0]-1]=1
vis=[0]*n
ans=0
for i in range(m):
graph[edge[i][0]-1][edge[i][1]-1]=0
graph[edge[i][1]-1][edge[i][0]-1]=0
vis=[0]*n
dfs(0)
connect=False
for j in range(n):
if vis[j]==0:
connect=True
if connect:
ans+=1
graph[edge[i][0]-1][edge[i][1]-1]=1
graph[edge[i][1]-1][edge[i][0]-1]=1
print(ans)
| p03575 |
# 頂点と辺の数を入力する
N, M = list(map(int, input().split()))
# 隣接リストを作成する
list_adjlist = [[] for _ in range(N + 1)]
# 辺のリストを作成する
list_edge = []
# 辺を入力し、隣接リストおよび辺のリストに格納する
for _ in range(M):
a, b = list(map(int, input().split()))
list_edge.append((a, b))
list_adjlist[a].append(b)
list_adjlist[b].append(a)
# 橋の数bridgeを設定する
bridge = 0
# aとbを結ぶ辺について、その辺を通らずにaからbにたどり着けるかを調べる
for a, b in list_edge:
# これから訪問する頂点のリストlist_nodeを初期化する
list_node = list_adjlist[a].copy()
list_node.remove(b)
# これまでに訪問した頂点の集合set_visit_nodeを初期化する
set_visit_node = {a}
# 繰り返し
while True:
# 次に訪問可能な頂点の集合set_next_nodeを設定する
set_next_node = set()
# list_node内の頂点vに訪問する
for v in list(list_node):
# vと隣接している頂点をset_next_nodeに格納する
set_next_node |= set(list_adjlist[v])
# set_visit_nodeを更新する
set_visit_node |= set(list_node)
# set_next_nodeの全要素がset_visit_nodeに含まれる場合、、
if set_next_node.issubset(set_visit_node):
break
# set_next_nodeの要素にset_visit_nodeに含まれない要素が存在する場合、、
else:
# list_nodeを更新する
list_node = list(set_next_node - set_visit_node)
# set_visit_nodeにbが含まれない場合（＝aからbにたどり着けない場合）
if b not in set_visit_node:
bridge += 1
# 結果を出力する
print(bridge) | #幅優先探索（BFS）を利用
# 頂点と辺の数を入力する
N, M = list(map(int, input().split()))
# 隣接リストを作成する
list_adjlist = [[] for _ in range(N + 1)]
# 辺のリストを作成する
list_edge = []
# 辺を入力し、隣接リストおよび辺のリストに格納する
for _ in range(M):
a, b = list(map(int, input().split()))
list_edge.append((a, b))
list_adjlist[a].append(b)
list_adjlist[b].append(a)
def FIFO(list_FIFO, node):
if node != None:
list_FIFO.append(node)
return None
return list_FIFO.pop(0)
# 橋の総数（all_bridge）を初期化する
all_bridge = 0
# uv間の辺がなくても、uからvへたどり着けるか探索
for u, v in list_edge:
# uv間の辺が橋かどうか（uv_bridge）を初期化する（初期状態：1＝橋である）
uv_bridge = 1
# FIFOキューを初期化する
list_FIFO = []
# FIFOキューに入れたことのある点かどうかをチェックするリスト（list_check）を初期化する
list_check = [False] * (N + 1)
# FIFOキューにuを追加する
FIFO(list_FIFO, u)
# uをFIFOキューに入れた点としてチェックする
list_check[u] = True
# FIFOキューが空でない、かつvにたどり着いていない限り、幅優先探索
while list_FIFO != [] and list_FIFO[-1] != v:
# FIFOキューから点（node）を取り出す
node = FIFO(list_FIFO, None)
# nodeの隣接点（adjnode）について繰り返す
for adjnode in list_adjlist[node]:
# adjnodeがFIFOキューに入れたことのある点だった場合
if list_check[adjnode]:
# 以降の処理は行わずに次の隣接点に移る
continue
# adjnodeがvだった場合
if adjnode == v:
# nodeがuでない場合
if node != u:
# uv_bridgeを更新する（0＝橋でない）
uv_bridge = 0
# FIFOキューにadjnodeを追加する
FIFO(list_FIFO, adjnode)
# 繰り返しを終了する
break
# adjnodeがv出ない場合
else:
# FIFOキューにadjnodeを追加する
FIFO(list_FIFO, adjnode)
# adjnodeをFIFOキューに入れた点としてチェックする
list_check[adjnode] = True
# all_bridgeにuv_bridgeを加える
all_bridge += uv_bridge
# all_bridgeを出力する
print(all_bridge) | p03575 |
n, m = list(map(int, input().split()))
L = [[0, 0] for _ in range(m)]
g = [[] for _ in range(n)]
for j in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
L[j][0] = a
L[j][1] = b
from collections import deque
ans = 0
for i in range(m):
g = [[] for _ in range(n)]
for j in range(m):
if j == i:
continue
a = L[j][0]
b = L[j][1]
g[a].append(b)
g[b].append(a)
#print(g)
s = deque()
s.append(0)
visit = [-1]*n
visit[0] = 0
while s:
x = s.pop()
for new_x in g[x]:
if visit[new_x] == -1:
visit[new_x] = visit[x] + 1
s.append(new_x)
if min(visit) == -1:
ans += 1
print(ans) | n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
def lowlink(g, root=0):
n = len(g)
order = [n]*n
low = [n]*n
s = [root]
cnt = 1
par = [-1]*n
seq = []
while s:
v = s.pop()
if order[v] != n:
continue
order[v] = cnt
seq.append(v)
low[v] = cnt
cnt += 1
for u in g[v]:
if order[u] < cnt:
if par[v] != u:
low[v] = min(low[v], order[u])
continue
else:
par[u] = v
s.append(u)
child = [[] for _ in range(n)]
for v in range(n):
if par[v] != -1:
child[par[v]].append(v)
seq.reverse()
for v in seq:
for u in child[v]:
low[v] = min(low[v], low[u])
# bridge
bridge = []
for p in range(n):
for c in child[p]:
if order[p] < low[c]:
bridge.append((p, c))
# articulation points
AP = []
for v in range(n):
if v == root:
if len(child[v]) >= 2:
AP.append(v)
else:
for c in child[v]:
if order[v] <= low[c]:
AP.append(v)
break
return AP, bridge
_, bridge = lowlink(g, 0)
print((len(bridge))) | p03575 |
from collections import deque
n,m = list(map(int,input().split()))
edge_ls = [0] * m
for i in range(m):
a,b = list(map(int,input().split()))
edge_ls[i] = [a,b]
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
'''
xとyは-=1して使うのが基本
'''
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
edge_q = deque(edge_ls)
num_bridge = 0
for i in range(m):
tar = edge_q.popleft()
uf = UnionFind(n)
for a,b in edge_q:
a -= 1
b -= 1
uf.union(a,b)
if not uf.group_count() == 1:
num_bridge += 1
edge_q.append(tar)
print(num_bridge) | from collections import deque
num_ver, num_edge = list(map(int,input().split()))
edges_ls = [0] * num_edge
for i in range(num_edge):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
edges_ls[i] = [a,b]
num_bridge = 0
for ind_take_edge in range(num_edge):
graph_ls = [[] for _ in range(num_ver)]
# graph_lsを作る
for ind_edge in range(num_edge):
if ind_edge != ind_take_edge:
a,b = edges_ls[ind_edge]
graph_ls[a].append(b)
graph_ls[b].append(a)
# 0からdfsしてdone_lsを仕上げていく
done_ls = [0] * num_ver
queue = deque()
queue.append(0)
while queue:
now = queue.pop()
done_ls[now] = 1
for nex in graph_ls[now]:
if done_ls[nex] != 1:
queue.append(nex)
if sum(done_ls) != num_ver:
num_bridge += 1
print(num_bridge)
| p03575 |
from collections import deque
N, M = list(map(int, input().split()))
graph = [set() for _ in range(N + 1)]
edge = []
for m in range(M):
a, b = list(map(int, input().split()))
graph[a].add(b)
graph[b].add(a)
edge.append([a, b])
ans = 0
for m in range(M):
Bridge = True
fr, to = edge[m][0], edge[m][1]
V = {fr} | set(graph[fr]) - {to}
que = set(graph[fr]) - {to}
while que:
node = que.pop()
for new_node in graph[node]:
if new_node == to:
Bridge = False
break
if new_node not in V:
que.add(new_node)
V.add(new_node)
else:
continue
break
if Bridge:
ans += 1
print(ans) | from collections import deque
N, M = list(map(int, input().split()))
graph = [set() for _ in range(N + 1)]
edge = []
##immutableに気をつけて
for m in range(M):
a, b = list(map(int, input().split()))
graph[a].add(b)
graph[b].add(a)
edge.append([a, b])
ans = 0
for m in range(M):
Bridge = True
fr, to = edge[m][0], edge[m][1]
V = {fr} | set(graph[fr]) - {to}
que = deque(set(graph[fr]) - {to})
while que:
node = que.pop()
for new_node in graph[node]:
if new_node == to:
Bridge = False
break
if new_node not in V:
que.append(new_node)
V.add(new_node)
else:
continue
break
if Bridge:
ans += 1
print(ans) | p03575 |
N,M = list(map(int,input().split()))
AB = []
from collections import deque
for i in range(M):
AB.append(list(map(int,input().split())))
out = 0
for remove in range(M):
G = [[] for i in range(N)]
for i in range(M):
if i==remove:
continue
else:
A,B=AB[i]
G[A-1].append(B-1)
G[B-1].append(A-1)
s = 0
visit = [0]*N
que = deque([s])
visit[s] = 1
while que:
v = que.popleft()
for w in G[v]:
if visit[w] == 1:
continue
visit[w] = 1
que.append(w)
if sum(visit)!=N:
out+=1
print(out) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
AB = []
for i in range(M):
AB.append(list(map(int,input().split())))
out = 0
for broken in range(M):
Network = UnionFind(N)
for j in range(M):
if j!=broken:
A,B=AB[j][0],AB[j][1]
Network.union(A-1, B-1)
if Network.group_count()==2:
out+=1
print(out) | p03575 |
from collections import deque
n,m=list(map(int,input().split()))
X=[]
M=[[] for _ in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
X.append([a,b])
M[a-1].append(b-1)
M[b-1].append(a-1)
ans=0
for i in range(m):
se={X[i][0]-1,X[i][1]-1}
q=deque([0])
visited=[0]*n
while q:
s=q.popleft()
if visited[s]==1:
continue
visited[s]=1
for x in M[s]:
if {s,x}!=se:
q.append(x)
if sum(visited)!=n:
ans+=1
print(ans) | n,m=list(map(int,input().split()))
X=[]
M=[[] for _ in range(n)]
for i in range(m):
a,b=list(map(int,input().split()))
X.append([a-1,b-1])
M[a-1].append(b-1)
M[b-1].append(a-1)
ans=0
def dfs(x,se):
visited[x]=1
for m in M[x]:
if se!={x,m} and visited[m]==0:
dfs(m,se)
for i in range(m):
visited=[0]*n
dfs(0,set(X[i]))
if 0 in visited:
ans+=1
print(ans) | p03575 |
from collections import defaultdict
n, m = list(map(int, input().split()))
G = defaultdict(list)
s = []
for i in range(m):
a, b = list(map(int, input().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
s.append((a - 1, b - 1))
def dfs(cur, pre, NG, k):
global used
used[cur] = 1
for v in G[cur]:
if v != pre and used[v] != 1 and (v, cur) != NG and (cur, v) != NG:
dfs(v, cur, NG, k + 1)
num = 0
for i in range(m):
ng = s[i]
used = [0] * n
used[0] = 1
dfs(0, -1, ng, 0)
if sum(used) == n:
num += 1
print((m - num)) | N, M = list(map(int, input().split()))
G = [[] for i in range(N)]
E = []
for i in range(M):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
G[a].append(b)
G[b].append(a)
E.append((a, b))
def dfs(v, pre, s, ng):
if used[v]:
return
used[v] = 1
s.add(v)
for u in G[v]:
if u == pre:
continue
if (u, v) != ng and (v, u) != ng:
dfs(u, v, s, ng)
return
num = 0
for i in E:
used = [0] * N
s = set()
dfs(0, -1, s, i)
if len(s) == N:
num += 1
print((M - num))
| p03575 |
import copy
N,M=list(map(int,input().split()))
l_2d = [[0] * N for i in range(N)]
edges=[]
def dfs(i):
l_visit[i-1]=1
for j in range(1,N+1):
if l_2d_temp[i-1][j-1]==1 and l_visit[j-1]==0:
dfs(j)
return
for _ in range(M):
i,j=list(map(int,input().split()))
edges.append([i,j])
l_2d[i-1][j-1]=1
l_2d[j-1][i-1]=1
ans=0
for edge in edges:
i,j=edge
l_2d_temp=copy.deepcopy(l_2d)
l_2d_temp[i-1][j-1]=0
l_2d_temp[j-1][i-1]=0
l_visit=[0]*N
dfs(1)
if 0 in l_visit:
ans+=1
print(ans) | N, M = list(map(int, input().split()))
R = []
G = {k: [] for k in range(N)} # 0-indexed
for _ in range(M):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
R.append((a-1, b-1))
def dfs(p, i, arrived):
for n in G[p]:
if arrived[n] is False and tuple(sorted((p, n))) != R[i]:
arrived[n] = True
dfs(n, i, arrived)
ans = 0
for i in range(M):
arrived = [False]*N
arrived[0] = True
dfs(0, i, arrived)
if not all(arrived):
ans += 1
print(ans)
| p03575 |
n,m=list(map(int,input().split()))
e=[]
for i in range(m):
e.append(list(map(int,input().split())))
ans=0
for i in range(m):
nall=[]
for j in range(m):
if i==j:
continue
nall.append(e[j])
visited=[0]*n
visited[0]=1
t=[1]
while len(t)>0:
tmp=[]
ntmp=[]
for p in t:
visited[p-1]=1
for q in nall:
if q[0]==p:
if visited[q[1]-1]==0:
tmp.append(q[1])
visited[q[1]-1]=1
elif q[1]==p:
if visited[q[0]-1]==0:
tmp.append(q[0])
visited[q[0]-1]=1
else:
if visited[q[0]-1]==0 or visited[q[1]-1]==0:
ntmp.append(q)
t=tmp
nall=ntmp
if sum(visited)!=n:
ans+=1
print(ans)
| n,m=list(map(int,input().split()))
e=[]
for i in range(m):
e.append(list(map(int,input().split())))
ans=0
for i in range(m):
g=[[] for _ in range(n)]
for j in range(m):
if i==j:
continue
g[e[j][0]-1].append(e[j][1])
g[e[j][1]-1].append(e[j][0])
visited=[0]*n
visited[0]=1
q=[1]
while len(q)>0:
a=q.pop(0)
visited[a-1]=1
for k in g[a-1]:
if visited[k-1]==0:
q+=[k]
if sum(visited)!=n:
ans+=1
print(ans)
| p03575 |
n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
E = []
for i in range(m):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
E.append((a-1, b-1))
from collections import deque
def solve(s, t):
if len(G[s]) == 1 or len(G[t]) == 1:
return 1
used = [0]*n
que = deque()
used[s] = 1
for v in G[s]:
if v == t:
continue
used[v] = 1
que.append(v)
while que:
u = que.popleft()
for v in G[u]:
if not used[v]:
used[v] = 1
que.append(v)
return sum(used) != n
ans = 0
for a, b in E:
ans += solve(a, b)
print(ans)
| n, m = list(map(int, input().split()))
G = [[] for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
def bridge(g, v, s=0):
bl = [False] * v
c_memo = [0] * v
c_used = [False] * v
b_g = [[] for i in range(v)]
def dfs(v, f, l):
bcnt = fcnt = 0
c_used[v] = True
for t in g[v]:
if not c_used[t]:
ll = []
ret = dfs(t, v, ll)
if ret>0:
l += ll
else:
b_g[t] = ll
for u in ll:
b_g[u].append(t)
l.append(t)
bcnt += ret
else:
if t==f:
if fcnt==1:
c_memo[f] -= 1
bcnt += 1
fcnt += 1
elif not bl[t]:
c_memo[t] -= 1
bcnt += 1
bl[v] = True
bcnt += c_memo[v]
return bcnt
dfs(s, -1, b_g[s])
for u in b_g[s]:
b_g[u].append(s)
return b_g
G = bridge(G, n)
ans = 0
for i in range(n):
for v in G[i]:
if i < v:
ans += 1
print(ans) | p03575 |
from itertools import chain
import copy
n, m = list(map(int, input().split()))
lis = [[10000000 for i in range(n)] for j in range(n)]
hen = []
for _ in range(m):
hen.append(list(map(int, input().split())))
ans = 0
for x in range(m):
lis_tmp = copy.deepcopy(lis)
bri = copy.deepcopy(hen)
bri.pop(x)
for y in range(m-1):
lis_tmp[bri[y][0]-1][bri[y][1]-1] = 1
lis_tmp[bri[y][1]-1][bri[y][0]-1] = 1
for k in range(n):
for i in range(n):
for j in range(n):
lis_tmp[i][j] = min(lis_tmp[i][j], lis_tmp[i][k] + lis_tmp[k][j])
if 10000000 in list(chain.from_iterable(lis_tmp)):
ans += 1
print(ans) | n, m = list(map(int, input().split()))
hen = []
for _ in range(m):
hen.append(list(map(int, input().split())))
def dfs(vis, graph, x, n):
vis[x] = True
for i in range(n):
if graph[x][i] == False:
continue
if vis[i] == True:
continue
dfs(vis, graph, i, n)
return vis
ans = 0
for i in range(m):
graph = [[False for _ in range(n)] for _ in range(n)]
rng = [a for a in range(m)]
del rng[i]
for y in rng:
graph[hen[y][0]-1][hen[y][1]-1] = True
graph[hen[y][1]-1][hen[y][0]-1] = True
vis = [False for _ in range(n)]
vis = dfs(vis, graph, 0, n)
connected = True
for k in range(n):
if vis[k] == False:
connected = False
if connected == False:
ans += 1
print(ans) | p03575 |
class UnionFind:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
while self.table[x] >= 0:
x = self.table[x]
return x
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] != self.table[s2]:
if self.table[s1] < self.table[s2]:
self.table[s2] = s1
else:
self.table[s1] = s2
else:
self.table[s1] += -1
self.table[s2] = s1
return
n, m = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(m)]
ans = 0
for i in range(m):
uf = UnionFind(n)
for j in range(m):
if i != j:
uf.union(edges[j][0]-1, edges[j][1]-1)
c = 0
for j in range(n):
if j == uf.find(j):
c += 1
if c > 1:
ans += 1
print(ans)
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0] * (n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
n, m = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(m)]
ans = 0
for i in range(m):
uf = UnionFind(n)
for j in range(m):
if i != j:
uf.union(edges[j][0]-1, edges[j][1]-1)
c = 0
for j in range(n):
if j == uf.find(j):
c += 1
if c > 1:
ans += 1
print(ans)
| p03575 |
#####################################################################################################
##### Low Link (橋、関節点)
#####################################################################################################
"""
計算量
O(V+E)
参考
https://algo-logic.info/bridge-lowlink/
"""
import sys
input = sys.stdin.readline
import marshal
class Graph:
def __init__(self, n, dictated=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.dictated == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bridge_detector(self, articular_list=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:param articular_list: True = 関節点のリストを返す
:return: 各点までの距離と何番目に発見したかを返す
"""
if self.destroy:
edge2 = self.edges
else:
edge2 = marshal.loads(marshal.dumps(self.edges))
start, time = 0, 0
p, t = start, time
self.parent[p] = -2
ord = [-1]*self.n # ord = DFS で頂点 q を何番目に探索したか
ord[p] = t
low = [-1]*self.n # low = q からの 0 回以上木辺を使って前進し、後退辺を1回以下使って後退する事で到達できる頂点 p について、ord[p] の最小値
low[p] = 0
articular = [] # 関節点の集合
bridge = [] # 橋の集合
if len(edge2[p]) >= 2:
""" 根に子が二つ異常存在する場合は、根も関節点 """
articular.append(p)
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if ord[q] < low[p]:
low[p] = ord[q]
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
""""""""""""""""""""
ord[q] = low[q] = t + 1
self.parent[q] = p
p, t = q, t + 1
else:
if p == start and t == time:
break
""" p から進める点がもう無い時の点 p における処理 """
parent_p = self.parent[p]
if low[p] < low[parent_p]:
low[parent_p] = low[p]
""" この時点でlow[p]が確定するので、ord[parent[p]] ≤ low[p] を判定しておく"""
if ord[parent_p] <= low[p]:
if ord[parent_p]:
articular.append(parent_p + self.decrement)
if ord[parent_p] < low[p]:
bridge.append((parent_p + self.decrement, p + self.decrement))
""""""""""""""""""""
p, t = self.parent[p], t - 1
""" 点 p から親ノードに戻ってきた時の親ノードにおける処理 """
""""""""""""""""""""
if articular_list == False:
return bridge
else:
return articular
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edges[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
def inc(A):
return list([x+1 for x in A])
def dec(A):
return list([x-1 for x in A])
###############################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, dictated=False, decrement=True, destroy=True)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
print((len(graph.bridge_detector(articular_list=False))))
# graph.draw()
"""
9 10
7 8
8 9
3 6
9 2
1 2
2 3
3 4
4 5
5 6
6 7
""" | #####################################################################################################
##### Low Link (橋、関節点)
#####################################################################################################
"""
計算量
O(V+E)
参考
https://algo-logic.info/bridge-lowlink/
"""
import sys
input = sys.stdin.readline
import marshal
class Graph:
def __init__(self, n, dictated=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.dictated == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bridge_detector(self, articular_list=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:param articular_list: True = 関節点のリストを返す
:return: 各点までの距離と何番目に発見したかを返す
"""
start, time = 0, 0
p, t = start, time
self.parent[p] = -2
ord = [-1]*self.n # ord = DFS で頂点 q を何番目に探索したか
ord[p] = t
low = [-1]*self.n # low = q からの 0 回以上木辺を使って前進し、後退辺を1回以下使って後退する事で到達できる頂点 p について、ord[p] の最小値
low[p] = 0
articular = [] # 関節点の集合
bridge = [] # 橋の集合
if len(self.edges[p]) >= 2:
""" 根に子が二つ異常存在する場合は、根も関節点 """
articular.append(p)
while True:
if self.edges[p]:
q = self.edges[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if ord[q] < low[p]:
low[p] = ord[q]
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
""""""""""""""""""""
ord[q] = low[q] = t + 1
self.parent[q] = p
p, t = q, t + 1
else:
if p == start and t == time:
break
""" p から進める点がもう無い時の点 p における処理 """
parent_p = self.parent[p]
if low[p] < low[parent_p]:
low[parent_p] = low[p]
""" この時点でlow[p]が確定するので、ord[parent[p]] ≤ low[p] を判定しておく"""
if ord[parent_p] <= low[p]:
if ord[parent_p]:
articular.append(parent_p + self.decrement)
if ord[parent_p] < low[p]:
bridge.append((parent_p + self.decrement, p + self.decrement))
""""""""""""""""""""
p, t = self.parent[p], t - 1
""" 点 p から親ノードに戻ってきた時の親ノードにおける処理 """
""""""""""""""""""""
if articular_list == False:
return bridge
else:
return articular
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edges[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
def inc(A):
return list([x+1 for x in A])
def dec(A):
return list([x-1 for x in A])
###############################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, dictated=False, decrement=True, destroy=True)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
print((len(graph.bridge_detector(articular_list=False))))
# graph.draw()
"""
9 10
7 8
8 9
3 6
9 2
1 2
2 3
3 4
4 5
5 6
6 7
""" | p03575 |
#####################################################################################################
##### Low Link (橋、関節点)
#####################################################################################################
"""
計算量
O(V+E)
参考
https://algo-logic.info/bridge-lowlink/
"""
import sys
input = sys.stdin.readline
import marshal
class Graph:
def __init__(self, n, dictated=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.dictated == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bridge_detector(self, articular_list=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:param articular_list: True = 関節点のリストを返す
:return: 各点までの距離と何番目に発見したかを返す
"""
start, time = 0, 0
p, t = start, time
self.parent[p] = -2
ord = [-1]*self.n # ord = DFS で頂点 q を何番目に探索したか
ord[p] = t
low = [-1]*self.n # low = q からの 0 回以上木辺を使って前進し、後退辺を1回以下使って後退する事で到達できる頂点 p について、ord[p] の最小値
low[p] = 0
articular = [] # 関節点の集合
bridge = [] # 橋の集合
if len(self.edges[p]) >= 2:
""" 根に子が二つ異常存在する場合は、根も関節点 """
articular.append(p)
while True:
if self.edges[p]:
q = self.edges[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if ord[q] < low[p]:
low[p] = ord[q]
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
""""""""""""""""""""
ord[q] = low[q] = t + 1
self.parent[q] = p
p, t = q, t + 1
else:
if p == start and t == time:
break
""" p から進める点がもう無い時の点 p における処理 """
parent_p = self.parent[p]
if low[p] < low[parent_p]:
low[parent_p] = low[p]
""" この時点でlow[p]が確定するので、ord[parent[p]] ≤ low[p] を判定しておく"""
if ord[parent_p] <= low[p]:
if ord[parent_p]:
articular.append(parent_p + self.decrement)
if ord[parent_p] < low[p]:
bridge.append((parent_p + self.decrement, p + self.decrement))
""""""""""""""""""""
p, t = self.parent[p], t - 1
""" 点 p から親ノードに戻ってきた時の親ノードにおける処理 """
""""""""""""""""""""
if articular_list == False:
return bridge
else:
return articular
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edges[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
def inc(A):
return list([x+1 for x in A])
def dec(A):
return list([x-1 for x in A])
###############################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, dictated=False, decrement=True, destroy=True)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
print((len(graph.bridge_detector(articular_list=False))))
# graph.draw()
"""
9 10
7 8
8 9
3 6
9 2
1 2
2 3
3 4
4 5
5 6
6 7
""" | #####################################################################################################
##### Low Link (橋、関節点)
#####################################################################################################
"""
計算量
O(V+E)
参考
https://algo-logic.info/bridge-lowlink/
"""
import sys
input = sys.stdin.readline
import marshal
class Graph:
def __init__(self, n, dictated=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.dictated = dictated
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.dictated == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set([x - 1 for x in adjacent_list])
else:
self.edges[i] = set(adjacent_list)
def bridge_detector(self, articular_list=False):
"""
:param p: スタート地点
:param save: True = 前回の探索結果を保持する
:param articular_list: True = 関節点のリストを返す
:return: 各点までの距離と何番目に発見したかを返す
"""
if self.destroy:
edge2 = self.edges
else:
edge2 = marshal.loads(marshal.dumps(self.edges))
start, time = 0, 0
p, t = start, time
self.parent[p] = -2
ord = [-1]*self.n # ord = DFS で頂点 q を何番目に探索したか
ord[p] = t
low = [-1]*self.n # low = q からの 0 回以上木辺を使って前進し、後退辺を1回以下使って後退する事で到達できる頂点 p について、ord[p] の最小値
low[p] = 0
articular = [] # 関節点の集合
bridge = [] # 橋の集合
if len(edge2[p]) >= 2:
""" 根に子が二つ異常存在する場合は、根も関節点 """
articular.append(p)
while True:
if edge2[p]:
q = edge2[p].pop()
if q == self.parent[p] and not self.dictated:
""" 逆流した時の処理 """
""""""""""""""""""""
continue
if self.parent[q] != -1:
""" サイクルで同一点を訪れた時の処理 """
if ord[q] < low[p]:
low[p] = ord[q]
""""""""""""""""""""
continue
""" p から q への引継ぎ"""
""""""""""""""""""""
ord[q] = low[q] = t + 1
self.parent[q] = p
p, t = q, t + 1
else:
if p == start and t == time:
break
""" p から進める点がもう無い時の点 p における処理 """
parent_p = self.parent[p]
if low[p] < low[parent_p]:
low[parent_p] = low[p]
""" この時点でlow[p]が確定するので、ord[parent[p]] ≤ low[p] を判定しておく"""
if ord[parent_p] <= low[p]:
if ord[parent_p]:
articular.append(parent_p + self.decrement)
if ord[parent_p] < low[p]:
bridge.append((parent_p + self.decrement, p + self.decrement))
""""""""""""""""""""
p, t = self.parent[p], t - 1
""" 点 p から親ノードに戻ってきた時の親ノードにおける処理 """
""""""""""""""""""""
if articular_list == False:
return bridge
else:
return articular
def draw(self):
"""
:return: グラフを可視化
"""
import matplotlib.pyplot as plt
import networkx as nx
if self.dictated:
G = nx.DiGraph()
else:
G = nx.Graph()
for x in range(self.n):
for y in self.edges[x]:
G.add_edge(x + self.decrement, y + self.decrement)
nx.draw_networkx(G)
plt.show()
def inc(A):
return list([x+1 for x in A])
def dec(A):
return list([x-1 for x in A])
###############################################################################################
N, M = list(map(int, input().split()))
graph = Graph(N, dictated=False, decrement=True, destroy=False)
for _ in range(M):
x, y = list(map(int, input().split()))
graph.add_edge(x, y)
print((len(graph.bridge_detector(articular_list=False))))
# graph.draw()
"""
9 10
7 8
8 9
3 6
9 2
1 2
2 3
3 4
4 5
5 6
6 7
""" | p03575 |
class UnionFind:
def __init__(self, num):
self.rank = [0]*num
self.par = [i for i in range(num)] #基準(par = parentのpar)
self.n = num
self.size = [1]*num
#親を探す
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x]) #自分じゃなきゃ親を探す
return self.par[x]
#集合を結合する(結合する前に親のポインタを取得する)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]: #ランクの高い方に基準を合わせる
x,y=y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
def same(self, x, y):
return self.find(x) == self.find(y)
def all_find(self):
for n in range(len(self.par)):
self.find(n)
n,m=list(map(int,input().split()))
# edges=[[0]*n for i in range(n)]
# uf=UnionFind(n)
ans=0
# ab=[]
# for i in range(m):
# a,b=map(int,input().split())
# ab.append([a,b])
# uf.union(a-1,b-1)
# for i in range(m):
# uf1=UnionFind(n)
# for j in range(m):
# a,b=ab[j]
# if i==j:
# continue
# uf1.union(a-1,b-1)
# if all([True if i==j else False for i,j in zip(uf.par,uf1.par)])!=True:
# ans+=1
nl=[]
for i in range(m):
f,t=list(map(int,input().split()))
nl.append([f-1,t-1])
for i in range(m):
uf=UnionFind(n)
flag=False
for j in range(m):
if i==j:
continue
uf.union(nl[j][0],nl[j][1])
nl.append(t)
for j in range(n):
for k in range(n):
if not uf.same(j,k):
flag=True
if flag:
ans+=1
print(ans) | class UnionFind:
def __init__(self, num):
self.rank = [0]*num
self.par = [i for i in range(num)] #基準(par = parentのpar)
self.n = num
self.size = [1]*num
#親を探す
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x]) #自分じゃなきゃ親を探す
return self.par[x]
#集合を結合する(結合する前に親のポインタを取得する)
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]: #ランクの高い方に基準を合わせる
x,y=y,x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
self.size[x] += self.size[y]
self.size[y] = 0
def same(self, x, y):
return self.find(x) == self.find(y)
def all_find(self):
for n in range(len(self.par)):
self.find(n)
n,m=list(map(int,input().split()))
uf=UnionFind(n)
ans=0
ab=[]
for i in range(m):
a,b=list(map(int,input().split()))
ab.append([a,b])
for i in range(m):
uf=UnionFind(n)
flag=False
for j in range(m):
a,b=ab[j]
if i==j:
continue
uf.union(a-1,b-1)
for j in range(n):
for k in range(j,n):
if not uf.same(j,k):
flag=True
if flag:
ans+=1
print(ans) | p03575 |
class UnionFind:
def __init__(self, size):
self.table = [i for i in range(size)]
def find(self, x):
return self.table[x]
def union(self, x, y):
x1 = self.find(x)
y1 = self.find(y)
if x1 == y1:
return False
for i in range(len(self.table)):
if self.table[i] == y1:
self.table[i] = x1
return True
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
edges.append([a-1, b-1])
mat = [[0]*N for _ in range(N)]
for s, g in edges:
mat[s][g] = 1
mat[g][s] = 1
ans = 0
for i in range(M):
uni = UnionFind(N)
for j in range(M):
if i != j:
uni.union(edges[j][0], edges[j][1])
if not all(uni.find(0) == uni.find(x) for x in range(N)):
ans += 1
print(ans)
| # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
"""
size:頂点の数
"""
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
"""
xのrootを返す
"""
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def union(self, x, y):
"""
x,yを同じグループとしてまとめる
"""
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
"""
xとyが同じグループならTrue
"""
return self.find(x) == self.find(y)
def component(self):
"""
各連結成分のrootの集合を返す
len()をとれば連結成分の数が求められる
return-> set()
"""
comp = set()
for i in self.parent:
p = self.find(i)
comp.add(p)
return comp
def __str__(self):
"""
for debug
クラスのlistの情報を出力
"""
ret = "parents\n"
ret += " ".join(map(str, self.parent))
ret += '\n'
ret += " ".join(map(str, self.rank))
return ret
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = [int(x)-1 for x in input().split()]
edges.append([a, b])
ans = 0
for e in edges:
Un = UnionFind(N)
for g in edges:
if e == g:
continue
else:
Un.union(g[0], g[1])
if not Un.same(e[0], e[1]):
ans += 1
print(ans)
| p03575 |
#!/usr/bin/env python3
from copy import deepcopy
def dfs(x, adj, visited):
for y, flag in enumerate(adj[x]):
if flag and y not in visited:
visited.add(y)
dfs(y, adj, visited)
def main():
n, m = list(map(int, input().split()))
adj = [[(i == j) for i in range(n)] for j in range(n)]
edges = set()
for i in range(m):
a1, b1 = list(map(int, input().split()))
a = a1 - 1
b = b1 - 1
edges.add((a, b))
adj[a][b] = True
adj[b][a] = True
res = 0
for e in edges:
adjc = deepcopy(adj)
adjc[e[0]][e[1]] = False
adjc[e[1]][e[0]] = False
visited = {0}
dfs(0, adjc, visited)
if len(visited) < n:
res += 1
print(res)
main()
| #!/usr/bin/env python3
from copy import deepcopy
def dfs(x, adj, visited):
for y, flag in enumerate(adj[x]):
if flag and y not in visited:
visited.add(y)
dfs(y, adj, visited)
def is_simply_connected(adj):
n = len(adj)
visited = {0}
dfs(0, adj, visited)
return len(visited) == n
def main():
n, m = list(map(int, input().split()))
adj = [[(i == j) for i in range(n)] for j in range(n)]
edges = set()
for i in range(m):
a1, b1 = list(map(int, input().split()))
a = a1 - 1
b = b1 - 1
edges.add((a, b))
adj[a][b] = True
adj[b][a] = True
res = 0
for a, b in edges:
adjc = deepcopy(adj)
adjc[a][b] = False
adjc[b][a] = False
if not is_simply_connected(adjc):
res += 1
print(res)
main()
| p03575 |
#!/usr/bin/env python3
from copy import deepcopy
def dfs(x, adj, visited):
for y, flag in enumerate(adj[x]):
if flag and y not in visited:
visited.add(y)
dfs(y, adj, visited)
def is_simply_connected(adj):
n = len(adj)
visited = {0}
dfs(0, adj, visited)
return len(visited) == n
def main():
n, m = list(map(int, input().split()))
adj = [[(i == j) for i in range(n)] for j in range(n)]
edges = set()
for i in range(m):
a1, b1 = list(map(int, input().split()))
a = a1 - 1
b = b1 - 1
edges.add((a, b))
adj[a][b] = True
adj[b][a] = True
res = 0
for a, b in edges:
adjc = deepcopy(adj)
adjc[a][b] = False
adjc[b][a] = False
if not is_simply_connected(adjc):
res += 1
print(res)
main()
| #!/usr/bin/env python3
from copy import deepcopy
def dfs(x, adj, visited):
for y, flag in enumerate(adj[x]):
if flag and y not in visited:
visited.add(y)
dfs(y, adj, visited)
def is_simply_connected(adj):
n = len(adj)
visited = {0} # O(log n). Use list instead.
dfs(0, adj, visited)
return len(visited) == n
def main():
n, m = list(map(int, input().split()))
adj = [[(i == j) for i in range(n)] for j in range(n)]
edges = set()
for i in range(m):
a1, b1 = list(map(int, input().split()))
a = a1 - 1
b = b1 - 1
edges.add((a, b))
adj[a][b] = True
adj[b][a] = True
res = 0
for a, b in edges:
adj[a][b] = adj[b][a] = False
if not is_simply_connected(adj):
res += 1
adj[a][b] = adj[b][a] = True
print(res)
main()
| p03575 |
from collections import deque
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
edges.append((a, b))
ans = 0
for removeEdge in range(M):
confilm = [False for _ in range(N)]
que = deque([])
que.append(0)
while que:
now = que.popleft()
confilm[now] = True
for i, (a, b) in enumerate(edges):
if i == removeEdge:
continue
if a == now:
if not confilm[b]:
que.append(b)
if b == now:
if not confilm[a]:
que.append(a)
if False in confilm:
ans += 1
print(ans) |
class UnionFind :
def __init__(self, size) :
self.parent = list(range(size))
self.height = [0] * size
self.size = [1] * size
self.component = size
def root(self, index) :
if self.parent[index] == index : # 根の場合
return index
rootIndex = self.root(self.parent[index]) # 葉の場合親の根を取得
self.parent[index] = rootIndex # 親の付け直し
return rootIndex
def union(self, index1, index2) : # 結合
root1 = self.root(index1)
root2 = self.root(index2)
if root1 == root2 : # 連結されている場合
return
self.component -= 1 # 連結成分を減らす
if self.height[root1] < self.height[root2] :
self.parent[root1] = root2 # root2に結合
self.size[root2] += self.size[root1]
else :
self.parent[root2] = root1 # root1に結合
self.size[root1] += self.size[root2]
if self.height[root1] == self.height[root2] :
self.height[root1] += 1
return
def isSameRoot(self, index1, index2) :
return self.root(index1) == self.root(index2)
def sizeOfSameRoot(self, index) :
return self.size[self.root(index)]
def getComponent(self) :
return self.component
N, M = list(map(int, input().split()))
AB = [tuple([int(a) - 1 for a in input().split()]) for _ in range(M)]
ans = 0
for i in range(M):
tree = UnionFind(N)
for a, b in (AB[:i] + AB[i + 1:]):
tree.union(a, b)
if tree.getComponent() > 1:
ans += 1
print(ans)
| p03575 |
import copy
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
class UnionFindPathCompression():
def __init__(self, n:int):
self.parents = list(range(n))
self.rank = [1]*n
self.size = [1]*n
def find(self, x:int) -> int:
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x:int, y:int):
px = self.find(x)
py = self.find(y)
if px == py:
return
else:
if self.rank[px] < self.rank[py]:
self.parents[px] = py
self.size[py] += self.size[px]
else:
self.parents[py] = px
self.size[px] += self.size[py]
#ランクの更新
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
n,m = list(map(int,input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
memo = 0
for i in range(m):
ufpc = UnionFindPathCompression(n)
ab_copy = copy.deepcopy(ab)
ab_copy.pop(i)
for a,b in ab_copy:
a,b = a-1,b-1
ufpc.union(a,b)
for i in range(n):
ufpc.find(i)
check = set(ufpc.parents)
if len(check)==1:
memo += 1
print((m-memo)) | import copy
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
class UnionFindPathCompression():
def __init__(self, n:int):
self.parents = list(range(n))
self.rank = [1]*n
self.size = [1]*n
def find(self, x:int) -> int:
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x:int, y:int):
px = self.find(x)
py = self.find(y)
if px == py:
return
else:
if self.rank[px] < self.rank[py]:
self.parents[px] = py
self.size[py] += self.size[px]
else:
self.parents[py] = px
self.size[px] += self.size[py]
#ランクの更新
if self.rank[px] == self.rank[py]:
self.rank[px] += 1
n,m = list(map(int,input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ans = 0
for i in range(m):
ufpc = UnionFindPathCompression(n)
ab_copy = copy.deepcopy(ab)
ab_copy.pop(i)
for a,b in ab_copy:
a,b = a-1,b-1
ufpc.union(a,b)
for i in range(n):
ufpc.find(i)
check = set(ufpc.parents)
if len(check) != 1:
ans += 1
print(ans)
| p03575 |
import sys
from io import StringIO
import unittest
sys.setrecursionlimit(10**5)
def dfs(u, visited, g, seq):
visited[u] = True
for v in g[u]:
if visited[v] == True or not seq[u][v]:
continue
dfs(v, visited, g, seq)
def resolve():
n, m = list(map(int, input().split()))
seq = [[True]*n for _ in range(n)]
g = [[] for _ in range(n)]
edges = []
ans = 0
for _ in range(m):
a, b = list(map(int, input().split()))
edges.append([a-1, b-1])
for i in range(m):
g[edges[i][0]].append(edges[i][1])
g[edges[i][1]].append(edges[i][0])
for i in range(m):
visited = [False]*n
seq[edges[i][1]][edges[i][0]] = False
seq[edges[i][0]][edges[i][1]] = False
dfs(0, visited, g, seq)
if len(visited) != visited.count(True):
ans += 1
seq[edges[i][1]][edges[i][0]] = True
seq[edges[i][0]][edges[i][1]] = True
print(ans)
resolve() | def search(u, g, visited):
if visited[u]:
return
visited[u] = True
for v in g[u]:
search(v, g, visited)
def resolve():
n, m = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(m)]
ans = 0
for i in range(m):
g = [[] for _ in range(n)]
for j in range(m):
if i == j:
continue
a, b = edges[j]
g[a-1].append(b-1)
g[b-1].append(a-1)
visited = [False]*n
search(0, g, visited)
if visited.count(True) != n:
ans += 1
print(ans)
resolve() | p03575 |
from collections import deque
N,M = list(map(int,input().split()))
edges = []
connections = {}
for i in range(M):
edges.append(list(map(int,input().split())))
a,b = edges[-1][0],edges[-1][1]
if a in connections:
connections[a].append(b)
else:
connections[a] = [b]
if b in connections:
connections[b].append(a)
else:
connections[b] = [a]
ans = 0
for i in range(M):
queue = deque([1])
checked = [0]*(N+1)
checked[1] = 1
NG = {edges[i][0],edges[i][1]}
while queue:
currentpoint = queue.popleft()
for nextpoint in connections[currentpoint]:
if not (currentpoint in NG and nextpoint in NG) and checked[nextpoint] == 0:
queue.append(nextpoint)
checked[nextpoint] = 1
if sum(checked) != N:
ans += 1
print(ans) | #https://note.nkmk.me/python-union-find/
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N,M = list(map(int,input().split()))
ab = [list(map(int,input().split())) for i in range(M)]
uf = UnionFind(N+1)
for i in range(M):
uf.union(ab[i][0],ab[i][1])
base = uf.group_count()
ans = 0
for skip in range(M):
uf = UnionFind(N+1)
for i in range(M):
if skip == i:
continue
else:
uf.union(ab[i][0],ab[i][1])
if uf.group_count()-base == 1:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p03575 |
from collections import deque
n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = deque()
q.append(1)
seen = {1}
while q:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = [1]
seen = {1}
while len(q) > 0:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| p03575 |
from collections import deque
n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = deque()
q.append(1)
seen = {1}
while q:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = [1]
seen = {1}
while len(q) > 0:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| p03575 |
from collections import deque
n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = deque()
q.append(1)
seen = {1}
while q:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| from collections import deque
n, m = list(map(int, input().split()))
eg = [[] for _ in range(n + 1)]
al = [0] * m
bl = [0] * m
for i in range(m):
a, b = list(map(int, input().split()))
eg[a].append(b)
eg[b].append(a)
al[i], bl[i] = a, b
ans = 0
for i in range(m):
x, y = al[i], bl[i]
q = deque()
q.append(1)
seen = {1}
while len(q) > 0:
v = q.pop()
for t in eg[v]:
if t in seen:
continue
elif (v == x and t == y) or (v == y and t == x):
continue
q.append(t)
seen.add(t)
if len(seen) != n:
ans += 1
print(ans)
| p03575 |
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
n,m = list(map(int,input().split())) #n:頂点数 w:辺の数
l=[list(map(int,input().split())) for i in range(m)]
ans=0
#d[u][v] : 辺uvのコスト(存在しないときはinf)
for j in range(m):
d = [[float("inf") for i in range(n)] for i in range(n)]
b=l[:j]+l[j+1:]
for i in range(m-1):
x,y = b[i][0],b[i][1]
x-=1;y-=1
d[x][y] = 1
d[y][x] = 1
for i in range(n):
d[i][i] = 0 #自身のところに行くコストは０
#print(warshall_floyd(d))
for i in range(n):
for k in range(n):
if warshall_floyd(d)[i][k]==float("inf"):
ans+=1
break
else:
continue
break
#print(ans)
print(ans) | import heapq
def dijkstra_heap(s):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
n,w = list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(w)]
ans=0
#edge[i] : iから出る道の[重み,行先]の配列
for j in range(w):
edge = [[] for i in range(n)]
b=l[:j]+l[j+1:]
for i in range(w-1):
x,y = b[i][0],b[i][1]
x-=1;y-=1
z=1
edge[x].append([z,y]) #有向辺
edge[y].append([z,x]) #有向辺
if float("inf") in dijkstra_heap(0):
ans+=1
print(ans) | p03575 |
N, M = [int(_) for _ in input().split()]
paths = [[0] * (N + 1) for _ in range(N + 1)]
def has_path(c, t, arrived):
if c == t: return True
for i in range(1, N + 1):
if i in arrived: continue
if paths[c][i]:
arrived.append(i)
if has_path(i, t, arrived):
return True
arrived.pop()
return False
edge = []
for i in range(M):
a, b = [int(_) for _ in input().split()]
paths[a][b] = 1
paths[b][a] = 1
edge.append((a, b,))
ans = 0
for e in edge:
paths[e[0]][e[1]] = 0
paths[e[1]][e[0]] = 0
if not has_path(e[0], e[1], []):
ans += 1
paths[e[0]][e[1]] = 1
paths[e[1]][e[0]] = 1
print(ans) | N, M = [int(_) for _ in input().split()]
paths = [[0] * (N + 1) for _ in range(N + 1)]
edges = []
for i in range(M):
a, b = [int(_) for _ in input().split()]
paths[a][b] = 1
paths[b][a] = 1
edges.append((a, b))
class UF:
def __init__(self, v):
self.parent = None
self.val = v
@property
def root(self):
if not self.parent:
return self
return self.parent.root
def __str__(self):
if self.parent:
return str(self.val) + ' ' + str(self.parent.val)
return str(self.val) + ' None'
def merge(u1, u2):
r1 = u1.root
r2 = u2.root
if r1 == r2:
return
r1.parent = r2
def chk(a, b):
nodes = [UF(i) for i in range(N + 1)]
for i in range(1, N):
for j in range(i + 1, N + 1):
if paths[i][j]:
merge(nodes[i], nodes[j])
return int(nodes[a].root != nodes[b].root)
ans = 0
for e in edges:
paths[e[0]][e[1]] = 0
paths[e[1]][e[0]] = 0
ans += chk(e[0], e[1])
paths[e[0]][e[1]] = 1
paths[e[1]][e[0]] = 1
print(ans) | p03575 |
N,M=[int(i) for i in input().split()]
graph = [[] for _ in range(N+1)]
from collections import deque
aa = [0] * M
bb = [0] * M
ans = 0
for i in range(M):
a,b = [int(j) for j in input().split()]
graph[a].append(b)
graph[b].append(a)
aa[i] = a
bb[i] = b
import copy
grapha = copy.deepcopy(graph)
for k in range(M):
graph[aa[k]].remove(bb[k])
graph[bb[k]].remove(aa[k])
seen = [False] * (N+1)
from collections import deque
que = deque()
que.append(1)
while len(que) != 0:
x = que.popleft()
seen[x] = True
for i in graph[x]:
if seen[i]:
continue
que.append(i)
seen[i] = True
for l in range(1,N+1):
if seen[l]:
continue
ans +=1
break
graph = copy.deepcopy(grapha)
print(ans) | #template
def inputlist(): return [int(j) for j in input().split()]
from collections import Counter
#template
#issueから始める
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
N,M = inputlist()
ans = 0
ab = [0]*M
for i in range(M):
ab[i] = inputlist()
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j == i:
continue
uf.union(ab[j][0]-1,ab[j][1]-1)
if len(uf.roots()) != 1:
ans +=1
print(ans) | p03575 |
import copy
#深さ優先探索
def dfs(node, E_st_tmp):
#辺の集合が存在しないとき
if len(E_st_tmp) == 0:
#全ての頂点を覗いた時
if not (False in V_look):
return
else:#辺の集合もないし、頂点もない。
return
elif not (False in V_look): #辺の集合があっても全部見る時ある。
return
#ここで探索する
for i in range(V):
E_st_tmp_copy = copy.copy(E_st_tmp)
if {node, i} in E_st_tmp_copy:
V_look[i] = True
E_st_tmp_copy.remove({node, i})
dfs(i, E_st_tmp_copy)
return
#連結かどうかのチェックする
V, E = list(map(int, input().split()))
V_set = [v for v in range(V)]
E_set = []
for _ in range(E):
a,b = list(map(int, input().split()))
E_set.append({a-1, b-1})
count = 0
for edge in E_set:
E_set_cut = copy.copy(E_set)
E_set_cut.remove(edge)
#全ての頂点を覗いたか?
V_look = [False] * V
V_look[0] = True
#深さ優先探索
for v in range(V):
E_set_copy = copy.copy(E_set_cut)
if {0, v} in E_set_copy:
V_look[v] = True
E_set_copy.remove({0, v})
flg_t = dfs(v, E_set_copy)
if (False in V_look):
count += 1
print(count)
| import sys
import copy
N, M = list(map(int, input().split()))
V = []
E = []
for i in range(N):
V.append(set())
seen = []
seen = [False] * N
count = 0
def dfs(node):
global V
global seen
#注目ノードは訪問済みか?
if seen[node]==True:
return
seen[node]=True
for next_node in V[node]:
dfs(next_node)
return
for i in range(M):
*l, = list(map(int, input().split()))
V[l[0]-1].add(l[1]-1)
V[l[1]-1].add(l[0]-1)
E.append([l[0]-1, l[1]-1])
E_copy = copy.deepcopy(E)
V_copy = copy.deepcopy(V)
seen_copy = copy.deepcopy(seen)
for i in range(M):
e = [E[i][0], E[i][1]]
V[e[0]].remove(e[1])
V[e[1]].remove(e[0])
dfs(0)
if (False in seen):
count = count + 1
seen = [False] * N
V = copy.deepcopy(V_copy)
print(count)
| p03575 |
import copy
N,M = list(map(int,input().split()))
graph = [[] for _ in range(N)]
edges = []
for _ in range(M):
a,b = list(map(int,input().split()))
graph[a-1].append(b-1)
graph[b-1].append(a-1)
edges.append([a-1,b-1])
def dfs(G,v):
seen[v] = True
#print(seen)
for nv in G[v]:
#print(nv)
if seen[nv]:
continue
dfs(G,nv)
ans = 0
for edge in edges:
seen = [False] * N
copied_graph = copy.deepcopy(graph)
copied_graph[edge[0]].remove(edge[1])
copied_graph[edge[1]].remove(edge[0])
dfs(copied_graph,0)
if not all(seen):
ans += 1
print(ans) | N,M = list(map(int,input().split()))
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x,y):
x = find(x)
y = find(y)
if x == y:
return False
else:
if par[x] > par[y]:
x,y = y,x
par[x] += par[y]
par[y] = x
return True
def same(x,y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
a = [0]*M
b = [0]*M
for i in range(M):
a[i], b[i] = list(map(int,input().split()))
a[i] -= 1
b[i] -= 1
# 一つの辺以外を繋いでその辺の両端の点が同じ集合に属していたらその辺は橋ではない
ans = 0
for i in range(M):
par = [-1] * (N + 1)
for j in range(M):
if i != j:
unite(a[j],b[j])
if not same(a[i],b[i]):
ans += 1
print(ans)
| p03575 |
def DFS(N, copyedge):
matrix = [[] for i in range(N)]
for a, b in copyedge:
matrix[a].append(b)
matrix[b].append(a)
check = [True]*N
check[0] = False
Que = [0]
while len(Que) != 0:
now = Que.pop()
for i in matrix[now]:
if check[i] == True:
check[i] = False
Que.append(i)
if True not in check:
return 0
else:
return 1
ans = 0
N, M = list(map(int, input().split()))
edge = []
for i in range(M):
edge.append([int(i) - 1 for i in input().split()])
for i in range(M):
copyedge = edge[:i] + edge[i+1:]
ans += DFS(N, copyedge)
print(ans) | N, M = list(map(int, input().split()))
ab = [[] for i in range(M)]
ans = 0
for i in range(M):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
ab[i] = [a, b]
def cal(AB):
matrix = [[] for i in range(N)]
for a, b in AB:
matrix[a].append(b)
matrix[b].append(a)
check = [0] * N
check[0] = 1
deque = [0]
while deque:
now = deque.pop()
for i in matrix[now]:
if check[i] == 0:
deque.append(i)
check[i] = 1
if len(set(check)) == 1:
return 0
else:
return 1
for i in range(M):
AB = ab[:]
del AB[i]
ans += cal(AB)
print(ans) | p03575 |
from collections import deque
n, m = list(map(int, input().split()))
E = [[*[int(x)-1 for x in input().split()]] for _ in range(m)]
V = [[] for _ in range(n)]
for a,b in E:
V[a].append(b)
V[b].append(a)
def dfs(a,b,f,i):
# if i>=n:
# return
if vis[f] == 1: return
vis[f] = 1
# print('f',f)
for t in V[f]:
if f==a and t == b: continue
# if t == b: continue
if vis[t] == 1: continue
# print(t)
dfs(a,b,t,i+1)
ans = 0
for a, b in E:
vis = [0]*n
dfs(a,b,a,1)
# print(a,b,vis)
if vis[b] == 0:
ans += 1
# print('----')
# print(E)
# print(V)
print(ans)
| n, m = list(map(int, input().split()))
E = [[*[int(x)-1 for x in input().split()]] for _ in range(m)]
V = [[] for _ in range(n)]
for a, b in E:
V[a].append(b)
V[b].append(a)
def dfs(a, b, f):
if vis[f] == 1: return
vis[f] = 1
for t in V[f]:
if f==a and t == b: continue
dfs(a, b, t)
ans = 0
for a, b in E:
vis = [0]*n
dfs(a, b, a)
if vis[b] == 0: ans += 1
print(ans)
| p03575 |
from collections import deque
def dfs(n, start, graph):
visited = [False] * n
stack = deque()
stack.append(start)
visited[start] = True
while stack:
q = stack.popleft()
nxts = graph[q]
for nxt in nxts:
if not visited[nxt]:
visited[nxt] = True
stack.append(nxt)
return visited
n, m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for _ in range(m)]
ans = 0
for i in range(m):
graph = [[] for _ in range(n)]
for itr, (a, b) in enumerate(edge):
if itr != i:
graph[a - 1].append(b - 1)
graph[b - 1].append(a - 1)
if not all(dfs(n, 0, graph)):
ans += 1
print(ans) | n,m=list(map(int,input().split()))
edge=[[] for _ in range(n+1)]
eab=[]
for i in range(m):
a,b=list(map(int,input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
eab.append([a-1,b-1])
def dfs(visited,count,node):
visited[node]=True
count+=1
ev=edge[node]
for node in ev:
if visited[node]:
continue
else:
count=dfs(visited,count,node)
return count
ans=0
for i in range(m):
a,b=eab[i]
edge[a].remove(b)
edge[b].remove(a)
ci=dfs([False for _ in range(n)],0,0)
if ci!=n:
ans+=1
edge[a].append(b)
edge[b].append(a)
print(ans) | p03575 |
from collections import defaultdict as dd
n,m = list(map(int, input().split()))
dic = dd(list)
l = []
cnt = 0
for _ in range(m):
a,b = list(map(int, input().split()))
l.append((a,b))
dic[a].append(b)
dic[b].append(a)
def con(x):
visit.add(x)
for i in dic[x]:
if i in visit:
continue
con(i)
return visit == set(range(1,n+1))
for x,y in l:
dic[x].remove(y)
dic[y].remove(x)
visit = set()
if not con(x):
cnt += 1
dic[x].append(y)
dic[y].append(x)
print(cnt) | int1 = lambda x: int(x) - 1
N, M = list(map(int, input().split()))
G = [list() for _ in range(N)]
edges = [tuple(map(int1, input().split())) for _ in range(M)]
for u,v in edges:
G[u].append(v)
G[v].append(u)
pre = [-1]*N
low = [-1]*N
def detect_bridge(v, p=None, c=0):
ret = list()
pre[v] = low[v] = c
c += 1
for x in G[v]:
if x == p: continue
if pre[x] < 0:
br, c = detect_bridge(x, v, c)
ret.extend(br)
if low[v] > low[x]: low[v] = low[x]
if pre[v] == low[v] > 0:
ret.append((p, v))
return ret, c
bridges, _ = detect_bridge(0)
print((len(bridges))) | p03575 |
from collections import deque
from collections import defaultdict
edges = defaultdict(list)
N,M = list(map(int, input().split()))
pairs = []
for i in range(M):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
pairs.append((a,b))
ans = 0
# M本目の辺を切って全探索
for i in range(M):
edges = defaultdict(list)
s = 0
for j,(a,b) in enumerate(pairs):
if i == j:continue
edges[a].append(b)
edges[b].append(a)
s = b
cnt = 0
# print(i,edges)
# bfs
seen = [False] * N
q = deque()
q.append(b)
while len(q) > 0:
e = q.popleft()
nx = edges[e]
for n in nx:
if seen[n]:continue
seen[n] = True
q.append(n)
if sum(seen) != N:
ans += 1
print(ans)
| """
DFS
"""
from collections import defaultdict
N,M = list(map(int, input().split()))
pairs = []
for i in range(M):
a,b = list(map(int, input().split()))
a -= 1
b -= 1
pairs.append((a,b))
def dfs(s):
global visited,edges
if visited[s]:return 0
visited[s] = True
ns = edges[s]
for n in ns:
dfs(n)
ans = 0
for i in range(M):
edges = defaultdict(list)
visited = [False] * N
for j,(a,b) in enumerate(pairs):
if i == j: continue
edges[b].append(a)
edges[a].append(b)
dfs(0)
if sum(visited) != N:
ans += 1
print(ans) | p03575 |
def main():
from collections import deque
def traversal(ignore_idx):
s = 0
visited = [-1] * N
visited[s] = 0
dq = deque([s])
while dq:
v = dq.popleft()
for u, edge_idx in g[v]:
if ~visited[u] or edge_idx == ignore_idx:
continue
dq.append(u)
visited[u] = 0
return all(~flg for flg in visited) # 連結ならTrue
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N))
for edge_idx in range(M):
a, b = (int(x) - 1 for x in input().split())
g[a].add((b, edge_idx))
g[b].add((a, edge_idx))
ret = 0
for ignore_idx in range(M):
res = traversal(ignore_idx)
if not res:
ret += 1
print(ret)
if __name__ == '__main__':
main()
| def main():
from collections import deque
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N))
es = []
for _ in range(M):
a, b = (int(x) - 1 for x in input().split())
g[a].add(b)
g[b].add(a)
es.append((a, b))
cnt = 0
for e in es:
v = 0
dq = deque()
dq.append(v)
used = [False] * N
used[v] = True
while dq:
v = dq.popleft()
for u in g[v]:
if used[u]: continue
if (v, u) == e or (u, v) == e: continue
used[u] = True
dq.append(u)
if all(used): continue
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| p03575 |
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N, M = MI()
V = [[] for _ in range(N)]
E = []
for i in range(M):
a, b = MI1()
V[a].append(b)
V[b].append(a)
E.append((a, b))
ans = 0
for a, b in E:
used = [0] * N
flag = True
q = deque([a])
used[a] = 1
while q:
cur = q.popleft()
for nv in V[cur]:
if (a, b) == (cur, nv) or (a, b) == (nv, cur):
continue
if used[nv]:
continue
if nv == b:
flag = False
q = []
break
q.append(nv)
used[nv] = 1
# print(a, b, q)
if flag:
ans += 1
print(ans)
if __name__ == '__main__':
solve()
| import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque, defaultdict
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
"""
https://note.nkmk.me/python-union-find/
素集合データ構造
:parameter
union(x, y): 2つの集合を一つに併合する
find(x): xがどの集合に属しているかを判定する
size(x): 要素xが属するグループのサイズ（要素数）を返す
same(x, y): 要素x, yが同じグループに属するかどうかを返す
members(x): 要素xが属するグループに属する要素をリストで返す
roots(): 全ての根の要素をリストで返す
group_count(): グループの数を返す
all_group_members(): 辞書を返す。 key = ルート要素, value = そのグループに含まれる要素のリスト
__str__(): print()での表示用。ルート要素: [そのグループに含まれる要素のリスト]を文字列で返す
"""
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def all_group_count(self):
return [self.size(r) for r in self.roots()]
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
N, M = MI()
E = []
for i in range(M):
a, b = MI1()
E.append((a, b))
ans = 0
for a, b in E:
uf = UnionFind(N)
for v1, v2 in E:
if (v1, v2) == (a, b):
continue
uf.union(v1, v2)
# print(uf.group_count())
if uf.group_count() > 1:
ans += 1
print(ans)
if __name__ == '__main__':
solve()
| p03575 |
from queue import Queue
N, M = list(map(int, input().split()))
a, b = [0] * M, [0] * M
g = [[False] * N for _ in range(N)]
for i in range(M):
a[i], b[i] = list(map(int, input().split()))
g[a[i]-1][b[i]-1] = True
g[b[i]-1][a[i]-1] = True
ans = 0
for _a, _b in zip(a, b):
g[_a-1][_b-1] = False
g[_b-1][_a-1] = False
visit = [False] * N
q = Queue()
q.put(0)
while not q.empty():
v = q.get()
visit[v] = True
for adj_v, adj in enumerate(g[v]):
if not adj or visit[adj_v]:
continue
q.put(adj_v)
if not all(visit):
ans += 1
g[_a-1][_b-1] = True
g[_b-1][_a-1] = True
print(ans) | class UnionFind(object):
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self._size = n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x != y:
self._size -= 1
if self.rank[x] < self.rank[y]:
x, y = y, x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
self.par[y] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
def size(self):
return self._size
N, M = list(map(int, input().split()))
a, b = [0] * M, [0] * M
for i in range(M):
a[i], b[i] = list(map(int, input().split()))
ans = 0
for i in range(M):
uf = UnionFind(n=N)
for j in range(M):
if j == i:
continue
uf.union(a[j]-1, b[j]-1)
if uf.size() != 1:
ans += 1
print(ans) | p03575 |
N, M = list(map(int,input().split())) # N:ノード数、M:エッジ数
visited = [False for i in range(N)] # ノードの訪問済みフラグ
edges = [[i-1 for i in map(int,input().split())] for j in range(M)] # エッジ情報のインプット
graph = [[False for i in range(N)] for j in range(N)] # 接続行列の入れ物
# 各エッジについて、情報を接続行列に埋め込む
for edge in edges:
graph[edge[0]][edge[1]] = True
graph[edge[1]][edge[0]] = True
# dfs:ノードvについて、エッジで接続した未訪問のノードを即時訪問する(再帰処理)
def dfs(v):
queue = [v]
while len(queue) != 0:
now = queue.pop(0)
visited[now] = True
for next in range(N):
if graph[now][next] == False:continue
if visited[next] == True:continue
queue.append(next)
ans = 0
# 各エッジを取り除いたとき、dfsして未訪問のノードが残っていれば、そのエッジは橋
for i in range(M):
graph[edges[i][0]][edges[i][1]] = False
graph[edges[i][1]][edges[i][0]] = False
for j in range(N):
visited[j] = False
dfs(0)
bridge = False
for j in range(N):
if visited[j] == False:
bridge = True
if bridge:
ans += 1
graph[edges[i][0]][edges[i][1]] = True
graph[edges[i][1]][edges[i][0]] = True
print(ans)
| N, M = list(map(int,input().split())) # N:ノード数、M:エッジ数
visited = [False for i in range(N)] # ノードの訪問済みフラグ
edges = [[i-1 for i in map(int,input().split())] for j in range(M)] # エッジ情報のインプット
graph = [[False for i in range(N)] for j in range(N)] # 接続行列の入れ物
# 各エッジについて、情報を接続行列に埋め込む
for edge in edges:
graph[edge[0]][edge[1]] = True
graph[edge[1]][edge[0]] = True
# dfs:ノードvについて、エッジで接続した未訪問のノードを深いほうから訪問(LIFO)
def dfs(v):
queue = [v]
while len(queue) != 0:
now = queue.pop()
visited[now] = True
for next in range(N):
if graph[now][next] == False:continue
if visited[next] == True:continue
queue.append(next)
ans = 0
# 各エッジを取り除いたとき、dfsして未訪問のノードが残っていれば、そのエッジは橋
for i in range(M):
graph[edges[i][0]][edges[i][1]] = False
graph[edges[i][1]][edges[i][0]] = False
for j in range(N):
visited[j] = False
dfs(0)
bridge = False
for j in range(N):
if visited[j] == False:
bridge = True
if bridge:
ans += 1
graph[edges[i][0]][edges[i][1]] = True
graph[edges[i][1]][edges[i][0]] = True
print(ans)
| p03575 |
# coding: utf-8
N, M = list(map(int, input().split()))
graph = [[False for i in range(N)] for j in range(N)]
visited = [False for i in range(N)]
def dfs(v):
visited[v] = True
for k in range(N):
if not graph[v][k]:
continue
if visited[k]:
continue
dfs(k)
A, B = [], []
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
A.append(a)
B.append(b)
graph[a][b] = True
graph[b][a] = True
ans = 0
for a, b in zip(A, B):
graph[a][b] = False
graph[b][a] = False
visited = [False for i in range(N)]
dfs(0)
bridge = False
for j in range(N):
if not visited[j]:
bridge = True
if bridge:
ans += 1
graph[a][b] = True
graph[b][a] = True
print(ans)
| # coding: utf-8
N, M = list(map(int, input().split()))
graph = [[False for i in range(N)] for j in range(N)]
visited = [False for i in range(N)]
def dfs(v):
visited[v] = True
for k in range(N):
# 橋がなければわたらない
if not graph[v][k]:
continue
# すでに訪れていたら渡らない
if visited[k]:
continue
dfs(k)
A, B = [], []
for i in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
A.append(a)
B.append(b)
# 橋をTrueとして表す
graph[a][b] = True
graph[b][a] = True
ans = 0
# a, bの橋が通れないとして都度DFSを実行
for a, b in zip(A, B):
graph[a][b] = False
graph[b][a] = False
visited = [False for i in range(N)]
dfs(0)
bridge = False
for j in range(N):
if not visited[j]:
bridge = True
# 渡れない島があったら+1
if bridge:
ans += 1
graph[a][b] = True
graph[b][a] = True
print(ans) | p03575 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def unite(x,y):
x = root(x)
y = root(y)
if rank[x] < rank[y]:
par[x] = y
else:
par[y] = x
if rank[x] == rank[y]:
rank[x] += 1
n,m = LI()
v = LIR(m)
for i in range(m):
v[i][0] -= 1
v[i][1] -= 1
ans = 0
for i in range(m):
par = [i for i in range(n)]
rank = [0]*n
s = 1
for j in range(m):
if i == j:
continue
a,b = v[j]
if root(a) != root(b):
s += 1
if s >= n:
break
unite(a,b)
else:
ans += 1
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
cnt = 0
def solve():
def lowlink(v):
global cnt
def dfs(x):
global cnt
for y in v[x]:
if pre[y] is None:
cnt += 1
pre[y] = low[y] = cnt
par[y] = x
py = dfs(y)
if py < low[x]:
low[x] = py
else:
if par[x] != y and pre[y] < low[x]:
low[x] = pre[y]
if pre[x] < low[y]:
res.append((x,y))
return low[x]
pre = [None]*n
low = [None]*n
par = [None]*n
res = []
for x in range(n):
if pre[x] is None:
pre[x] = low[x] = cnt
dfs(x)
return res
n,m = LI()
v = [[] for i in range(n)]
for i in range(m):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
ans = lowlink(v)
print((len(ans)))
return
#Solve
if __name__ == "__main__":
solve()
| p03575 |
N, M = list(map(int, input().split()))
E = [list(map(int, input().split())) for k in range(M)]
ans = 0
for k in range(M):
F = E[:k]+E[k+1:]
D = [[10**9+7 for l in range(N)] for m in range(N)]
for p in range(N):
D[p][p] = 0
for n in F:
D[n[0]-1][n[1]-1] = D[n[1]-1][n[0]-1] = 1
for s in range(N):
for t in range(N):
for u in range(N):
if D[t][u] > D[t][s] + D[s][u]:
D[t][u] = D[t][s] + D[s][u]
f = 0
for p in range(N):
for q in range(N):
if D[p][q] > N:
f = 1
ans += f
print(ans) | N, M = list(map(int,input().split()))
P = [list(map(int,input().split())) for k in range(M)]
ans = 0
for i in range(M):
T = P[:i]+P[i+1:]
G = [[] for k in range(N)]
V = [0 for k in range(N)]
for e in T:
G[e[0]-1].append(e[1]-1)
G[e[1]-1].append(e[0]-1)
def dfs(visited,graph,ima):
for e in graph[ima]:
if visited[e] == 0:
visited[e] = 1
dfs(visited,graph,e)
dfs(V,G,0)
if sum(V) != N:
ans += 1
print(ans)
| p03575 |
import copy
N,M=list(map(int,input().split()))
A=[]
L=[[1000for i in range(N)]for j in range(N)]
for i in range(M):
a,b=list(map(int,input().split()))
A.append([a,b])
L[a-1][b-1]=1
L[b-1][a-1]=1
for j in range(N):
L[j][j]=0
#print(L)
l=copy.deepcopy(L)
cnt=0
for k in range(M):
L=copy.deepcopy(l)
L[A[k][0]-1][A[k][1]-1]=1000
L[A[k][1]-1][A[k][0]-1]=1000
for x in range(N):
for y in range(N):
for z in range(N):
if L[y][z]>L[y][x]+L[x][z]:
L[y][z]=L[y][x]+L[x][z]
#print(L[A[k][0]-1][A[k][1]-1])
if L[A[k][0]-1][A[k][1]-1]>=1000:
cnt+=1
L[A[k][0]-1][A[k][1]-1]=1
L[A[k][1]-1][A[k][0]-1]=1
#print(L)
print(cnt) | import copy
N,M=list(map(int,input().split()))
A=[]
for i in range(M):
a,b=list(map(int,input().split()))
A.append([a,b])
ANS=0
for i in range(M):
L=[[]for _ in range(N+1)]
for j in range(M):
if i==j:
continue
else:
L[A[j][0]].append((A[j][1],A[j][0]))
L[A[j][1]].append((A[j][0],A[j][1]))
X=1
C=[100 for i in range(N+1)]
C[1]=1
C[0]=1
Q=L[1]
#print(L)
for j in range(1000):
if len(Q)==j:
break
if C[Q[j][0]]==100:
C[Q[j][0]]=C[Q[j][1]]+1
for k in L[Q[j][0]]:
if C[k[0]]==100:
Q.append((k[0],k[1]))
#print(Q)
#print(C)
if 100 in C:
ANS+=1
print(ANS) | p03575 |
n,m=list(map(int,input().split()))
g=[[] for i in range(1+n)]
v=[0]*(1+n)
e=[]
for i in range(m):
a,b=list(map(int,input().split()))
e.append((a,b))
g[a].append(b)
g[b].append(a)
def dfs(st,ed):
q=[]
q.append(st)
while q:
cur=q.pop()
v[cur]=1
if cur==ed:
return True
for nb in g[cur]:
#if v[nb]!=1:
if v[nb]!=1 and (cur,nb)!=(st,ed):
q.append(nb)
#print(st,ed,v)
return False
ans=0
for a,b in e:
v=[0]*(1+n)
#v[b]=1
if not dfs(a,b):
ans+=1
#print(g)
print(ans)
| n,m=list(map(int,input().split()))
g=[[] for i in range(1+n)]
v=[0]*(1+n)
e=[]
for i in range(m):
a,b=list(map(int,input().split()))
e.append((a,b))
g[a].append(b)
g[b].append(a)
def dfs(st,ed):
q=[]
q.append(st)
while q:
cur=q.pop()
v[cur]=1
if cur==ed:
return True
for nb in g[cur]:
if v[nb]!=1 and (cur,nb)!=(st,ed):
q.append(nb)
return False
ans=0
for a,b in e:
v=[0]*(1+n)
if not dfs(a,b):
ans+=1
print(ans) | p03575 |
from collections import deque
N, M = list(map(int, input().split()))
V = [list(map(int, input().split())) for _ in range(M)]
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
return True
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
ans = 0
for i in range(N):
for j in range(i+1, N):
uf = UnionFind(N)
for a, b in V:
if a-1 == i and b-1 ==j:
continue
uf.union(a-1, b-1)
if not uf.same(i, j):
ans += 1
print(ans)
| from collections import deque
N, M = list(map(int, input().split()))
V = [list(map(int, input().split())) for _ in range(M)]
class UnionFind():
def __init__(self, n):
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
return True
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
ans = 0
for i in range(M):
uf = UnionFind(N)
for j, (a, b) in enumerate(V):
if i != j:
uf.union(a-1, b-1)
if not uf.same(V[i][0]-1, V[i][1]-1):
ans += 1
print(ans)
| p03575 |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return 0
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def size(self, x):
return -self.root[self.find(x)]
n,m,*l = list(map(int,open(0).read().split()))
edges = [(a,b) for a,b in zip(l[::2],l[1::2])]
ans = 0
for i in range(m):
uf = UnionFind(n)
for j in range(m):
if i==j:
continue
else:
a,b = edges[j]
uf.unite(a,b)
ans += uf.size(a)<n
print(ans) | import sys
input = sys.stdin.buffer.readline
n,m=list(map(int,input().split()))
es=[list(map(int,input().split())) for _ in range(m)]
def check(s,t):
q=[0]
vis=[0]*n
vis[0]=1
while q:
c=q.pop()
for x in con[c]:
if (c==s and x==t) or (c==t and x==s) or vis[x]:
continue
vis[x]=1
q.append(x)
return not all(vis)
con=[[] for _ in range(n)]
for s,t in es:
con[s-1]+=t-1,
con[t-1]+=s-1,
print((sum(check(s-1,t-1) for s,t in es))) | p03575 |
from collections import deque
n,m = list(map(int,input().split()))
G = [[0]*n for _ in range(n)]
E = []
for i in range(m):
a,b = list(map(int,input().split()))
a,b = a-1, b-1
G[a][b] = 1
G[b][a] = 1
E.append((a,b))
ans = 0
for e in E:
del_a, del_b = e
#対象の辺を消す
G[del_a][del_b] = 0
G[del_b][del_a] = 0
que = ([0])
visited = [False]*n
while que:
node = que.pop()
if visited[node] == True:
continue
visited[node] = True
for j in range(n):
if G[node][j] == 1:
que.append(j)
if False in visited:
ans += 1
#対象の辺を戻す
G[del_a][del_b] = 1
G[del_b][del_a] = 1
print(ans) | class UnionFind:
#要素数nで初期化
#インスタンス変数の初期化
def __init__(self, n):
#root : 木の要素数
#rnk : 木の高さ(rank)
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
"""ノードxのrootノードを見つける"""
def Find_Root(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
"""木の合併"""
def Union(self, x, y):
#入力ノードの親を探索
x = self.Find_Root(x)
y = self.Find_Root(y)
#既に同じ木に所属する場合
if (x==y):
return
#異なる木に所属する場合 -> rnkから判断して合併する
elif (self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
#rnkが同じ(深さが同じ)場合
if self.rnk[x]==self.rnk[y]:
self.rnk[y] += 1
"""xとyが同じグループに所属するか"""
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
"""ノードxが属する木のサイズ"""
def Count(self, x):
return -self.root[self.Find_Root(x)]
n,m = list(map(int,input().split()))
edge = []
for i in range(m):
a,b = list(map(int,input().split()))
edge.append([a,b])
res = 0
for i in range(m):
tmp_edge = edge[:i] + edge[i+1:]
uf = UnionFind(n)
for j in range(len(tmp_edge)):
uf.Union(tmp_edge[j][0], tmp_edge[j][1])
if not uf.isSameGroup(edge[i][0], edge[i][1]):
res += 1
print(res) | p03575 |
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
edges = [(0,0) for _ in range(M)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
edges[i] = (a-1,b-1)
import sys
sys.setrecursionlimit(10**8)
def dfs(v, es):
#print(h,w)
if len(es[v])==0:
return 0
for u in es[v]:
if visited[u]==False:
visited[u]=True
dfs(u,es)
return 0
import copy
ans = 0
for i in range(M):
visited = [False]*N
a,b = edges[i]
es = copy.deepcopy(edge)
# print(edge,a,b)
es[a].remove(b)
es[b].remove(a)
for v in range(N):
if visited[v]==False:
visited[v]=True
dfs(v,es)
if False in visited:
# print(a,b)
break
else:
continue
ans += 1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def nums(self,x):
return abs(self.parents[self.find(x)])
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
A = [0]*M
B = [0]*M
for i in range(M):
A[i],B[i] = list(map(int, input().split()))
ans = 0
for i in range(M):
uf = UnionFind(N)
for j in range(M):
if j!=i:
uf.union(A[j]-1,B[j]-1)
if len(uf.roots())>1:
ans += 1
print(ans) | p03575 |
#!/usr/bin/env python3
from pprint import pprint
from collections import deque, defaultdict
import itertools
import math
import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.buffer.readline
INF = float('inf')
n_nodes, m_edges = list(map(int, input().split()))
edges = []
for _ in range(m_edges):
u, v = list(map(int, input().split()))
edges.append([u - 1, v - 1])
# pprint(edges)
def find_root(v):
if v != parents[v]:
parents[v] = find_root(parents[v])
return parents[v]
def has_same_root(u, v):
return find_root(u) == find_root(v)
def unite(u, v):
root_u, root_v = find_root(u), find_root(v)
if root_u == root_v:
return
if rank[root_u] < rank[root_v]:
root_u, root_v = root_v, root_u
parents[root_v] = root_u
rank[root_u] += rank[root_v]
res = 0
for i in range(m_edges):
parents = [i for i in range(n_nodes)]
rank = [1] * n_nodes
for j in range(m_edges):
if i == j:
continue
u, v = edges[j]
if not has_same_root(u, v):
unite(u, v)
# pprint(parents)
count = 0
for v in range(n_nodes):
if parents[v] == v:
count += 1
if count > 1:
res += 1
print(res)
| #!/usr/bin/env python3
from pprint import pprint
import sys
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
u, v = list(map(int, input().split()))
edges.append([u-1, v-1])
# pprint(edges)
# ある辺iを除いた残りの辺にそれぞれに対してuniteの操作を行ったのち、異なるparentsの数を数える
# 連結グラフであれば、異なるparentsの数は1になる
# 非連結グラフであれば、異なるparentsの数は2以上になる
def root(v):
if parents[v] == v:
return v
parents[v] = root(parents[v])
return parents[v]
def unite(u, v):
u_root = root(u)
v_root = root(v)
if u_root == v_root:
return
parents[u_root] = v_root
def same(u, v):
return root(u) == root(v)
ans = 0
for e_i in edges:
parents = [i for i in range(N)]
for e_j in edges:
if e_i == e_j:
continue
u, v = e_j
if not same(u, v):
unite(u, v)
count = 0
for v in range(N):
if parents[v] == v:
count += 1
if count > 1:
ans += 1
print(ans)
| p03575 |
n,m=list(map(int,input().split()))
e=[[] for _ in range(n)]
b=[]
for i in range(m):
x,y=list(map(int,input().split()))
e[x-1].append(y-1)
e[y-1].append(x-1)
b.append([x-1,y-1])
def ne(now,s,visit):
visit.append(now)
for i in e[now]:
if i not in visit:
ne(i, s, visit[:])
elif len(visit)>2 and s==i:
v1=visit[1]
v2=visit[-1]
if [s,v1] in b: b.remove([s,v1])
elif [v1,s] in b: b.remove([v1,s])
if [s,v2] in b:b.remove([s,v2])
elif [v2,s] in b:b.remove([v2,s])
break
for i in range(n):
ne(i,i,[])
print((len(b))) | from itertools import combinations
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
elif(self.rnk[x] > self.rnk[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rnk[x] == self.rnk[y]):
self.rnk[y] += 1
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x):
return -self.root[self.Find_Root(x)]
n,m=list(map(int,input().split()))
uf=UnionFind(n)
e=[]
comb=list(combinations(list(range(n)),2))
for _ in range(m):
a,b=list(map(int,input().split()))
e.append((a-1,b-1))
ans=0
for i in range(m):
uf=UnionFind(n)
for j in range(m):
if i==j:continue
uf.Unite(*e[j])
if not all([uf.isSameGroup(x,y) for x,y in comb]):ans+=1
print(ans) | p03575 |
def root(i):
if par[i] < 0:
return i
else:
return root(par[i])
def size(a):
return -par[root(a)]
def union(a,b):
a = root(a)
b = root(b)
if a == b:#親が等しい
return False
if size(a) < size(b):#サイズが大きい方に繋げる
a,b = b,a
par[a] += par[b]
par[b] = a
return True
n,m = list(map(int,input().split()))
bridge = []
for i in range(m):
bridge.append([int(j)-1 for j in input().split()])
ans = 0
for i in range(m):
par = [-1 for _ in range(n)]
for j in range(m):
if j != i:
union(bridge[j][0],bridge[j][1])
cnt = [ i for i in par if i < 0]
if len(cnt) > 1:
ans += 1
print(ans) | def dfs(current):
for maps in Graph[current]:
if maps in already:
continue
else:
already.append(maps)
dfs(maps)
n,m = list(map(int,input().split()))
ans = 0
Edges = []
for _ in range(m):
Edges.append([int(j)-1 for j in input().split()])
for i in range(m):
egdes = Edges[0:i]+Edges[i+1:]
Graph = [[] for _ in range(n)]
for edge in egdes:
Graph[edge[0]].append(edge[1])
Graph[edge[1]].append(edge[0])
already = []
dfs(0)
if len(already) != n:
ans += 1
print(ans) | p03575 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
import copy
N, M = mi()
D = dp2(float('inf'), N, N)
memo = []
cnt = 0
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
D[s][t] = D[t][s] = 1
for x in range(M):
d = copy.deepcopy(D)
s, t = memo[x][0], memo[x][1]
d[s][t] = d[t][s] = float('inf')
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
for i in range(N):
for j in range(i+1, N):
if d[i][j] == float('inf'):
cnt += 1
break
else:
continue
break
print(cnt) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
## UnionFind
N, M = mi()
memo = []
rel = [[] for i in range(N)]
#d = dp2(float('inf'), N, N)
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
rel[s].append(t)
rel[t].append(s)
#d[s][t] = d[t][s] = 1
#print(d)
def dfs(v):
#print(v, used)
for nv in rel[v]:
#for nv in range(N):
if not used[nv]:
#if d[v][nv] != float('inf') and not used[nv]:
used[nv] = 1
dfs(nv)
if sum(used) == N:
global flag
flag = True
return
#used[nv] = 0
cnt = M
for x in range(M):
s, t = memo[x][0], memo[x][1]
rel[s].remove(t)
rel[t].remove(s)
#print(rel)
#print(s, t)
#d[s][t] = d[t][s] = float('inf')
#print(d)
for i in range(N):
#print(x, i)
flag = 0
used = [0]*N
used[i] = 1
dfs(i)
#print(flag)
if flag:
cnt -= 1
break
rel[s].append(t)
rel[t].append(s)
#d[s][t] = d[t][s] = 1
print(cnt) | p03575 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
## UnionFind
N, M = mi()
memo = []
rel = [[] for i in range(N)]
#d = dp2(float('inf'), N, N)
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
rel[s].append(t)
rel[t].append(s)
#d[s][t] = d[t][s] = 1
#print(d)
def dfs(v):
#print(v, used)
for nv in rel[v]:
#for nv in range(N):
if not used[nv]:
#if d[v][nv] != float('inf') and not used[nv]:
used[nv] = 1
dfs(nv)
if sum(used) == N:
global flag
flag = True
return
#used[nv] = 0
cnt = M
for x in range(M):
s, t = memo[x][0], memo[x][1]
rel[s].remove(t)
rel[t].remove(s)
#print(rel)
#print(s, t)
#d[s][t] = d[t][s] = float('inf')
#print(d)
for i in range(N):
#print(x, i)
flag = 0
used = [0]*N
used[i] = 1
dfs(i)
#print(flag)
if flag:
cnt -= 1
break
rel[s].append(t)
rel[t].append(s)
#d[s][t] = d[t][s] = 1
print(cnt) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
## DFS
N, M = mi()
memo = []
rel = [[] for i in range(N)]
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
rel[s].append(t)
rel[t].append(s)
def dfs(v):
for nv in rel[v]:
if not used[nv]:
used[nv] = 1
dfs(nv)
if sum(used) == N:
global flag
flag = 1
return
cnt = M
for x in range(M):
s, t = memo[x][0], memo[x][1]
rel[s].remove(t)
rel[t].remove(s)
flag = 0
used = [0]*N
dfs(0)
if flag:
cnt -= 1
rel[s].append(t)
rel[t].append(s)
print(cnt) | p03575 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
## DFS
from collections import deque
N, M = mi()
memo = []
rel = [[] for i in range(N)]
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
rel[s].append(t)
rel[t].append(s)
cnt = 0
que = deque()
for x in range(M):
s, t = memo[x][0], memo[x][1]
rel[s].remove(t)
rel[t].remove(s)
que.append(0)
used = [0]*N
while que != deque():
v = que.popleft()
for nv in rel[v]:
if not used[nv]:
used[nv] = 1
que.append(nv)
if sum(used) != N:
cnt += 1
rel[s].append(t)
rel[t].append(s)
print(cnt) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
## ダイクストラ
import heapq
def dijkstra_heap(s, edge):
#始点sから各頂点への最短距離
###edge=[[e[0]:コスト, e[1]：目的地]...]
#O(ElogV)
d = [float("inf")] * N #各頂点への最小距離を記憶
used = [True] * N #True:未確定
d[s] = 0 #スタート地点は0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e) #スタート地点につながった頂点をプッシュ
while len(edgelist):
minedge = heapq.heappop(edgelist) #一番距離が小さいものを取り出す
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]: #既に最短距離確定済みだったらスルー
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
if e[0]+d[v] > d[e[1]]: #既に求まってる最短距離以上なら枝刈り
continue
heapq.heappush(edgelist, [e[0]+d[v], e[1]]) #最小値更新した頂点につながった頂点をプッシュ
return d
N, M = mi()
memo = []
rel = [[] for i in range(N)]
for i in range(M):
s, t = mi()
s, t = s-1, t-1
memo.append((s, t))
rel[s].append([1, t])
rel[t].append([1, s])
cnt = 0
for x in range(M):
s, t = memo[x][0], memo[x][1]
rel[s].remove([1, t])
rel[t].remove([1, s])
l = sorted(dijkstra_heap(0, rel))
ind = bisect.bisect_left(l, float('inf'))
if ind != N:
cnt += 1
rel[s].append([1, t])
rel[t].append([1, s])
print(cnt) | p03575 |
N, M = list(map(int, input().split()))
graph = [[0 for i in range(N)] for j in range(N)]
edges = []
for m in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
edges.append([a,b])
graph[a][b] = 1
graph[b][a] = 1
ans = 0
for a,b in edges:
graph[a][b] = 0
graph[b][a] = 0
visited = [False] * N
visited[0] = True
q = [i for i in range(N) if graph[0][i]]
while q:
r = q.pop(0)
visited[r] = True
for i in range(N):
if graph[r][i] and not visited[i]:
q.append(i)
if False in visited:
ans += 1
graph[a][b] = 1
graph[b][a] = 1
print(ans) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
N, M = list(map(int, input().split()))
G = []
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G.append((a,b))
ans = 0
for i in range(M):
uni = UnionFind(N)
for j in range(M):
if i == j:
continue
uni.union(G[j][0],G[j][1])
if uni.group_count() >= 2:
ans += 1
print(ans)
if __name__ == "__main__":
main() | p03575 |
n, m = list(map(int, input().split()))
d = [[float("inf")] * n for i in range(n)]
edge = []
for i in range(m):
a, b = list(map(int, input().split()))
edge.append((a, b))
d[a - 1][b - 1] = 1
d[b - 1][a - 1] = 1
ans = 0
for a in range(m):
d_s = [x[:] for x in d]
x, y = edge[a]
d_s[x - 1][y - 1] = float("inf")
d_s[y - 1][x - 1] = float("inf")
for k in range(n):
for i in range(n):
for j in range(n):
d_s[i][j] = min(d_s[i][j], d_s[i][k] + d_s[k][j])
flag = 0
for i in range(n):
if flag:
break
for j in range(n):
if flag:
break
if d_s[i][j] == float("inf"):
ans += 1
flag = 1
print(ans) | n, m = list(map(int, input().split()))
edge = [list(map(int, input().split())) for i in range(m)]
ans = 0
for i in edge:
l = list(range(n))
for j in edge:
if j != i:
l = [l[j[0] - 1] if l[k] == l[j[1] - 1] else l[k] for k in range(n)]
if len(set(l)) != 1:
ans += 1
print(ans) | p03575 |
n, m = list(map(int, input().split()))
li = []
count = 0
def check_dfs(node_list):
traveled = []
return dfs(node_list, traveled, 0)
def dfs(node_list, t_list, position):
t_list.append(position)
if len(t_list) == n:
return 0
for i in node_list[position]:
if i not in t_list:
dfs(node_list, t_list, i)
if len(t_list) == n:
return 0
else:
return 1
for i in range(m):
array = list(map(int, input().split()))
li.append(array)
for i in range(m):
nodes = [[] for k in range(n)]
for j in range(m):
if j == i:
continue
else:
nodes[li[j][0]-1].append(li[j][1]-1)
nodes[li[j][1]-1].append(li[j][0]-1)
count += check_dfs(nodes)
print(count) | import sys
sys.setrecursionlimit(10**5)
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n)]
edge = []
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
graph[b].append(a)
edge.append([a, b])
cnt = 0
def dfs(start, a, b, explored, n):
for node in graph[start]:
if node not in explored:
if (start, node) == (a, b) or (start, node) == (b, a):
continue
else:
explored.append(node)
dfs(node, a, b, explored, n)
if len(explored) == n:
return 0
else:
return 1
x = 0
for i, j in edge:
x += dfs(0, i, j, [], n)
print(x) | p03575 |
N, M = list(map(int, input().split()))
graph = [[False for j in range(N)] for i in range(N)]
am = [0] * M
bm = [0] * M
def dfs(visited, n):
visited[n] = True
for k, v in enumerate(visited):
if v:
continue
if not graph[n][k]:
continue
visited = dfs(visited, k)
return visited
def main():
for i in range(M):
# 0-indexed
ai, bi = list(map(int, input().split()))
ai -= 1
bi -= 1
am[i] = ai
bm[i] = bi
graph[ai][bi] = True
graph[bi][ai] = True
ans = 0
for ai, bi in zip(am, bm):
graph[ai][bi] = False
graph[bi][ai] = False
# 訪問済 All False
visited = dfs([False] * N, 0)
# All True ならば 橋 ではない
if not all(visited):
ans += 1
# 元に戻す
graph[ai][bi] = True
graph[bi][ai] = True
print(ans)
return
main()
| N, M = list(map(int, input().split()))
graph = [[] for i in range(N)]
for i in range(M):
ai, bi = list(map(int, input().split()))
ai -= 1
bi -= 1
graph[ai].append(bi)
graph[bi].append(ai)
rank = [N] * N
low = [N] * N
visited = [False] * N
def dfs(k, pos, parent):
rank[pos] = k
low[pos] = k
k += 1
visited[pos] = True
for i in graph[pos]:
if not visited[i]:
dfs(k, i, pos)
low[pos] = min(low[pos], low[i])
elif i != parent:
low[pos] = min(low[pos], rank[i])
def main():
dfs(0, 0, -1)
ans = 0
for i in range(N):
for j in graph[i]:
if rank[j] < low[i]:
ans += 1
print(ans)
return
main()
| p03575 |
n, m = list(map(int, input().split()))
INF = 10**9
a = [[INF]*n for i in range(n)]
hen_m = []
for i in range(m):
x1, x2 = list(map(int, input().split()))
x1 -= 1
x2 -= 1
hen_m.append([x1, x2])
a[x1][x2] = 1
a[x2][x1] = 1
for i in range(n):
a[i][i] = 0
#ワーシャルフロイド
def warshall(n, c):
for i in range(n):
for j in range(n):
for k in range(n):
c[j][k] = min(c[j][k], c[j][i] + c[i][k])
ans = 0
# Mの辺を消して、わ～シャルフロイド
for i in range(m):
b = [i[::] for i in a]
x1 , x2 = hen_m[i]
b[x1][x2] = INF
b[x2][x1] = INF
warshall(n, b)
flag = 0
for j in range(n - 1):
for k in range(j + 1,n):
if b[j][k] >= INF:
flag = 1
break
if flag == 1:
break
#print(i, flag)
ans += flag
print(ans)
| n, m = list(map(int, input().split()))
a = [[False]*n for i in range(n)]
hen_m = []
for i in range(m):
x1, x2 = list(map(int, input().split()))
x1 -= 1
x2 -= 1
hen_m.append([x1, x2])
a[x1][x2] = True
a[x2][x1] = True
for i in range(n):
a[i][i] = True
#ワーシャルフロイド
def warshall(n, c):
for i in range(n):
for j in range(n):
for k in range(n):
c[j][k] = c[j][k] or (c[j][i] and c[i][k])
ans = 0
# Mの辺を消して、わ～シャルフロイド
for i in range(m):
b = [i[::] for i in a]
x1 , x2 = hen_m[i]
b[x1][x2] = False
b[x2][x1] = False
warshall(n, b)
flag = 0
for j in range(n - 1):
for k in range(j + 1,n):
if not b[j][k]:
flag = 1
break
if flag == 1:
break
#print(i, flag)
ans += flag
print(ans)
| p03575 |
import sys
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
ab=[[0,0] for i in range(m)]
for i in range(m):
ab[i][0],ab[i][1]=list(map(int,input().split()))
ans=0
for i in range(m):
root=[j for j in range(n+1)]
root[0]=1
def r(x):
if root[x]==x:
return x
else:
root[x]=r(root[x])
return root[x]
def unite(x,y):
x=r(x)
y=r(y)
if x==y:
return
else:
x,y=min(x,y),max(x,y)
root[y]=x
for j in range(m):
if j!=i:
a,b=ab[j][0],ab[j][1]
unite(a,b)
if not all(r(j)==1 for j in range(1,n+1)):
ans+=1
print(ans)
| from _collections import deque
n,m=list(map(int,input().split()))
ab=[[0,0] for i in range(m)]
for i in range(m):
ab[i][0],ab[i][1]=list(map(int,input().split()))
ans=0
for i in range(m):
edg=[[] for j in range(n+1)]
dep=[-1]*(n+1)
dep[0]=1
dep[1]=1
for j in range(m):
if j!=i:
a,b=ab[j][0],ab[j][1]
edg[a].append(b)
edg[b].append(a)
data=deque([1])
while len(data)>0:
p=data.popleft()
for j in edg[p]:
if dep[j]==-1:
dep[j]=1
data.append(j)
if not all(dep[i]==1 for i in range(n+1)):ans+=1
print(ans)
| p03575 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.