input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from sys import setrecursionlimit; setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
edge = {}
starts = set(i for i in range(1, N+1))
for _ in range(M):
x, y = list(map(int, input().split()))
if x not in edge:
edge[x] = [y]
else:
edge[x].append(y)
starts -= {y}
def rec(d, e, dp):
dp[e] = max(dp[e], d)
if e not in edge:
return 0
for f in edge[e]:
rec(d+1, f, dp)
return max(dp)
depth = []
for s in starts:
depth.append(rec(0, s, [0]*(N+1)))
print((max(depth)))
| from sys import setrecursionlimit; setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
edge = {i:[] for i in range(1, N+1)}
starts = set(i for i in range(1, N+1))
for _ in range(M):
x, y = list(map(int, input().split()))
edge[x].append(y)
starts -= {y}
memo = [-1] * (N+1)
def rec(e):
if memo[e] != -1:
return memo[e]
ret = 0
for f in edge[e]:
ret = max(ret, rec(f) + 1)
memo[e] = ret
return ret
max_d = 0
for s in starts:
max_d = max(max_d, rec(s))
print(max_d)
| p03166 |
from collections import deque
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read():
N, M = list(map(int, input().strip().split()))
E_out = [list() for i in range(N)]
E_in = [list() for i in range(N)]
for i in range(M):
x, y = list(map(int, input().strip().split()))
E_out[x-1].append(y-1) # x -> E_out[x]
E_in[y-1].append(x-1) # E_in[x] -> x
return N, M, E_in, E_out
def solve(N, M, E_in, E_out):
dp = [-1 for i in range(N)]
q = deque()
for x in range(N):
if len(E_out[x]) == 0:
q.append(x)
dp[x] = 0
while q:
x = q.pop()
for y in E_in[x]:
q.append(y)
dp[y] = max(dp[y], dp[x] + 1)
return max(dp)
if __name__ == '__main__':
inputs = read()
print(("%s" % solve(*inputs)))
| from collections import deque
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read():
N, M = list(map(int, input().strip().split()))
parents = [list() for i in range(N)]
n_children = [0 for i in range(N)]
for i in range(M):
x, y = list(map(int, input().strip().split()))
n_children[x-1] += 1 # x -> E_out[x]
parents[y-1].append(x-1) # E_in[x] -> x
return N, M, n_children, parents
def solve(N, M, n_children, parents):
dp = [0 for i in range(N)]
q = deque()
r = deque()
for x in range(N):
if n_children[x] == 0:
q.append(x)
while q:
x = q.pop()
r.append(x)
for parent in parents[x]:
n_children[parent] -= 1
if n_children[parent] == 0:
q.append(parent)
while r:
x = r.pop()
for y in parents[x]:
dp[x] = max(dp[x], dp[y]+1)
return max(dp)
if __name__ == '__main__':
inputs = read()
print(("%s" % solve(*inputs)))
| p03166 |
N, M = (int(i) for i in input().split())
outs = [[] for i in range(N)]
ins = [0] * N
for _ in range(M):
x, y = (int(i) for i in input().split())
x -= 1
y -= 1
outs[x].append(y)
ins[y] += 1
q = []
for i in range(N):
if ins[i] == 0:
q.append(i)
result = []
while q != []:
qn = q.pop(0)
result.append(qn)
for v in outs[qn]:
ins[v] -= 1
if ins[v] == 0:
q.append(v)
last = [0] * N
# last[i] = iが最後だったときに最長のパス
for sq in result:
tp = last[sq] + 1
for v in outs[sq]:
last[v] = max(last[v], tp)
print((max(last)))
| N, M = (int(i) for i in input().split())
outs = [[] for i in range(N)]
ins = [0] * N
for _ in range(M):
x, y = (int(i) for i in input().split())
x -= 1
y -= 1
outs[x].append(y)
ins[y] += 1
q = []
for i in range(N):
if ins[i] == 0:
q.append(i)
result = []
while q != []:
qn = q.pop()
result.append(qn)
for v in outs[qn]:
ins[v] -= 1
if ins[v] == 0:
q.append(v)
last = [0] * N
# last[i] = iが最後だったときに最長のパス
for sq in result:
for v in outs[sq]:
last[v] = max(last[v], last[sq] + 1)
print((max(last)))
| p03166 |
import sys
sys.setrecursionlimit(10 ** 9)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
x, y = list(map(int, input().split()))
G[x].append(y)
lst = [-1] * (N + 1)
def calc(x):
if lst[x] != -1:
return lst[x]
tmp = 0
for next_ in G[x]:
tmp = max(tmp, calc(next_))
lst[x] = tmp + 1
return tmp + 1
for i in range(1, N + 1):
if lst[i] == -1:
calc(i)
print((max(lst) - 1)) | import sys
sys.setrecursionlimit(10 ** 9)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for _ in range(M):
x, y = list(map(int, input().split()))
G[x].append(y)
lst = [-1] * (N + 1)
def calc(x):
if lst[x] != -1:
return lst[x]
tmp = 0
for next_ in G[x]:
tmp = max(tmp, calc(next_))
lst[x] = tmp + 1
return tmp + 1
ans = 0
for i in range(1, N + 1):
if lst[i] == -1:
ans = max(ans, calc(i))
print((ans - 1)) | p03166 |
import sys
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
#dp[v]: start from v maxpath
dp = [-1 for _ in range(N)]
gragh = [[] for _ in range(N)]
for _ in range(M):
x,y = list(map(int, input().split()))
gragh[x-1].append(y-1)
#solve DAG and topological sort by recursive funciton
def f(v,G=gragh):
if dp[v] != -1:
return dp[v]
ret = 0
for u in G[v]:
ret = max(ret, f(u) + 1)
return ret
for v in range(N):
dp[v] = f(v)
print((max(dp)))
| import sys
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
#dp[v]: start from v maxpath
dp = [-1 for _ in range(N)]
gragh = [[] for _ in range(N)]
for _ in range(M):
x,y = list(map(int, input().split()))
gragh[x-1].append(y-1)
#solve DAG and topological sort by memo recursive funciton
def f(v,G=gragh):
if dp[v] != -1:
return dp[v]
ret = 0
for u in G[v]:
ret = max(ret, f(u) + 1)
dp[v] = ret
return ret
for v in range(N):
dp[v] = f(v)
print((max(dp))) | p03166 |
""""
5 8
5 3
2 3
2 4
5 2
5 1
1 4
4 3
1 3
"""
N, M = list(map(int, input().split()))
G = []
for _ in range(M):
G.append(list(map(int, input().split())))
h = [0]*(N+1)
for eg in G:
h[eg[1]]+=1
que = []
for i in range(1, N+1):
if h[i] == 0: que.append(i)
dp = [0]*(N+1)
while len(que)>0:
now = que.pop(0)
for eg in G:
if eg[0]==now:
h[eg[1]]-=1
if h[eg[1]]==0:
que.append(eg[1])
dp[eg[1]] = max(dp[eg[0]] + 1, dp[eg[1]])
print(max(dp)) |
""""
5 8
5 3
2 3
2 4
5 2
5 1
1 4
4 3
1 3
"""
N, M = list(map(int, input().split()))
G = []
for _ in range(M):
G.append(list(map(int, input().split())))
h = [0]*(N+1)
dest = [[] for _ in range(N+1)]
for eg in G:
h[eg[1]]+=1
dest[eg[0]].append(eg[1])
que = []
for i in range(1, N+1):
if h[i] == 0: que.append(i)
dp = [0]*(N+1)
while len(que)>0:
now = que.pop(0)
for edest in dest[now]:
h[edest]-=1
if h[edest]==0:
que.append(edest)
dp[edest] = max(dp[now] + 1, dp[edest])
print(max(dp))
| p03166 |
# Author: S Mahesh Raju
# Username: maheshraju2020
# Date: 01/08/2020
from sys import stdin,stdout
from math import gcd, ceil, sqrt
from collections import Counter
from bisect import bisect_left, bisect_right
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007
def bfs(node, d):
queue = [node, None]
count = 0
while len(queue):
cur = queue.pop(0)
if not cur:
if len(queue):
queue.append(None)
count += 1
else:
for neigh in d.get(cur, []):
queue.append(neigh)
return count - 1
n, m = iia()
d = {}
indegree = [0] * (n + 1)
for i in range(m):
a, b = iia()
d.setdefault(a, []).append(b)
indegree[b] += 1
res = 0
for i in range(1, n + 1):
if indegree[i] == 0:
res = max(res, bfs(i, d))
print(res)
| # Author: S Mahesh Raju
# Username: maheshraju2020
# Date: 01/08/2020
from sys import stdin, stdout
import sys
from math import gcd, ceil, sqrt
from collections import Counter
from bisect import bisect_left, bisect_right
ii1 = lambda: int(stdin.readline().strip())
is1 = lambda: stdin.readline().strip()
iia = lambda: list(map(int, stdin.readline().strip().split()))
isa = lambda: stdin.readline().strip().split()
mod = 1000000007
sys.setrecursionlimit(100000)
n, m = iia()
dp = [-1] * (n + 1)
d = {}
for i in range(m):
a, b = iia()
d.setdefault(a, []).append(b)
def dfs(cur):
if dp[cur] != -1:
return dp[cur]
t = 0
for i in d.get(cur, []):
t = max(1 + dfs(i), t)
dp[cur] = t
return dp[cur]
res = 0
for i in range(1, n + 1):
res = max(res, dfs(i))
print(res) | p03166 |
import sys
sys.setrecursionlimit(10**7)
def f(v):
if dp[v] != 0:
return dp[v]
res = 0
for i in graph[v]:
res = max(res,f(i)+1)
dp[v] = res
return res
N, M = list(map(int, input().split()))
graph = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
graph[x-1].append(y-1)
dp = [0]*N
for i in range(N):
f(i)
print((max(dp))) | import sys
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
edge[x-1].append(y-1)
dp = [0]*N
def f(v):
if dp[v] != 0:
return dp[v]
res = 0
for i in edge[v]:
res = max(res, f(i)+1)
dp[v] = res
return res
for i in range(N):
f(i)
print((max(dp))) | p03166 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: G_fix
# CreatedDate: 2020-06-05 21:28:41 +0900
# LastModified: 2020-06-05 22:03:20 +0900
#
import os
import sys
from collections import deque
#import numpy as np
#import pandas as pd
def main():
n,m = list(map(int,input().split()))
path = [[] for _ in range(n+1)]
to_cnt = [0]*(n+1)
longest_cnt = [0]*(n+1)
for _ in range(m):
x,y = list(map(int,input().split()))
path[x].append(y)
to_cnt[y]+=1
Q = deque()
for i in range(1,n+1):
if to_cnt[i]==0:
Q.append(i)
# longest_cnt[s]=1
while(Q):
u = Q.popleft()
for v in path[u]:
to_cnt[v]-=1
if longest_cnt[u]+1>longest_cnt[v]:
longest_cnt[v]=longest_cnt[u]+1
Q.append(v)
print((max(longest_cnt)))
if __name__ == "__main__":
main()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: G_fix
# CreatedDate: 2020-06-05 21:28:41 +0900
# LastModified: 2020-06-05 22:05:41 +0900
#
import os
import sys
from collections import deque
#import numpy as np
#import pandas as pd
def main():
n,m = list(map(int,input().split()))
path = [[] for _ in range(n+1)]
to_cnt = [0]*(n+1)
longest_cnt = [0]*(n+1)
for _ in range(m):
x,y = list(map(int,input().split()))
path[x].append(y)
to_cnt[y]+=1
Q = deque()
for i in range(1,n+1):
if to_cnt[i]==0:
Q.append(i)
# longest_cnt[s]=1
while(Q):
u = Q.popleft()
for v in path[u]:
to_cnt[v]-=1
if longest_cnt[u]+1>longest_cnt[v]:
longest_cnt[v]=longest_cnt[u]+1
if to_cnt[v]==0:
Q.append(v)
print((max(longest_cnt)))
if __name__ == "__main__":
main()
| p03166 |
N, M = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
from collections import defaultdict
from collections import deque
g = defaultdict(set)
for x, y in XY:
g[x].add(y)
def bfs(u):
s = deque([u])
cost = {u: 0}
done = set()
while s:
u = s.popleft()
if u not in done:
done.add(u)
else:
continue
for v in g[u]:
cost[v] = cost[u] + 1
if v in done:
done.remove(v)
s.append(v)
return cost
ans = 0
for i in range(1, N+1):
d = bfs(i)
ans = max(ans, max(d.values()))
print(ans) | N, M = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
from collections import defaultdict
from collections import deque
from collections import Counter
g = defaultdict(set)
for x, y in XY:
g[x].add(y)
def TSort(g):
V = list(g.keys())
for v in list(g.values()):
V.extend(list(v))
V = set(V)
funin = Counter()
for u in V:
for v in g[u]:
funin[v] += 1
q = deque()
for v in V:
if funin[v] == 0:
q.append(v)
L = []
while q:
u = q.popleft()
L.append(u)
for v in g[u]:
funin[v] -= 1
if funin[v] == 0:
q.append(v)
return L
D = Counter()
ns = TSort(g)
for u in ns:
for v in g[u]:
D[v] = max(D[v], D[u] + 1)
print((D.most_common()[0][1])) | p03166 |
import sys
from functools import lru_cache
sys.setrecursionlimit(100000)
@lru_cache(maxsize=None)
def dfs(v):
lv = links[v]
return max(dfs(u) for u in lv) + 1 if lv else 0
n, m = list(map(int, input().split()))
sss = set(range(n))
links = [set() for _ in range(n)]
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
sss.discard(y)
links[x].add(y)
print((max(dfs(v) for v in sss)))
| import sys
from functools import lru_cache
sys.setrecursionlimit(1000000)
@lru_cache(maxsize=None)
def dfs(v):
lv = links[v]
return max(list(map(dfs, lv))) + 1 if lv else 0
n, m = list(map(int, input().split()))
sss = set(range(n))
links = [set() for _ in range(n)]
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
sss.discard(y)
links[x].add(y)
print((max(list(map(dfs, sss)))))
| p03166 |
import sys
from functools import lru_cache
sys.setrecursionlimit(1000000)
@lru_cache(maxsize=None)
def dfs(v):
lv = links[v]
return max(list(map(dfs, lv))) + 1 if lv else 0
n, m = list(map(int, input().split()))
sss = set(range(n))
links = [set() for _ in range(n)]
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
sss.discard(y)
links[x].add(y)
print((max(list(map(dfs, sss)))))
| import sys
sys.setrecursionlimit(1000000)
def dfs(v):
if cache[v] > -1:
return cache[v]
lv = links[v]
cache[v] = ret = max(list(map(dfs, lv))) + 1 if lv else 0
return ret
n, m = list(map(int, input().split()))
sss = set(range(n))
links = [set() for _ in range(n)]
cache = [-1] * n
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
sss.discard(y)
links[x].add(y)
print((max(list(map(dfs, sss)))))
| p03166 |
import sys
sys.setrecursionlimit(1000000)
def dfs(v):
if cache[v] > -1:
return cache[v]
lv = links[v]
cache[v] = ret = max(list(map(dfs, lv))) + 1 if lv else 0
return ret
n, m = list(map(int, input().split()))
sss = set(range(n))
links = [set() for _ in range(n)]
cache = [-1] * n
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
sss.discard(y)
links[x].add(y)
print((max(list(map(dfs, sss)))))
| import sys
sys.setrecursionlimit(1000000)
def dfs(v):
if cache[v] > -1:
return cache[v]
lv = links[v]
cache[v] = ret = max(list(map(dfs, lv))) + 1 if lv else 0
return ret
n, m = list(map(int, input().split()))
links = [set() for _ in range(n)]
cache = [-1] * n
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
x -= 1
y -= 1
links[x].add(y)
print((max(list(map(dfs, list(range(n)))))))
| p03166 |
n,m=list(map(int,input().split()))
h={}
st=set([i for i in range(1,n+1)])
kos=set()
for _ in range(m):
oy,ko=list(map(int,input().split()))
h.setdefault(oy,[])
h[oy]+=[ko]
kos.add(ko)
st=st-kos
dep=0
while 1:
nst=set()
for s in st:
if s not in h:continue
for ko in h[s]:
nst.add(ko)
if len(nst)==0:
break
st=nst
dep+=1
print(dep) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
def get_kyori(i):
if kos[i] == []:
kyori[i] = 0
return 0
if kyori[i] > -1:
return kyori[i]
re = 0
for ko in kos[i]:
new = get_kyori(ko) + 1
if re < new:
re = new
kyori[i] = re
return re
n, m = list(map(int, input().split()))
kos = [[] for _ in range(n + 1)]
kyori = [-1] * (n + 1)
for _ in range(m):
oya, ko = list(map(int, input().split()))
kos[oya] += [ko]
for i in range(1, n + 1):
if kyori[i] == -1:
kyori[i] = get_kyori(i)
print((max(kyori[1:])))
| p03166 |
from collections import deque
def main():
n, adj = getInputs()
# maxDistance[start]
maxDistance = [0] * n
overallMaxDistance = 0
calculated = [0] * n
for v in getVertexSequence(n, adj):
# distance[dest] (starting at v)
distance = [0] * n
currMaxDistance = 0
toVisit = deque([v])
while len(toVisit) > 0:
curr = toVisit.popleft()
for dest in adj[curr]:
if calculated[dest] == 1:
newDistance = distance[curr] + maxDistance[dest] + 1
if newDistance > distance[dest]:
distance[dest] = newDistance
if distance[dest] > currMaxDistance:
currMaxDistance = distance[dest]
else:
if distance[curr] + 1 > distance[dest]:
distance[dest] = distance[curr] + 1
if distance[dest] > currMaxDistance:
currMaxDistance = distance[dest]
toVisit.append(dest)
maxDistance[v] = currMaxDistance
if currMaxDistance > overallMaxDistance:
overallMaxDistance = currMaxDistance
calculated[v] = 1
print(overallMaxDistance)
def getInputs():
n, m = [int(x) for x in input().split()]
adj = []
for i in range(n):
adj.append([])
for i in range(m):
a, b = [int(x) for x in input().split()]
adj[a - 1].append(b - 1)
return n, adj
def getVertexSequence(n, adj):
pairs = []
for i in range(n):
pairs.append((i, adj[i]))
pairs.sort(key=(lambda x: len(x[1])))
sequence = []
for i in range(n):
sequence.append(pairs[i][0])
return sequence
main()
| def main():
n, adj = getInputs()
sequence = getTopologicalSort(n, adj)
distance = [-1] * n
longest = -1
for v in sequence:
if len(adj[v]) == 0:
distance[v] = 0
else:
for dest in adj[v]:
distance[v] = max(distance[v], 1 + distance[dest])
longest = max(longest, distance[v])
print(longest)
def getTopologicalSort(n, adj):
state = [0] * n
toVisit = list(range(n))
topologicalSort = []
order = []
while len(toVisit) > 0:
curr = toVisit.pop()
if state[curr] == 0:
order.append(curr)
state[curr] = 1
foundNewDest = False
for dest in adj[curr]:
if state[dest] == 0:
toVisit.append(dest)
foundNewDest = True
if not foundNewDest:
while True:
v = order[-1]
allProcessed = True
for dest in adj[v]:
if state[dest] == 0:
allProcessed = False
break
if allProcessed:
state[v] = 2
topologicalSort.append(order.pop())
if len(order) == 0 or not allProcessed:
break
return topologicalSort
def getInputs():
n, m = [int(x) for x in input().split()]
adj = []
for i in range(n):
adj.append([])
for i in range(m):
a, b = [int(x) for x in input().split()]
adj[a - 1].append(b - 1)
return n, adj
main()
| p03166 |
from collections import deque
n, m = list(map(int, input().split()))
G = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x)-1 for x in input().split()]
G[x].append(y)
counts = [-1] * n
while -1 in counts:
start = counts.index(-1)
q = deque([[start, 0]])
while q:
i, l = q.pop()
counts[i] = max(counts[i], l)
for ni in G[i]:
q.append([ni, l+1])
print((max(counts)))
| import sys
sys.setrecursionlimit(500000)
n, m = list(map(int, input().split()))
G = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x)-1 for x in input().split()]
G[x].append(y)
# iを始点としたときの有効パスの最大長さ
dp = [-1] * n
def rec(s):
if dp[s] != -1:
return dp[s]
ret = 0
for ns in G[s]:
ret = max(ret, rec(ns)+1)
dp[s] = ret
return ret
ml = 0
for i in range(n):
ml = max(ml, rec(i))
print(ml) | p03166 |
def bell(edges, n):
dist = [0 for i in range(n)]
changed = True
while changed:
changed = False
for edge in edges:
if dist[edge[1]] < dist[edge[0]] + 1:
changed = True
dist[edge[1]] = max(dist[edge[0]] + 1, dist[edge[1]])
return dist
n,m = list(map(int,input().split()))
edges = []
for _ in range(m):
a, b= (int(x) for x in input().split())
edges.append([a-1, b-1])
res = bell(edges, n)
print((max(res))) | import sys
sys.setrecursionlimit(10**5)
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n+1)]
for _ in range(m):
x, y = list(map(int, input().split()))
edges[x].append(y)
dp = [-1 for _ in range(n+1)]
def longest_path(u):
if dp[u] != -1:
return dp[u]
d = 0
for v in edges[u]:
d = max(d, 1+longest_path(v))
dp[u] = d
return d
for u in range(1, n+1):
longest_path(u)
print((max(dp))) | p03166 |
# input
N, M = list(map(int, input().split()))
cost = [[float('inf')] * N for i in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
cost[x - 1][y - 1] = -1
for i in range(N):
for j in range(N):
for k in range(N):
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])
ans = 0
for i in range(N):
for j in range(N):
if ans > cost[i][j]:
ans = cost[i][j]
print((ans * -1)) | # input
N, M = list(map(int, input().split()))
edges = []
for i in range(M):
edges.append(list(map(int, input().split())))
# DP
cost = [[float(0)] * N for i in range(N)]
for e in edges:
e[0] -= 1
e[1] -= 1
cost[e[0]][e[1]] = 1
for e in edges:
for i in range(N):
if cost[i][e[0]] > 0: # i → e.start への経路があるとき
cost[i][e[1]] = max(cost[i][e[1]], cost[i][e[0]] + 1)
for j in range(N):
if cost[e[1]][j] > 0: # e.end → j への経路があるとき
cost[e[0]][j] = max(cost[e[0]][j], cost[e[1]][j] + 1)
ans = 0
for i in range(N):
for j in range(N):
if ans < cost[i][j]:
ans = cost[i][j]
print(ans) | p03166 |
import sys
N, M = list(map(int, input().split()))
graph = [dict() for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
graph[x - 1][y - 1] = 1
dp = [0 for _ in range(N)]
sys.setrecursionlimit(10 ** 9)
def dfs(num_v):
if len(graph[num_v]) == 0:
return
for to in list(graph[num_v].keys()):
dp[to] = max(dp[to], dp[num_v] + 1)
dfs(to)
ans = 0
for i in range(N):
dfs(i)
ans = max(ans, max(dp))
print(ans)
| import sys
sys.setrecursionlimit(10 ** 8)
N, M = list(map(int, input().split()))
graph = [dict() for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
graph[y - 1][x - 1] = 1
dp = [0 for _ in range(N)]
def dfs(u):
if dp[u] != 0:
return dp[u]
max_dis = 0
for f in list(graph[u].keys()):
if max_dis < dfs(f) + 1:
max_dis = dfs(f) + 1
dp[u] = max_dis
return dp[u]
for i in range(N):
dfs(i)
print((max(dp)))
| p03166 |
import sys
sys.setrecursionlimit(10 ** 8)
N, M = list(map(int, input().split()))
graph = [dict() for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
graph[y - 1][x - 1] = 1
dp = [0 for _ in range(N)]
def dfs(u):
if dp[u] != 0:
return dp[u]
max_dis = 0
for f in list(graph[u].keys()):
if max_dis < dfs(f) + 1:
max_dis = dfs(f) + 1
dp[u] = max_dis
return dp[u]
for i in range(N):
dfs(i)
print((max(dp)))
| import sys
sys.setrecursionlimit(10 ** 8)
N, M = list(map(int, input().split()))
graph = [dict() for _ in range(N)]
for i in range(M):
x, y = list(map(int, input().split()))
graph[y - 1][x - 1] = 1
dp = [0 for _ in range(N)]
def dfs(u):
if dp[u] != 0 or len(graph[u]) == 0:
return dp[u]
max_dis = 0
for f in list(graph[u].keys()):
if max_dis < dfs(f) + 1:
max_dis = dfs(f) + 1
dp[u] = max_dis
return dp[u]
for i in range(N):
dfs(i)
print((max(dp)))
| p03166 |
N, M = list(map(int, input().split()))
childs = [[] for _ in range(N)]
for i in range(M):
p, c = list(map(int, input().split()))
childs[p-1].append(c)
stack = list(range(1, N+1))
# dp[n]: nに到達する最長のパス
dp = [0] * N
while stack:
n = stack.pop()
for nc in childs[n-1]:
if dp[nc-1] < dp[n-1] + 1:
stack.append(nc)
dp[nc-1] = dp[n-1] + 1
print((max(dp)))
| import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
childs = [[] for _ in range(N)]
for i in range(M):
p, c = list(map(int, input().split()))
childs[p-1].append(c-1)
depth = [-1] * N
def dfs(n):
if depth[n] != -1:
return depth[n]
if childs[n]:
depth[n] = max((dfs(nc) for nc in childs[n])) + 1
else:
depth[n] = 0
return depth[n]
print((max((dfs(n) for n in range(N)))))
| p03166 |
import sys
sys.setrecursionlimit(10**9)
n , m = list(map(int,input().split()))
g = [[] for i in range(n)]
for _ in range(m):
v1 , v2 = list(map(int,input().split()))
v1 -=1; v2 -=1
g[v1].append(v2)
# finding longest path for vertice i
def dfs(i):
temp = 0
for nv in g[i]:
temp = max(temp, dfs(nv)+1)
return temp
# finding overall longest path
res = 0
for i in range(n):
res = max(res, dfs(i))
print(res) | import sys
sys.setrecursionlimit(10**9)
n , m = list(map(int,input().split()))
g = [[] for i in range(n)]
dp = [-1] *n
for _ in range(m):
v1 , v2 = list(map(int,input().split()))
v1 -=1; v2 -=1
g[v1].append(v2)
# finding longest path for vertice i
def dfs(i):
if dp[i]!=-1:
return dp[i]
temp = 0
for nv in g[i]:
temp = max(temp, dfs(nv)+1)
dp[i]=temp
return temp
# finding overall longest path
res = 0
for i in range(n):
res = max(res, dfs(i))
print(res) | p03166 |
import sys
sys.setrecursionlimit(10**9)
def dfs(i):
if distance[i] != -1:
return distance[i]
ans = 0
for node in graph[i]:
ans = max(ans, dfs(node) + 1)
return ans
n, m = list(map(int, input().split()))
graph = [[] for i in range(n)]
distance = [-1 for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
ans = 0
for i in range(n):
ans = max(ans, dfs(i))
print(ans) |
import sys
sys.setrecursionlimit(10**9)
def dfs(i):
if distance[i] != -1:
return distance[i]
ans = 0
for node in graph[i]:
ans = max(ans, dfs(node) + 1)
distance[i] = ans
return ans
n, m = list(map(int, input().split()))
graph = [[] for i in range(n)]
distance = [-1 for i in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
graph[a].append(b)
ans = 0
for i in range(n):
ans = max(ans, dfs(i))
print(ans) | p03166 |
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 26 14:22:54 2020
@author: Maruthi Srinivas
"""
import sys
sys.setrecursionlimit(1000000)
def dfs(node,graph,dp):
temp=0
if dp[node]!=-1:
return dp[node]
for i in graph[node]:
temp=max(temp,dfs(i,graph,dp)+1)
dp[node]=temp
return temp
v,e=list(map(int,input().split()))
adj={x:[] for x in range(v+1)}
for i in range(e):
x,y=list(map(int,input().split()))
adj[x].append(y)
m=-1
dp=[-1]*(v+1)
for i in range(1,v+1):
visited=[False]*(v+1)
x=dfs(i,adj,dp)
#print(i,x)
m=max(m,x)
print(m)
| # -*- coding: utf-8 -*-
"""
Created on Sun Jul 26 14:22:54 2020
@author: Maruthi Srinivas
"""
import sys
sys.setrecursionlimit(1000000)
def dfs(node,graph,dp):
temp=0
if dp[node]!=-1:
return dp[node]
for i in graph[node]:
temp=max(temp,dfs(i,graph,dp)+1)
dp[node]=temp
return temp
v,e=list(map(int,input().split()))
adj={x:[] for x in range(v+1)}
for i in range(e):
x,y=list(map(int,input().split()))
adj[x].append(y)
m=-1
dp=[-1]*(v+1)
for i in range(1,v+1):
x=dfs(i,adj,dp)
m=max(m,x)
print(m)
| p03166 |
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
#from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.buffer.readline().strip().decode()
def mdata(): return list(map(int, data().split()))
out=sys.stdout.write
#sys.setrecursionlimit(100000)
INF=int(10e9)
n,m=mdata()
dp=[0]*n
g=[set() for i in range(n)]
par=[i for i in range(n)]
for i in range(m):
x,y=mdata()
g[x-1].add(y-1)
for i in range(n):
if par[i]==i:
s1=set()
s1.add(i)
while s1:
s2=set()
for i in s1:
for j in g[i]:
s2.add(j)
dp[j]=max(dp[j],dp[i]+1)
s1=s2.copy()
print((max(dp)))
| from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
#from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.buffer.readline().strip().decode()
def mdata(): return list(map(int, data().split()))
out=sys.stdout.write
#sys.setrecursionlimit(100000)
INF=int(10e9)
n,m=mdata()
dp=[0]*n
g=[set() for i in range(n)]
par=[i for i in range(n)]
chl=[0]*n
for i in range(m):
x,y=mdata()
g[x-1].add(y-1)
chl[y-1]=1
vis=[0]*n
for i in range(n):
if chl[i]==0:
s1=deque()
s1.append(i)
while s1:
a=s1[-1]
if vis[a]==1:
if a!=i:
dp[par[a]]=max(dp[par[a]],dp[a]+1)
s1.pop()
continue
vis[a]=1
for j in g[a]:
if vis[j]==0:
s1.append(j)
par[j]=a
else:
dp[a]=max(dp[a],dp[j]+1)
print((max(dp)))
| p03166 |
import sys
sys.setrecursionlimit(20000)
def getMax(d,n,c):
global bs
if len(d[n])==0:
bs=max(bs,c)
for k in d[n]:
getMax(d,k,c+1)
n,m=list(map(int,input().split()))
d={}
for j in range(1,n+1):
d[j]=[]
for i in range(m):
a,b=list(map(int,input().split()))
d[a].append(b)
bs=-1
for i in range(1,n+1):
c=0
getMax(d,i,c)
print(bs)
| import sys
sys.setrecursionlimit(20000)
def getMax(d, n):
if len(d[n]) == 0:
return 0
if not dp[n] == -1:
return dp[n]
for k in d[n]:
dp[n] = max(dp[n], 1 + getMax(d, k))
return dp[n]
n, m = list(map(int, input().split()))
d = {}
dp = [-1 for _ in range(n + 1)]
for j in range(1, n + 1):
d[j] = []
for i in range(m):
a, b = list(map(int, input().split()))
d[a].append(b)
bs = -1
for i in range(1, n + 1):
bs = max(bs, getMax(d,i))
print(bs)
| p03166 |
import sys
sys.setrecursionlimit(10**9)
def f(x):#dpは
if dp[x]!=-1:
return dp[x]#すでに値が決まっていたらそれをかえす
ans=0
for e in d[x]:#すべての枝について
ans=max(ans,1+f(e))
dp[x]=ans
return ans
n,m = list(map(int, input().split()))
d={}
dp=[-1]
for i in range(1,n+1):
d[i]=[]#dは初期値を[]
dp.append(-1)#dpは初期値-1
for _ in range(m):
a,b = list(map(int, input().split()))
d[a].append(b)#有向グラフをdictで
ans=0
for i in range(1,n+1):
ans=max(ans,f(i))
print(ans) | import sys
sys.setrecursionlimit(10**9)
def dfs(x): #グラフでの再帰DFS
if dp[x] != -1:
return dp[x] #すでに値が決まっていたらそれをかえす
ans = 0
for e in graph[x]: #すべての枝について
ans = max(ans,1 + dfs(e))
dp[x] = ans
return ans # 最も長い距離を返す
n,m = list(map(int, input().split()))
graph = [[] for i in range(n+1)]
dp = [-1]
for i in range(1,n+1):
dp.append(-1) # dpは初期値-1
for _ in range(m): # グラフの作成
a,b = list(map(int, input().split()))
graph[a].append(b)
#graph[b].append(a) #無向グラフの時
ans=0
for i in range(1,n+1):
ans=max(ans,dfs(i))
print(ans) | p03166 |
import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
# 各頂点の次数
deg = [0 for _ in range(n)]
# グラフ
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
deg[b - 1] += 1
que = deque([])
for i in range(n):
if deg[i] == 0:
que.append(i)
dp = [0 for _ in range(n)]
while que:
v = que.popleft()
for nv in edge[v]:
deg[nv] -= 1
if deg[nv] == 0:
que.append(nv)
dp[nv] = max(dp[nv], dp[v] + 1)
res = 0
for j in range(n):
res = max(res, dp[j])
print(res)
if __name__ == '__main__':
resolve()
| import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
# 各頂点の次数
deg = [0 for _ in range(n)]
# グラフ
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
deg[b - 1] += 1
# 入力辺を持たないノードの集合
que = deque([])
for i in range(n):
if deg[i] == 0:
que.append(i)
# トポロジカルソートを行いながら、入力辺を持たないノードからの最長経路を求める
dp = [0 for _ in range(n)]
while que:
v = que.popleft()
for nv in edge[v]:
# 入力辺を一つ消す
deg[nv] -= 1
if deg[nv] == 0:
que.append(nv)
dp[nv] = max(dp[nv], dp[v] + 1)
print((max(dp)))
if __name__ == '__main__':
resolve()
| p03166 |
n, m = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
dp = [[0,0] for _ in range(n+1)]
check = True
while(check):
check = False
for i in range(m):
x, y =xy[i]
if(dp[x][1] < dp[y][1]+1):
dp[x][1] = dp[y][1]+1
check = True
if(dp[y][0] < dp[x][0]+1):
dp[y][0] = dp[x][0]+1
check = True
ans = 0
for i in range(n+1):
ans = max(ans, dp[i][0])
print(ans) | from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
n, m = list(map(int, input().split()))
xy_dict = {}
for i in range(1,n+1):
xy_dict[i] = []
for i in range(m):
x,y = list(map(int, input().split()))
xy_dict[x].append(y)
dp = [-1]*(n+1)
dp[0] = 0
def get_longest(x):
global dp
if( dp[x] >= 0):
return dp[x]
else:
y_list = xy_dict[x]
temp_max = 0
for y in y_list:
temp_max = max(temp_max, get_longest(y)+1)
dp[x] = temp_max
return temp_max
ans = 0
for i in range(1,n+1):
ans = max(ans, get_longest(i))
print(ans) | p03166 |
#!/usr/bin/env python
import sys
import re
from collections import deque, defaultdict
from itertools import combinations, combinations_with_replacement
import bisect
from math import factorial, sqrt, log, ceil, floor
sys.setrecursionlimit(1000000)
def get_longest(x, longest, edges):
if longest[x] is not None:
return longest[x]
if not edges[x]:
return 0
result = max([get_longest(y, longest, edges)
for y in edges[x]])
return result + 1
def main():
input = sys.stdin.readline
#N, M = map(int, input().split())
#N, K = map(int, input().split())
#ps = list(map(int, input().split()))
N, M = list(map(int, input().split()))
edges = defaultdict(set)
for i in range(M):
x, y = list(map(int, input().split()))
edges[x].add(y)
longest = [None] * (N + 1)
for x in range(N):
x += 1
if longest[x] is None:
longest[x] = get_longest(x, longest, edges)
print((max(longest[1:])))
if __name__ == '__main__':
main()
| #!/usr/bin/env python
import sys
import re
from collections import deque, defaultdict
from itertools import combinations, combinations_with_replacement
import bisect
from math import factorial, sqrt, log, ceil, floor
sys.setrecursionlimit(1000000)
def get_longest(x, longest, edges):
if longest[x] is not None:
return longest[x]
if not edges[x]:
longest[x] = 0
else:
result = max([get_longest(y, longest, edges)
for y in edges[x]])
longest[x] = result + 1
return longest[x]
def main():
input = sys.stdin.readline
#N, M = map(int, input().split())
#N, K = map(int, input().split())
#ps = list(map(int, input().split()))
N, M = list(map(int, input().split()))
edges = defaultdict(set)
for i in range(M):
x, y = list(map(int, input().split()))
edges[x].add(y)
longest = [None] * (N + 1)
for x in range(N):
x += 1
if longest[x] is None:
get_longest(x, longest, edges)
print((max(longest[1:])))
if __name__ == '__main__':
main()
| p03166 |
import sys
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
g=[[] for i in range(n)]
for i in range(m):
v1,v2=list(map(int,input().split()))
v1-=1;v2-=1
g[v1].append(v2)
def dfs(i):
temp=0
for nv in g[i]:
temp=max(temp,dfs(nv)+1)
return temp
res=0
for i in range(n):
res=max(res,dfs(i))
print(res)
| import sys
sys.setrecursionlimit(10**9)
n,m=list(map(int,input().split()))
g=[[] for i in range(n)]
for i in range(m):
v1,v2=list(map(int,input().split()))
v1-=1;v2-=1
g[v1].append(v2)
dp=[-1]*n
def dfs(i):
if dp[i]!=-1:
return dp[i]
temp=0
for nv in g[i]:
temp=max(temp,dfs(nv)+1)
dp[i]=temp
return temp
res=0
for i in range(n):
res=max(res,dfs(i))
print(res)
| p03166 |
from collections import deque
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
memo = [[0] * N for _ in range(N)] #矢印が入ってきている数字を-1でフラグ立てる
dp = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
G[x].append((x, y))
memo[y][x] = 1
q = deque()
for i in range(N):
q.append(G[i])
while q:
moves = q.pop()
for move in moves:
x, y = move
dp[y] = max(dp[y], dp[x]+1)
memo[y][x] = 0
q.append(G[y])
print((max(dp)))
| from collections import deque
N, M = list(map(int, input().split()))
G = [[] for _ in range(N)]
# memo = [[0] * N for _ in range(N)] #矢印が入ってきている数字を-1でフラグ立てる
dp = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
G[x].append((x, y))
# memo[y][x] = 1
q = deque()
for i in range(N):
q.append(G[i])
while q:
moves = q.pop()
for move in moves:
x, y = move
dp[y] = max(dp[y], dp[x]+1)
# memo[y][x] = 0
q.append(G[y])
print((max(dp)))
| p03166 |
import sys
sys.setrecursionlimit(10**9)
n , m = list(map(int,input().split()))
g = [[] for i in range(n+1)]
dp = [-1] * (n+1)
for _ in range(m):
v1 , v2 = list(map(int,input().split()))
g[v1].append(v2)
# finding longest path for vertice i
def dfs(i):
if dp[i]!=-1:
return dp[i]
temp = 0
for nv in g[i]:
temp = max(temp, dfs(nv)+1)
dp[i]=temp
return temp
# finding overall longest path
res = 0
for i in range(1,n+1):
res = max(res, dfs(i))
print(res) | import sys
N, M = list(map(int, input().split()))
sys.setrecursionlimit(10**9)
vertices = [[] for i in range(N+1)]
dp = [-1] * (N+1)
for _ in range(M):
fro, to = list(map(int, input().split()))
vertices[fro].append(to)
def dfs(i):
if dp[i] != -1:
return dp[i]
temp = 0
for vertex in vertices[i]:
temp = max(temp, dfs(vertex)+1)
dp[i] = temp
return temp
for i in range(1,N+1):
dfs(i)
print((max(dp))) | p03166 |
N,M = list(map(int,input().split()))
XY = []
for i in range(M):
xy = list(map(int,input().split()))
XY.append(xy)
p = [i+1 for i in range(N)]
ans = []
stack = []
alr = []
xy1 = []
for xy in XY:
xy1.append(xy[1])
for i in range(1,N+1):
if i not in xy1:
stack.append(i)
alr.append(i)
while len(stack) > 0:
p1 = stack.pop(-1)
flag = True
for xy in XY:
if p1 == xy[0]:
alr.append(xy[1])
stack.append(xy[1])
if (p1 == xy[1]) and (xy[0] not in ans):
flag = False
if flag:
ans.append(p1)
dp = [0 for i in range(len(ans))]
for i in range(len(ans)):
for j in range(i):
if [ans[j],ans[i]] in XY:
dp[i] = max(dp[i],dp[j]+1)
print((max(dp)))
| import sys
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline
N,M = list(map(int,input().split()))
XY = [[] for m in range(N)]
for l in range(M):
x,y = list(map(int,input().split()))
XY[x-1].append(y-1)
dp = [-1 for k in range(N)]
def search(i):
if dp[i] != -1:
return dp[i]
c = 0
start = XY[i]
for s in start:
c = max(c,search(s)+1)
dp[i] = c
return dp[i]
a = 0
for i in range(N):
a = max(a,search(i))
print(a)
| p03166 |
import collections
import sys
sys.setrecursionlimit(10000000)
N,M = list(map(int,input().split()))
A = [list(map(int, input().split())) for i in range(M)]
visit = set()
G = collections.defaultdict(set)
for idx,(f,to) in enumerate(A):
G[f].add(to)
cache = {}
def dfs(start):
if start in cache:
return cache[start]
ma = 0
for i in G[start]:
if i not in visit:
visit.add(i)
ma = max(ma,dfs(i))
visit.remove(i)
cache[start] = ma + 1
return ma + 1
ma = 0
for f,to in A:
visit.add(f)
ma = max(ma,dfs(f))
visit.remove(f)
print((ma - 1))
| import collections
import sys
sys.setrecursionlimit(10000000)
N,M = list(map(int,input().split()))
A = [list(map(int, input().split())) for i in range(M)]
visit = set()
G = collections.defaultdict(set)
for idx,(f,to) in enumerate(A):
G[f].add(to)
cache = {}
def dfs(start):
if start in cache:
return cache[start]
ma = 0
for i in G[start]:
if i not in visit:
#visit.add(i)
ma = max(ma,dfs(i))
#visit.remove(i)
cache[start] = ma + 1
return ma + 1
ma = 0
for f,to in A:
#visit.add(f)
ma = max(ma,dfs(f))
#visit.remove(f)
print((ma - 1))
| p03166 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
inf = float('inf')
def rec(v):
if used[v]:
return dp[v]
used[v] = True
res = 0
for u in es[v]:
res = max(res, rec(u) + 1)
dp[v] = res
return res
n, m = list(map(int, input().split()))
es = tuple(set() for _ in range(n))
for _ in range(m):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
es[x].add(y)
used = [False] * n
dp = [inf] * n
ans = 0
for i in range(n):
ans = max(ans, rec(i))
print(ans)
| import sys
sys.setrecursionlimit(10 ** 7)
def dfs(v):
if d[v] != -1:
return d[v]
res = -1
for u in e[v]:
res = max(res, dfs(u))
res += 1
d[v] = res
return res
n, m = list(map(int, input().split()))
e = tuple(set() for _ in range(n))
for _ in range(m):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
e[x].add(y)
d = [-1] * n
res = -1
for v in range(n):
res = max(res, dfs(v))
print(res)
| p03166 |
def main():
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 7)
readline = sys.stdin.readline
@lru_cache(maxsize=None)
def dfs(v, par=-1):
"""最長有向パスに含まれる頂点数"""
ret = 0
for u in g[v]:
if u == par: continue
ret = max(ret, dfs(u, v))
return ret + 1
n, m = list(map(int, readline().split()))
g = tuple(set() for _ in range(n))
for _ in range(m):
x, y = (int(c) - 1 for c in input().split())
g[x].add(y)
ret = 0
for i in range(n):
ret = max(ret, dfs(i))
print((ret - 1))
if __name__ == '__main__':
main()
| def main():
import sys
sys.setrecursionlimit(10 ** 7)
readline = sys.stdin.readline
def dfs(v):
"""最長有向パスに含まれる頂点数"""
if memo[v] != -1:
return memo[v]
ret = 0
for u in g[v]:
ret = max(ret, dfs(u))
ret += 1 # 自身
memo[v] = ret
return ret
n, m = list(map(int, readline().split()))
g = tuple(set() for _ in range(n))
for _ in range(m):
x, y = (int(c) - 1 for c in input().split())
g[x].add(y)
memo = [-1] * n
ret = 0
for i in range(n):
ret = max(ret, dfs(i))
print((ret - 1))
if __name__ == '__main__':
main()
| p03166 |
#!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
g = [ list([int(x)-1 for x in input().split()]) for _ in range(M) ]
from collections import Counter, defaultdict
childs = Counter( x[1] for x in g)
childs_list = defaultdict(list)
for x,y in g:
childs_list[x].append(y)
roots = []
for i in range(N):
if childs[i] == 0:
roots.append(i)
l = [ i for i in roots]
costs = [ 0 for _ in range(N)]
while l:
nex_stack = []
# p = l.pop()
for p in l:
cnt = costs[p]
for c in childs_list[p]:
if cnt+1 > costs[c]:
costs[c] = cnt+1
# l.append( c )
nex_stack.append(c)
l = nex_stack
print((max(costs)))
| #!/mnt/c/Users/moiki/bash/env/bin/python
N,M = list(map(int, input().split()))
g = [ list([int(x)-1 for x in input().split()]) for _ in range(M) ]
from collections import Counter, defaultdict
childs = Counter( x[1] for x in g)
childs_list = defaultdict(list)
for x,y in g:
childs_list[x].append(y)
roots = []
for i in range(N):
if childs[i] == 0:
roots.append(i)
l = [ i for i in roots]
costs = [ 0 for _ in range(N)]
while l:
nex_stack = []
# p = l.pop()
for p in l:
# cnt = costs[p]
for c in childs_list[p]:
costs[c] = max(costs[p]+1, costs[c])
childs[c] -= 1
if childs[c] == 0:
nex_stack.append(c)
l = nex_stack
print((max(costs)))
| p03166 |
import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
N, M = geta(int)
g = defaultdict(lambda: [])
for _ in range(M):
x, y = geta(int)
g[x].append(y)
dp = [-1] * (N + 1)
def dfs(i):
if dp[i] != -1:
return dp[i]
else:
dist = 0
for j in g[i]:
dist_j = 1 + dfs(j)
if dist_j > dist: dist = dist_j
return dist
ans = 0
for i in range(1, N + 1):
tmp = dfs(i)
if tmp > ans: ans = tmp
print(ans)
if __name__ == "__main__":
main() | import sys
from collections import defaultdict
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10**6)
def geta(fn=lambda s: s.decode()):
return list(map(fn, readline().split()))
def gete(fn=lambda s: s.decode()):
return fn(readline().rstrip())
def main():
N, M = geta(int)
g = defaultdict(lambda: [])
for _ in range(M):
x, y = geta(int)
g[x].append(y)
dp = [-1] * (N + 1)
def dfs(i):
if dp[i] == -1:
dist = 0
for j in g[i]:
dist_j = 1 + dfs(j)
if dist_j > dist: dist = dist_j
dp[i] = dist
return dp[i]
ans = 0
for i in range(1, N + 1):
tmp = dfs(i)
if tmp > ans: ans = tmp
print(ans)
if __name__ == "__main__":
main() | p03166 |
from collections import deque
N,M = list(map(int, input().split()))
edge=[[] for j in range(N+1)]
x = [0] * M
y = [0] * M
#N,M=4,5
#x=[1, 1, 3, 2, 3]
#y=[2, 3, 2, 4, 4]
#edge=[[], [2, 3], [4], [2, 4], []]
for i in range(M):
x[i], y[i] = list(map(int, input().split()))
edge[x[i]].append(y[i])
def g(x):
q=deque([x])
move=[[1,0],[-1,0],[0,1],[0,-1]]
num=-1
s=False
while q:
#print(q)
for i in range(len(q)):
b=q.popleft()
if edge[b]==[]:
#print(num)
#print(H*W-kuro-num-1)
num=num
else:
for i in edge[b]:
q.append(i)
num+=1
return num
m=0
for i in range(N):
m=max(m,g(i+1))
print(m) | import sys
sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
G = [[] for _ in range(N + 1)]
for i in range(M):
x, y = list(map(int, input().split()))
G[x] += [y]
# print(G)
dp = [-1] * (N + 1)
def func(n):
if dp[n] != -1:
return dp[n]
cnt = 0
# 先にノードが存在する場合
# ノードが存在しない場合は、cnt=0のままforをすっ飛ばす
for m in G[n]:
cnt = max(cnt, func(m) + 1)
dp[n] = cnt
return cnt
for i in range(1, N + 1):
func(i)
# print(dp)
print((max(dp))) | p03166 |
#DAGの最長有向パスをトポロジカルソートで解く
from collections import defaultdict
N,M=list(map(int,input().split(' ')))
se=set()
d=defaultdict(int)
for i in range(M):
x,y=list(map(int,input().split(' ')))
se.add(x*(10**5)+y)
n=set(i for i in range(1,N+1))
while N>0:
m=set([x%10**5 for x in se])
for i in n-m:
n.remove(i)
N-=1
de=[x for x in se if x//10**5==i]
for j in de:
k=j%10**5
se.remove(j)
if d[k]<=d[i]:
d[k]=d[i]+1
print((max(d.values()))) | from collections import defaultdict, deque
N, M = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(M)]
outs = defaultdict(list)
ins = defaultdict(int)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
length=defaultdict(int)
q = deque(set(i for i in range(1,N+1))-set(ins.keys()))
length=defaultdict(int)
while q:
v1 = q.popleft()
for v2 in outs[v1]:
ins[v2] -= 1
if length[v2]<=length[v1]:
length[v2]=length[v1]+1
if ins[v2] == 0:
q.append(v2)
print((max(length.values()))) | p03166 |
#DAGの最長有向パスをトポロジカルソートで解く
from collections import defaultdict
N,M=list(map(int,input().split(' ')))
se=set()
d=defaultdict(int)
for i in range(M):
x,y=list(map(int,input().split(' ')))
se.add(x*(10**5)+y)
n=set(i for i in range(1,N+1))
while N>0:
m=set([x%10**5 for x in se])
for i in n-m:
n.remove(i)
N-=1
de=set([x for x in se if x//10**5==i])
for j in de:
k=j%10**5
se.remove(j)
if d[k]<=d[i]:
d[k]=d[i]+1
print((max(d.values()))) | from collections import defaultdict
n,m=list(map(int,input().split(' ')))
paths=defaultdict(list)
ins=[0]*(n+1)
for _ in range(m):
x,y=list(map(int,input().split(' ')))
paths[x].append(y)
ins[y]+=1
no_in=[y for y in range(1,n+1) if ins[y]==0]
depth=[0]*(n+1)
while no_in:
x=no_in.pop()
for y in paths[x]:
ins[y]-=1
depth[y]=max(depth[y],depth[x]+1)
if ins[y]==0:
no_in.append(y)
print((max(depth))) | p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
g[x - 1].append(y - 1)
memo = [-1]*n
def dp(v):
if memo[v] >= 0:
return memo[v]
else:
res = 0
for u in g[v]:
res = max(res, dp(u) + 1)
return res
for i in range(n):
memo[i] = dp(i)
print((max(memo)))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
g[x - 1].append(y - 1)
memo = [-1]*n
def dp(v):
if memo[v] >= 0:
return memo[v]
else:
res = 0
for u in g[v]:
res = max(res, dp(u) + 1)
memo[v] = res
return res
for i in range(n):
dp(i)
print((max(memo)))
| p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
g[x - 1].append(y - 1)
memo = [-1]*n
def dp(v):
if memo[v] >= 0:
return memo[v]
else:
res = 0
for u in g[v]:
res = max(res, dp(u) + 1)
memo[v] = res
return res
for i in range(n):
dp(i)
print((max(memo)))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = [int(x) for x in input().split()]
g = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
g[x - 1].append(y - 1)
memo = [0]*n
visited = [False]*n
def dp(v):
if visited[v]:
return memo[v]
else:
res = 0
for u in g[v]:
res = max(res, dp(u) + 1)
memo[v] = res
visited[v] = True
return res
for i in range(n):
dp(i)
print((max(memo)))
| p03166 |
import copy
N,M = list(map(int, input().split()))
t_table = {}
for i in range(M):
x,y = list(map(int, input().split()))
if x-1 in t_table: t_table[x-1].append(y-1)
else: t_table[x-1] = [y-1]
ans = 0
dp = [1 for _ in range(N)]
zerolist = [0 for _ in range(N)]
while True:
pnode = copy.copy(dp)
dp = [0 for _ in range(N)]
for i in range(N):
if pnode[i] == 1 and i in t_table:
for j in t_table[i]:
if dp[j]==0 : dp[j]= 1
if(dp == zerolist):
print(ans)
break
ans += 1
| import sys
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline
N,M = list(map(int, input().split()))
lst_edge = [[] for _ in range(N)]
for _ in range(M):
x,y = list(map(int, input().split()))
lst_edge[x-1].append(y-1)
dp = [-1] * N
def rec(v):
if dp[v] != -1:
return dp[v]
ans = 0
lst_nv = lst_edge[v]
for nv in lst_nv:
ans = max(ans, rec(nv)+1)
dp[v] = ans
return dp[v]
ans = 0
for v in range(N):
ans = max(ans,rec(v))
print(ans) | p03166 |
import sys
sys.setrecursionlimit(10**9)
n,m = list(map(int,input().split()))
graph = [[] for _ in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
graph[x-1].append(y-1)
dp = [0]*(n)
done = []
def dfs(i):
if i in done:
done.pop()
if dp[i] < len(done):dp[i] = len(done)
return len(done)
for j in graph[i]:
if not(j in done):
done.append(i)
dfs(j)
if dp[i] < len(done):dp[i] = len(done)
if done:done.pop()
return len(done)
for i in range(n):
dfs(i)
print((max(dp)))
| import sys
sys.setrecursionlimit(10**9)
n,m = list(map(int,input().split()))
graph = [[] for _ in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
graph[x-1].append(y-1)
dp = [-1]*(n)
def dfs(i):
if dp[i] != -1:
return dp[i]
else:
res = 0
for j in graph[i]:
res = max(res,dfs(j)+1)
dp[i] = res
return dp[i]
for i in range(n):
dfs(i)
print((max(dp))) | p03166 |
import sys
input = sys.stdin.buffer.readline
from collections import deque
def main():
N,M = list(map(int,input().split()))
edge = [[] for _ in range(N)]
begin = [True for _ in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
edge[x-1].append(y-1)
begin[y-1] = False
def longest(s):
INF = 10**10
l = [-INF for _ in range(N)]
l[s] = 0
q = deque([s])
while q:
now = q.popleft()
for fol in edge[now]:
if l[fol] < l[now]+1:
l[fol] = l[now]+1
q.append(fol)
return max(l)
ans = 0
for i,b in enumerate(begin):
if b:
ans = max(ans,longest(i))
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 9)
def main():
N,M = list(map(int,input().split()))
edge = [[] for _ in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
edge[x-1].append(y-1)
dist = [-1 for _ in range(N)]
def dfs(s):
if dist[s] != -1:
return dist[s]
else:
ret = 0
for fol in edge[s]:
ret = max(ret,dfs(fol)+1)
dist[s] = ret
return ret
for i in range(N):
dfs(i)
print((max(dist)))
if __name__ == "__main__":
main()
| p03166 |
# https://atcoder.jp/contests/dp/tasks/dp_g
import sys
sys.setrecursionlimit(10**7)
class DAG:
def __init__(self, n):
# n: num of vertices
self.n = n
self.adj = [[] for _ in range(n)]
def addEdge(self, parent, child):
self.adj[parent].append(child)
def dfs(self, node):
ans = 0
for child in self.adj[node]:
ans = max(ans, 1 + self.dfs(child))
return ans
def dfsWithDp(self, node, dp, visited):
if(visited[node]):
return dp[node]
visited[node] = True
for child in self.adj[node]:
if not visited[child]:
self.dfsWithDp(child, dp, visited)
dp[node] = max(dp[node], 1 + self.dfsWithDp(child, dp, visited))
return dp[node]
# o(n^2) solution
def findLongestPathNaive(self):
ans = 0
for i in range(self.n):
ans = max(ans, self.dfs(i))
return ans
# O(n) solution
def findLongestPathWithDp(self):
visited = [False] * self.n
dp = [0] * self.n # dp[i] := longest path starting from vertex i
ans = 0
for i in range(self.n):
ans = max(ans, self.dfsWithDp(i, dp, visited))
return ans
def main():
N, M = list(map(int, input().split()))
dag = DAG(N)
for _ in range(M):
parent, child = [int(i) - 1 for i in input().split()]
dag.addEdge(parent, child)
# print(dag.findLongestPathWithDp())
print((dag.findLongestPathNaive()))
main()
| # https://atcoder.jp/contests/dp/tasks/dp_g
import sys
sys.setrecursionlimit(10**7)
class DAG:
def __init__(self, n):
# n: num of vertices
self.n = n
self.adj = [[] for _ in range(n)]
def addEdge(self, parent, child):
self.adj[parent].append(child)
def dfs(self, node):
ans = 0
for child in self.adj[node]:
ans = max(ans, 1 + self.dfs(child))
return ans
def dfsWithMemo(self, node, memo, visited):
if(visited[node]):
return memo[node]
visited[node] = True
for child in self.adj[node]:
memo[node] = max(
memo[node], 1 + self.dfsWithMemo(child, memo, visited))
return memo[node]
def dfsWithDp(self, node, dp, visited):
if(visited[node]):
return dp[node]
visited[node] = True
for child in self.adj[node]:
if not visited[child]:
self.dfsWithDp(child, dp, visited)
dp[node] = max(dp[node], 1 + self.dfsWithDp(child, dp, visited))
return dp[node]
# o(n^2) solution
def findLongestPathNaive(self):
ans = 0
for i in range(self.n):
ans = max(ans, self.dfs(i))
return ans
# o(n) solution
def findLongestPathWithMemo(self):
visited = [False] * self.n
memo = [0] * self.n
ans = 0
for i in range(self.n):
ans = max(ans, self.dfsWithMemo(i, memo, visited))
return ans
# O(n) solution
def findLongestPathWithDp(self):
visited = [False] * self.n
dp = [0] * self.n # dp[i] := longest path starting from vertex i
ans = 0
for i in range(self.n):
ans = max(ans, self.dfsWithDp(i, dp, visited))
return ans
def main():
N, M = list(map(int, input().split()))
dag = DAG(N)
for _ in range(M):
parent, child = [int(i) - 1 for i in input().split()]
dag.addEdge(parent, child)
# print(dag.findLongestPathNaive())
print((dag.findLongestPathWithMemo()))
# print(dag.findLongestPathWithDp())
main()
| p03166 |
import sys
from functools import lru_cache
sys.setrecursionlimit(524287)
n,m,*l = list(map(int,open(0).read().split()))
pas = [[] for _ in range(n)]
for x,y in zip(l[::2],l[1::2]):
pas[x-1].append(y-1)
INF = float("inf")
done = [-INF]*n
@lru_cache(maxsize = None)
def dfs(t):
if done[t] >= 0:
pass
elif pas[t]:
done[t] = max(dfs(s) for s in pas[t]) + 1
else:
done[t] = 0
return done[t]
print((max(dfs(i) for i in range(n)))) | import sys
sys.setrecursionlimit(524287)
n,m,*l = list(map(int,open(0).read().split()))
pas = [[] for _ in range(n)]
for x,y in zip(l[::2],l[1::2]):
pas[x-1].append(y-1)
INF = float("inf")
done = [-INF]*n
def dfs(t):
if done[t] >= 0:
pass
elif pas[t]:
done[t] = max(dfs(s) for s in pas[t]) + 1
else:
done[t] = 0
return done[t]
print((max(dfs(i) for i in range(n))))
| p03166 |
from collections import deque
def bfs(vertices, start):
q = deque()
q.append(start)
while q:
u = q.popleft()
for v in vertices[u]:
if vis[v]==0 or (vis[u]+1>vis[v]) :
vis[v]=vis[u]+1
q.append(v)
return max(vis)
n,m=list(map(int,input().split()))
v=[[] for i in range(n+1)]
for i in range(m):
x,y=list(map(int,input().split()))
v[x].append(y)
vis = [0]*(n+1)
vis[0]=1
m=0
while 0 in vis:
i=vis.index(0)
vis[i]=1
m=max(m,bfs(v,i))
print((m-1)) | import sys
input=sys.stdin.readline
#for _ in range(int(input())):
# n=int(input())
# n,m=map(int,input().split())
# s=input().strip()
sys.setrecursionlimit(10**9)
def dfs(i):
if dp[i]!=-1:return dp[i]
c=0
for j in v[i]:c=max(c,dfs(j)+1)
dp[i]=c
return c
n,m=list(map(int,input().split()))
v=[[] for i in range(n+1)]
for i in range(m):
x,y=list(map(int,input().split()))
v[x].append(y)
dp = [-1]*(n+1)
m=0
for i in range(1,n+1):
m=max(m,dfs(i))
print(m) | p03166 |
import sys
sys.setrecursionlimit(100000)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
dpv = [-1]*N
def dp(v):
if dpv[v] != -1:
return dpv[v]
if len(edge[v])==0:
dpv[v]=0
return 0
res = 0
for w in edge[v]:
res = max(dp(w),res)
res += 1
dpv[v] = res
return res
def solve():
for i in range(N):
dp(i)
ans = max(dpv)
# print(dpv)
return ans
print((solve())) | import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
def dfs(v):
if len(edge[v])==0:
return 0
ans = 0
for u in edge[v]:
if longest[u]==-1:
longest[u]=dfs(u)
ans = max(ans,longest[u]+1)
return ans
longest = [-1]*N
for i in range(N):
if longest[i]==-1:
longest[i] = dfs(i)
ans = max(longest)
print(ans) | p03166 |
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
to = [False]*N
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
to[b-1] = True
import sys
sys.setrecursionlimit(10**8)
def dfs(v):
if lis[v]>=0:
return lis[v]
if len(edge[v])==0:
lis[v] = 1
return 1
ans = 0
for u in edge[v]:
ans = max(ans, dfs(u))
lis[v] = ans+1
return ans+1
ans = 0
lis = [-1]*N
for r in range(N):
if to[r]==False:
ans = max(ans, dfs(r)-1)
print(ans) | import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(M):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
def dfs(start):
stack = [start]
while stack:
v = stack[-1]
marker = 0
path_l[v] = 0
for u in edge[v]:
if path_l[u]==-1: #子へ降ろす
marker = 1
stack.append(u)
else: #子から吸い上げる
#吸い上げる際の個々の処理
path_l[v] = max(path_l[v], path_l[u]+1)
if marker==0:
stack.pop()
return
path_l = [-1]*N
for i in range(N):
if path_l[i]==-1:
dfs(i)
ans = max(path_l)
print(ans)
| p03166 |
from collections import defaultdict, deque
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
#print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
#print(ins)
#print("be",ins)
q = deque(v1 for v1 in range(v+1) if ins[v1] == 0)
#print("af",ins)
res = []
#print(outs)
#print(ins)
while q:
#print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]:
#print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0:
#print("<--",v2)
q.append(v2)
#print(res[1:])
#print(outs)
#print(ins)
dp = [0]*(v+1)
for i in res[1:]:
for j in outs[i]:
dp[j] = dp[i] + 1
#print(i, j, dp)
print((max(dp))) | """memo
トポロジカルソート「http://zehnpaard.hatenablog.com/entry/2018/06/26/201512」
をしてから，dpで求めた．（ソートと同時にdp求められそう）
"""
from collections import deque, defaultdict
import sys
input == sys.stdin.readline
def main():
v, n = list(map(int, input().split()))
es = [[int(x) for x in input().split()] for _ in range(n)]
outs = defaultdict(list)
ins = defaultdict(int)
#print(ins)
for v1, v2 in es:
outs[v1].append(v2)
ins[v2] += 1
#print(ins)
#print("be",ins)
q = deque(v1 for v1 in range(1,v+1) if ins[v1] == 0) #rangeは無駄なものがない
#print("af",ins)
res = []
#print(outs)
#print(ins)
dp = [0]*(v+1)
while q:
#print(q)
v1 = q.popleft()
res.append(v1)
for v2 in outs[v1]: #v1のノードから出ている矢印をみる．
dp[v2] = dp[v1] + 1
#print("-->",v2)
ins[v2] -= 1
if ins[v2] == 0: #v2のノードに入る矢印をすべて見たときにqに追加
#print("<--",v2)
q.append(v2)
#print(res[1:])
#print(outs)
#print(ins)
print((max(dp)))
if __name__ == '__main__':
main() | p03166 |
import sys
sys.setrecursionlimit(10**7)
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
edge[x-1].append(y-1)
dp = [-1]*n
def calc(x):
if dp[x] != -1:
return dp[x]
if not len(edge[x]):
dp[x] = 0
return 0
dp[x] = max(calc(i) for i in edge[x])+1
return dp[x]
ans = 0
for i in range(n):
if dp[i] != -1: continue
ans = max(ans, calc(i))
print(ans) | import sys
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
edge[x-1].append(y-1)
dp = [-1]*N
def calc(x):
if dp[x]!=-1:
return dp[x]
if not len(edge[x]):
dp[x] = 0
return 0
dp[x] = max([calc(i) for i in edge[x]])+1
return dp[x]
ans = 0
for i in range(N):
if dp[i] != -1: continue
ans = max(ans, calc(i))
print(ans)
| p03166 |
import collections
N,M = list(map(int,input().split()))
road = [[] for i in range(N+1)]
rev_road = [[] for i in range(N+1)]
for _ in range(M):
x,y=list(map(int,input().split()))
road[x].append(y)
rev_road[y].append(x)
dep = []
for i in range(1,N+1):
if len(rev_road[i]) == 0:
dep.append(i)
def largest_distance(i):
q = collections.deque([i])
dp =[0]*(N+1) #地点iからの最長経路
dp_max = 0
while q:
now = q.popleft()
for direct in road[now]:
if dp[direct]<=dp[now]:
dp[direct] = dp[now]+1
q.append(direct)
dp_max = max(dp_max,dp[direct])
return dp_max
ans = 0
for de in dep:
ans = max(ans,largest_distance(de))
print(ans)
| import sys
sys.setrecursionlimit(10**9)
N,M = list(map(int,input().split()))
road = [[] for _ in range(N+1)]
for _ in range(M):
x,y=list(map(int,input().split()))
road[x].append(y)
flag = [0]*(N+1)
dist = [0]*(N+1)
def distance(i):#地点iから終点までの最長距離
if flag[i] == 1:
return dist[i]
if road[i] == []:#行き先がない
return 0
else:#行き先がある
long_dist = 0
tmp = 0
for dirct in road[i]:
tmp = 1 + distance(dirct)
long_dist = max(long_dist,tmp)
flag[i]=1
dist[i] = long_dist
return long_dist
ans = 0
for i in range(1,N+1):
ans = max(ans,distance(i))
print(ans)
| p03166 |
import sys
from collections import deque
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()
def main():
N,M=list(map(int,input().split()))
edge=[[] for _ in range(N)]
s=set(range(N))
for _ in range(M):
x,y=[int(x)-1 for x in input().split()]
edge[x].append(y)
try:
s.remove(y)
except:
pass
que=deque(s)
memo=[0]*N
ans=0
while que:
v=que.popleft()
for nv in edge[v]:
memo[nv]=max(memo[nv],memo[v]+1)
ans=max(ans,memo[nv])
que.append(nv)
print(ans)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()
def main():
N,M=list(map(int,input().split()))
edge=[[] for _ in range(N)]
s=set(range(N))
for _ in range(M):
x,y=[int(x)-1 for x in input().split()]
edge[x].append(y)
try:
s.remove(y)
except:
pass
que=list(s)
memo=[0]*N
def saiki(v):
if memo[v]:
return memo[v]
tmp=0
for nv in edge[v]:
memo[v]=max(memo[v],saiki(nv)+1)
tmp=max(tmp,memo[v])
return tmp
ans=0
for v in que:
ans=max(ans,saiki(v))
print(ans)
if __name__ == '__main__':
main()
| p03166 |
from sys import stdin, setrecursionlimit
# input = stdin.readline
setrecursionlimit(200000)
N, M = list(map(int, input().split()))
# d = [0] * (N + 1)
adj = [[] for _ in range(N + 1)]
for _ in range(M):
x, y = list(map(int, input().split()))
adj[x].append(y)
# d[y] += 1
dp = [-1] * (N + 1)
def lp(x: 'int') -> 'int':
if dp[x] >= 0:
return dp[x]
else:
dp[x] = 0
for y in adj[x]:
dp[x] = max(dp[x], lp(y) + 1)
return dp[x]
print((max(lp(i) for i in range(1, N + 1))))
| from sys import stdin, setrecursionlimit
input = stdin.readline
setrecursionlimit(200000)
N, M = list(map(int, input().split()))
# d = [0] * (N + 1)
adj = [[] for _ in range(N + 1)]
for _ in range(M):
x, y = list(map(int, input().split()))
adj[x].append(y)
# d[y] += 1
dp = [-1] * (N + 1)
def lp(x: 'int') -> 'int':
if dp[x] >= 0:
return dp[x]
else:
dp[x] = 0
for y in adj[x]:
dp[x] = max(dp[x], lp(y) + 1)
return dp[x]
print((max(lp(i) for i in range(1, N + 1))))
| p03166 |
from sys import stdin, setrecursionlimit
from collections import defaultdict
input = stdin.readline
setrecursionlimit(200000)
N, M = list(map(int, input().split()))
# d = [0] * (N + 1)
adj = defaultdict(list)
for _ in range(M):
x, y = list(map(int, input().split()))
adj[x].append(y)
# d[y] += 1
dp = [-1] * (N + 1)
def lp(x: 'int') -> 'int':
if dp[x] >= 0:
return dp[x]
else:
dp[x] = 0
for y in adj[x]:
dp[x] = max(dp[x], lp(y) + 1)
return dp[x]
print((max(lp(i) for i in range(1, N + 1))))
| """
https://atcoder.jp/contests/dp/tasks/dp_g
Using list to store adjacent list is faster than using sets.
Maybe it is because the append operation of list in python is faster than add operation of sets.
Using defaultdict instead of list to store adj is faster. Maybe it is because in case the graph is
sparse, defauldict can save more query time.
"""
from sys import stdin
from collections import defaultdict, deque
input = stdin.readline
N, M = list(map(int, input().split()))
d = [0] * (N + 1)
adj = defaultdict(list)
for _ in range(M):
x, y = list(map(int, input().split()))
adj[x].append(y)
d[y] += 1
dp = [0] * (N + 1) # dp denotes longest path ends at i
Q = deque([i for i in range(1, N + 1) if d[i] == 0])
while Q:
cur = Q.popleft()
for nxt in adj[cur]:
dp[nxt] = max(dp[nxt], dp[cur] + 1)
d[nxt] -= 1
if d[nxt] == 0:
Q.append(nxt)
print((max(dp)))
| p03166 |
import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
G = dict([[i, []] for i in range(N)])
for _ in range(M):
x, y = list(map(int, input().split()))
G[x-1].append(y-1)
dp = [-1] * N
def rec(v):
if dp[v] >= 0:
return dp[v]
if len(G[v]) == 0:
return 0
ret = -1
for nv in G[v]:
ret = max(ret, rec(nv) + 1)
return ret
print((max([rec(v) for v in range(N)])))
| import sys
sys.setrecursionlimit(10**8)
N, M = list(map(int, input().split()))
G = dict([[i, []] for i in range(N)])
for _ in range(M):
x, y = list(map(int, input().split()))
G[x-1].append(y-1)
dp = [-1] * N
def rec(v):
if dp[v] >= 0:
return dp[v]
if len(G[v]) == 0:
return 0
ret = -1
for nv in G[v]:
ret = max(ret, rec(nv) + 1)
dp[v] = ret
return ret
print((max([rec(v) for v in range(N)])))
| p03166 |
from collections import deque
def main():
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n+1)]
for _ in range(m):
src, dst = list(map(int, input().split()))
graph[dst].append(src)
dist = [0] * (n+1)
for node in range(1, n+1):
visited = [False] * (n+1)
q = deque([node])
while q:
at = q.popleft()
visited[at] = True
for to in graph[at]:
dist[to] = max(dist[to], dist[at] + 1)
if not visited[to]:
q.append(to)
print((max(dist[1:])))
if __name__ == '__main__':
main()
| from collections import deque
def main():
n, m = list(map(int, input().split()))
graph = [[] for _ in range(n+1)]
parents = [0] * (n+1)
for _ in range(m):
src, dst = list(map(int, input().split()))
graph[src].append(dst)
parents[dst] += 1
q = deque()
for i in range(1, n+1):
if parents[i] == 0:
q.append(i)
dists = [0] * (n+1)
for i in q:
dists[0] = 0
while q:
at = q.popleft()
for to in graph[at]:
parents[to] -= 1
if parents[to] == 0:
q.append(to)
dists[to] = dists[at] + 1
print((max(dists[1:])))
if __name__ == '__main__':
main()
| p03166 |
### 動的計画法のテーブルを用意
# dp(n) は頂点nを始点として時の最大有効パスの長さ
def get_inputs():
N, M = list(map(int, input().split()))
# グラフgを初期化
g = [[] for _ in range(N)]
# 辺情報を読み込みgに追加
for _ in range(M):
x, y = [int(c) - 1 for c in input().split()]
g[x].append(y)
return N, M, g
def getlp(x, depth):
global dp, g
if depth >= MAX_DEPTH:
return -1
elif dp[x] != -1:
return dp[x]
elif len(g[x]) == 0:
dp[x] = 0
return dp[x]
else:
mxp = 0
for y in g[x]:
yp = getlp(y, depth + 1)
if yp == -1:
return -1
elif yp > mxp:
mxp = yp
dp[x] = mxp + 1
return dp[x]
N, M, g = get_inputs()
MAX_DEPTH = 900
dp = [-1] * N
nodes = list(range(N))
ans = 0
while len(nodes) > 0:
tmp_nodes = []
for x in range(N):
if dp[x] == -1:
t = getlp(x, 0)
if t == -1:
tmp_nodes.append(x)
else:
ans = max(ans, t)
else:
ans = max(ans, dp[x])
nodes = list(tmp_nodes)
print(ans)
| import sys
sys.setrecursionlimit(10**5)
def get_inputs():
N, M = list(map(int, input().split()))
# グラフgを初期化
g = [[] for _ in range(N)]
# 辺情報を読み込みgに追加
for _ in range(M):
x, y = [int(c) - 1 for c in input().split()]
g[x].append(y)
return N, M, g
def getlp(x):
global dp, g
if dp[x] != -1:
return dp[x]
elif len(g[x]) == 0:
dp[x] = 0
return dp[x]
else:
dp[x] = max([getlp(y) for y in g[x]]) + 1
return dp[x]
N, M, g = get_inputs()
dp = [-1] * N
ans = 0
for x in range(N):
ans = max(ans, getlp(x))
print(ans)
| p03166 |
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
from collections import deque
sys.setrecursionlimit(10**6)
N, M = mi()
x = li2(M)
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
flag = [0]*N
ans = deque([])
def dfs(x, ans):
if flag[x]:
return None
else:
flag[x] = 1
if adj[x]:
for a in adj[x]:
dfs(a, ans)
#global ans
ans.appendleft(x)
for i in range(N):
dfs(i, ans)
dp = [0]*N
for a in ans:
if adj[a]:
for b in adj[a]:
dp[b] = max(dp[b], dp[a] + 1)
print((max(dp))) | import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
from collections import deque
sys.setrecursionlimit(10**6)
N, M = mi()
x = li2(M)
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
flag = [0]*N
ans = deque([])
def dfs(x):
if flag[x]:
return None
else:
flag[x] = 1
for a in adj[x]:
dfs(a)
global ans
ans.appendleft(x)
for i in range(N):
dfs(i)
dp = [0]*N
for a in ans:
for b in adj[a]:
dp[b] = max(dp[b], dp[a] + 1)
print((max(dp))) | p03166 |
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
from collections import deque
sys.setrecursionlimit(10**6)
N, M = mi()
x = li2(M)
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
flag = [0]*N
ans = deque([])
def dfs(x):
if flag[x]:
return None
else:
flag[x] = 1
for a in adj[x]:
dfs(a)
global ans
ans.appendleft(x)
for i in range(N):
dfs(i)
dp = [0]*N
for a in ans:
for b in adj[a]:
dp[b] = max(dp[b], dp[a] + 1)
print((max(dp))) | import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**6)
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp))) | p03166 |
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**8)
#メモ化再帰
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
#メモ化再帰を実行
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp))) | import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**9)
#メモ化再帰
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
#メモ化再帰を実行
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp))) | p03166 |
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
from collections import deque
N, M = mi()
x = li2(M)
dp = [[0, []] for i1 in range(N+1)]
tmp = deque([])
for i in range(M):
dp[x[i][1]][0] = max(dp[x[i][1]][0], dp[x[i][0]][0] + 1)
dp[x[i][0]][1].append(x[i][1])
tmp.append(x[i][1])
while tmp != deque():
a = tmp.popleft()
if dp[a][1] != []:
for b in dp[a][1]:
dp[b][0] = max(dp[a][0] + 1, dp[b][0])
tmp.append(b)
#print(dp)
print((max([row[0] for row in dp]))) | import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**8)
#メモ化再帰
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
#メモ化再帰を実行
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp))) | p03166 |
def solve():
n, list_of_xy = read()
result = think(n, list_of_xy)
write(result)
def read():
n, m = read_int(2)
list_of_xy = []
for i in range(m):
list_of_xy.append(read_int(2))
return n, list_of_xy
def read_int(n):
return list([int(x) for x in read_line().split(' ')])[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(n, list_of_xy):
num_of_input_edges = [0 for _ in range(n + 1)]
num_of_output_edges = [0 for _ in range(n + 1)]
invalid_value = -1
length_of_longest_path_start_from = [invalid_value for _ in range(n + 1)]
for x, y in list_of_xy:
num_of_input_edges[y] += 1
num_of_output_edges[x] += 1
for i in range(1, len(num_of_input_edges)):
if num_of_output_edges[i] == 0:
length_of_longest_path_start_from[i] = 0
for i in range(1, len(num_of_input_edges)):
if num_of_input_edges[i] == 0:
update_logest_path_start_from(i, list_of_xy, length_of_longest_path_start_from, invalid_value)
return max(length_of_longest_path_start_from)
def update_logest_path_start_from(start_from, list_of_xy, length_of_longest_path_start_from, invalid_value):
if length_of_longest_path_start_from[start_from] != invalid_value:
return
subset_of_list_of_xy = list([x for x in list_of_xy if x[0] == start_from])
for x, y in subset_of_list_of_xy:
if length_of_longest_path_start_from[y] == invalid_value:
update_logest_path_start_from(y, list_of_xy, length_of_longest_path_start_from, invalid_value)
length_of_longest_path_start_from[x] = max(length_of_longest_path_start_from[x], length_of_longest_path_start_from[y] + 1)
else:
length_of_longest_path_start_from[x] = max(length_of_longest_path_start_from[x], length_of_longest_path_start_from[y] + 1)
def write(result):
print(result)
if __name__ == '__main__':
solve() | import sys
def solve():
n, list_of_xy = read()
result = think(n, list_of_xy)
write(result)
def read():
n, m = read_int(2)
list_of_xy = []
for i in range(m):
list_of_xy.append(read_int(2))
return n, list_of_xy
def read_int(n):
return list([int(x) for x in read_line().split(' ')])[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(n, list_of_xy):
num_of_input_edges = [0 for _ in range(n + 1)]
num_of_output_edges = [0 for _ in range(n + 1)]
linked_list = generate_linked_list(list_of_xy)
invalid_value = -1
length_of_longest_path_start_from = [invalid_value for _ in range(n + 1)]
for x, y in list_of_xy:
num_of_input_edges[y] += 1
num_of_output_edges[x] += 1
for i in range(1, len(num_of_input_edges)):
if num_of_output_edges[i] == 0:
length_of_longest_path_start_from[i] = 0
for i in range(1, len(num_of_input_edges)):
if num_of_input_edges[i] == 0:
update_logest_path_start_from(i, linked_list, length_of_longest_path_start_from, invalid_value)
return max(length_of_longest_path_start_from)
def generate_linked_list(list_of_xy):
linked_list = {}
for x, y in list_of_xy:
if x in linked_list:
linked_list[x].append(y)
else:
linked_list[x] = [y]
return linked_list
def update_logest_path_start_from(x, linked_list, length_of_longest_path_start_from, invalid_value):
if length_of_longest_path_start_from[x] != invalid_value:
return
dest_from_x = linked_list.get(x, [])
for y in dest_from_x:
if length_of_longest_path_start_from[y] == invalid_value:
update_logest_path_start_from(y, linked_list, length_of_longest_path_start_from, invalid_value)
length_of_longest_path_start_from[x] = max(length_of_longest_path_start_from[x], length_of_longest_path_start_from[y] + 1)
else:
length_of_longest_path_start_from[x] = max(length_of_longest_path_start_from[x], length_of_longest_path_start_from[y] + 1)
def write(result):
print(result)
if __name__ == '__main__':
sys.setrecursionlimit(10 ** 5)
solve() | p03166 |
import sys
import collections
from functools import lru_cache
xy = []
d = collections.defaultdict(list)
@lru_cache(maxsize=None)
def alg_memoization_recursion(f):
mt = 0
for v in d[f]:
mt = max(mt, alg_memoization_recursion(v) + 1)
return mt
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 5 + 1)
n, m = list(map(int, readline().split()))
for i in range(m):
x, y = list(map(int, readline().split()))
d[x-1] += [y-1]
mt = 0
for i in range(n):
mt = max(mt, alg_memoization_recursion(i))
print(mt)
if __name__ == '__main__':
solve()
| import sys
import collections
from functools import lru_cache
sys.setrecursionlimit(10 ** 7 + 1)
xy = []
d = collections.defaultdict(list)
@lru_cache(maxsize=None)
def alg_memoization_recursion(f):
mt = 0
for v in d[f]:
mt = max(mt, alg_memoization_recursion(v) + 1)
return mt
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n, m = list(map(int, readline().split()))
for i in range(m):
x, y = list(map(int, readline().split()))
d[x-1] += [y-1]
mt = 0
for i in range(n):
mt = max(mt, alg_memoization_recursion(i))
print(mt)
if __name__ == '__main__':
solve()
| p03166 |
import sys
sys.setrecursionlimit(10 ** 5 + 5)
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
N, M = list(map(int, input().split()))
x, y = [0] * M, [0] * M
from_x = [[] for _ in range(N)]
memo = [-1] * N
ans = 0
def length(i):
if memo[i] >= 0:
return memo[i]
else:
if len(from_x[i]) == 0:
memo[i] = 0
return memo[i]
else:
ret = 0
for j in from_x[i]:
tmp = length(j) + 1
if tmp > ret:
ret = tmp
memo[i] = ret
return ret
for i in range(M):
x[i], y[i] = list(map(int, input().split()))
from_x[y[i] - 1].append(x[i] - 1)
for i in range(N):
tmp = length(i)
if tmp > ans:
ans = tmp
print(ans)
| import sys
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
N, M = list(map(int, input().split()))
to_y = [[] for _ in range(N)]
deg = [0] * N
stack = []
dp = [0] * N
for _ in range(M):
x, y = list(map(int, input().split()))
to_y[x - 1].append(y - 1)
deg[y - 1] += 1
for i in range(N):
if deg[i] == 0:
stack.append(i)
while stack:
x = stack.pop(-1)
for y in to_y[x]:
dp[y] = max(dp[y], dp[x] + 1)
deg[y] -= 1
if deg[y] == 0:
stack.append(y)
print((max(dp))) | p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(m):
x, y = list([int(x)-1 for x in input().split()])
edges[x].append(y)
def memoize(f):
memo = dict()
def memoized(*args):
if args in list(memo.keys()):
return memo[args]
else:
memo[args] = f(*args)
return memo[args]
return memoized
@memoize
def longest_path(v):
retval = 0
for v2 in edges[v]:
retval = max(retval, longest_path(v2)+1)
return retval
ans = 0
for i in range(n):
ans = max(ans, longest_path(i))
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(m):
x, y = list([int(x)-1 for x in input().split()])
edges[x].append(y)
dist = [-1]*n
def longest_path(v):
if dist[v] != -1:
return dist[v]
retval = 0
for v2 in edges[v]:
retval = max(retval, longest_path(v2)+1)
dist[v] = retval
return dist[v]
ans = 0
for i in range(n):
ans = max(ans, longest_path(i))
print(ans) | p03166 |
from collections import deque, defaultdict
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
edges = [[]for _ in range(n)]
dd = defaultdict(int)
for _ in range(m):
x, y = list([int(x)-1 for x in input().split()])
edges[x].append(y)
dd[y] += 1
queue = deque([])
for i in range(n):
if dd[i] == 0:
queue.append(i)
toposorted = []
while queue:
v = queue.popleft()
toposorted.append(v)
for v2 in edges[v]:
if dd[v2] <= 0:
continue
dd[v2] -= 1
if dd[v2] == 0:
queue.append(v2)
dist = [0]*n
for i in range(n):
v = toposorted[i]
for v2 in edges[v]:
if dist[v2] <= dist[v]-1:
continue
dist[v2] = dist[v]-1
print((-min(dist)))
| from collections import deque
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
edges = [[]for _ in range(n)]
dinp = [0]*n
for _ in range(m):
x, y = list([int(x)-1 for x in input().split()])
edges[x].append(y)
dinp[y] += 1
queue = deque([])
for i in range(n):
if dinp[i] == 0:
queue.append(i)
toposorted = []
while queue:
v = queue.popleft()
toposorted.append(v)
for v2 in edges[v]:
dinp[v2] -= 1
if dinp[v2] == 0:
queue.append(v2)
dist = [0]*n
for i in range(n):
v = toposorted[i]
for v2 in edges[v]:
if dist[v2] <= dist[v]-1:
continue
dist[v2] = dist[v]-1
print((-min(dist)))
| p03166 |
from collections import deque
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
tree = [[] for i in range(n)]
for i in range(m):
a, b = info[i]
a -= 1
b -= 1
tree[a].append(b)
set_ = set([])
for i in range(n):
for j in tree[i]:
set_.add(j)
start = set([])
for i in range(n):
if i not in set_:
start.add(i)
q = deque([])
for i in start:
q.append(i)
dp = [0]*n
while q:
pos = q.popleft()
for next_pos in tree[pos]:
if dp[pos] + 1 > dp[next_pos]:
dp[next_pos] = dp[pos] + 1
q.append(next_pos)
print((max(dp))) | import sys
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
tree = [[] for i in range(n)]
for i in range(m):
a, b = info[i]
a -= 1
b -= 1
tree[a].append(b)
set_ = set([])
for i in range(n):
for j in tree[i]:
set_.add(j)
start = set([])
for i in range(n):
if i not in set_:
start.add(i)
memo = {}
dp = [0]*n
def solve(pos):
if pos in memo:
return memo[pos]
if len(tree[pos]) == 0:
memo[pos] = 0
return memo[pos]
tmp = 0
for next_pos in tree[pos]:
tmp = max(solve(next_pos) + 1, tmp)
memo[pos] = tmp
return memo[pos]
for i in range(n):
solve(i)
ans = 0
for i in memo:
ans = max(ans, memo[i])
print(ans) | p03166 |
def dfs(num,count,ans):
#print(num,count)
ans=max(ans,count)
for index,item in enumerate(l[num-1]):
if item==1:
dp[index+1]=max(dp[index+1],count)
ans=dfs(index+1,count+1,ans)
return ans
N,M=list(map(int,input().split()))
l=[[0]*N for _ in range(N)]
start=[i+1 for i in range(N)]
for _ in range(M):
x,y=list(map(int,input().split()))
l[x-1][y-1]=1
try:
start.remove(y)
except:
pass
#print(l)
dp=[0]*(N+1)
ans=0
for i in start:
ans=max(dfs(i,0,0),ans)
#print(dp)
print(ans)
| # coding: utf-8
# Your code here!
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
N,M=list(map(int,input().split()))
linked=[[] for i in range(N)]
for _ in range(M):
x,y=list(map(int,input().split()))
linked[x-1].append(y-1)
def saiki(num):
if visited[num]==1:
return dp[num]
visited[num]=1
value=0
if linked[num]:
for item in linked[num]:
value=max(value,saiki(item)+1)
dp[num]=value
return value
dp=[0]*N
visited=[0]*N
ans=0
for i in range(N):
ans=max(ans,saiki(i))
print(ans) | p03166 |
import sys
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache
sys.setrecursionlimit(10**6)
@lru_cache(maxsize=None)
def rec(v):
res=0
for nv in graph[v]:
res=max(res,rec(nv)+1)
return res
def main():
n,m=list(map(int,input().split()))
XY=[tuple(map(int,input().split())) for i in range(m)]
global dp,graph
graph=[[]for _ in range(n)]
for x,y in XY:
graph[x-1].append(y-1)
dp=[-1]*n #頂点i(0-)を始点としたときの有効パスの長さの最大値
ans=0
for v in range(n):
ans=max(ans,rec(v))
print(ans)
if __name__=='__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache
sys.setrecursionlimit(10**6)
@lru_cache(maxsize=None)
def rec(v):
res=0
for nv in graph[v]:
res=max(res,rec(nv)+1)
return res
def main():
n,m=list(map(int,input().split()))
XY=[tuple(map(int,input().split())) for i in range(m)]
global graph
graph=[[]for _ in range(n)]
for x,y in XY:
graph[x-1].append(y-1)
ans=0
for v in range(n):
ans=max(ans,rec(v))
print(ans)
if __name__=='__main__':
main() | p03166 |
import sys
def input(): return sys.stdin.readline().rstrip()
from functools import lru_cache
sys.setrecursionlimit(10**6)
@lru_cache(maxsize=None)
def rec(v):
res=0
for nv in graph[v]:
res=max(res,rec(nv)+1)
return res
def main():
n,m=list(map(int,input().split()))
XY=[tuple(map(int,input().split())) for i in range(m)]
global graph
graph=[[]for _ in range(n)]
for x,y in XY:
graph[x-1].append(y-1)
ans=0
for v in range(n):
ans=max(ans,rec(v))
print(ans)
if __name__=='__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**6)
def rec(v):
if dp[v]!=-1:return dp[v]
res=0
for nv in graph[v]:
res=max(res,rec(nv)+1)
dp[v]=res
return res
def main():
n,m=list(map(int,input().split()))
XY=[tuple(map(int,input().split())) for i in range(m)]
global dp,graph
graph=[[]for _ in range(n)]
for x,y in XY:
graph[x-1].append(y-1)
dp=[-1]*n #頂点i(0-)を始点としたときの有効パスの長さの最大値
ans=0
for v in range(n):
ans=max(ans,rec(v))
print(ans)
if __name__=='__main__':
main()
| p03166 |
from collections import deque
def main():
n, adj = getInputs()
# maxDistance[start]
maxDistance = [0] * n
calculated = set()
for v in getVertexSequence(n, adj):
# distance[dest] (starting at v)
distance = [0] * n
toVisit = deque([v])
while len(toVisit) > 0:
curr = toVisit.popleft()
for dest in adj[curr]:
if dest in calculated:
distance[dest] = max(
distance[dest],
distance[curr] + maxDistance[dest] + 1
)
else:
if distance[curr] + 1 > distance[dest]:
distance[dest] = distance[curr] + 1
toVisit.append(dest)
maxDistance[v] = max(distance)
calculated.add(v)
print((max(maxDistance)))
def getInputs():
n, m = [int(x) for x in input().split()]
adj = []
for i in range(n):
adj.append([])
for i in range(m):
a, b = [int(x) for x in input().split()]
adj[a - 1].append(b - 1)
return n, adj
def getVertexSequence(n, adj):
pairs = []
for i in range(n):
pairs.append((i, adj[i]))
pairs.sort(key=(lambda x: len(x[1])))
sequence = []
for i in range(n):
sequence.append(pairs[i][0])
return sequence
main()
| import sys
sys.setrecursionlimit(1000000)
def main():
n, m = [int(x) for x in input().split()]
global dp
dp = [-1]*n
grafo = [[] for _ in range(n)]
for _ in range(m):
x, y = [int(x) for x in input().split()]
x -= 1
y -= 1
grafo[x].append(y)
resp = 0
for u in range(n):
resp = max(dfs(u, grafo), resp)
print(resp)
def dfs(u, grafo):
global dp
if len(grafo[u]) == 0:
dp[u] = 0
return dp[u]
if dp[u] != -1:
return dp[u]
for v in grafo[u]:
dp[u] = max(dfs(v, grafo) + 1, dp[u])
return dp[u]
main() | p03166 |
import sys
input=sys.stdin.readline
def longest_path(s):
global dp
if adj[s]:
dp[s-1]=max((longest_path(t)+1)for t in adj[s])
else:
dp[s-1]=0
return dp[s-1]
N,M=list(map(int,input().split()))
edge=[]
for _ in range(M):
edge.append(list(map(int,input().split())))
adj={}
for n in range(1,N+1):
l=[]
for m in range(M):
if edge[m][0]==n:
l.append(edge[m][1])
adj[n]=l
dp=[0]*N
for i in range(1,N+1):
if dp[i-1]==0:
longest_path(i)
print((max(dp))) | import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
def longest_path(s):
global dp
if dp[s-1]<1:
if edge[s]:
dp[s-1]=max((longest_path(t)+1)for t in edge[s])
else:
dp[s-1]=0
return dp[s-1]
N,M=list(map(int,input().split()))
edge={}
for i in range(1,N+1):
edge.setdefault(i,[])
for _ in range(M):
x,y=list(map(int,input().split()))
edge[x].append(y)
dp=[0]*N
for i in range(1,N+1):
if dp[i-1]==0:
longest_path(i)
print((max(dp))) | p03166 |
import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
from functools import lru_cache
def main():
N, M = LI()
es = [[x for x in LI()] for _ in range(M)]
from collections import defaultdict
outs = defaultdict(list) # ノードが int なら、[[] for _ in range(n+1)] でもよさそう。
# ins = defaultdict(int) # ノードが int なら、 [0 for _ in range(n+1)] でもよさそう。
for from_v, to_v in es:
outs[from_v].append(to_v)
# ins[to_v] += 1
@lru_cache()
def max_len(v):
if not outs[v]:
return 0
else:
return max([max_len(x)+1 for x in outs[v]])
print((max([max_len(x) for x in range(1,N+1)])))
main() | import sys
sys.setrecursionlimit(10**7)
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 II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7
# from functools import lru_cache
def main():
N, M = LI()
es = [[x for x in LI()] for _ in range(M)]
from collections import defaultdict
outs = defaultdict(list) # ノードが int なら、[[] for _ in range(n+1)] でもよさそう。
# ins = defaultdict(int) # ノードが int なら、 [0 for _ in range(n+1)] でもよさそう。
for from_v, to_v in es:
outs[from_v].append(to_v)
# ins[to_v] += 1
# @lru_cache()
memo = [None for _ in range(N+1)]
def max_len(v):
if memo[v] is not None:
return memo[v]
if not outs[v]:
memo[v] = 0
return 0
else:
memo[v] = max([max_len(x)+1 for x in outs[v]])
return memo[v]
print((max([max_len(x) for x in range(1,N+1)])))
main() | p03166 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N, M = list(map(int, input().split()))
g = [[] for _ in range(N)] #場合によって変える
for _ in range(M):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
dp = [0]*N
def func(i):
for j in g[i]:
dp[j] = max(dp[j], dp[i]+1)
func(j)
for i in range(N):
if dp[i]==0:
func(i)
print((max(dp)))
if __name__ == '__main__':
main() | #トポロジカルソートなるもの
#再帰で書いてるところをwhileで書いてる
#要は無駄な探索(再帰呼び出し)を無くしてる
#まぁ思いつかない
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
n,m = list(map(int,input().split()))
edge = [[] for i in range(n)]
#st:入る辺が無い頂点
st = []
#to[i]:頂点iに入る辺数
to = [0]*n
for i in range(m):
x,y = list(map(int, input().split()))
edge[x-1].append(y-1)
to[y-1] += 1
for i in range(n):
if to[i] == 0:
st.append(i)
#dp[i]:頂点iを終点とする最長のパスの長さ
dp = [0]*n
while st:
go = st.pop()
for e in edge[go]:
to[e] -= 1
if to[e] == 0:
st.append(e)
dp[e] = max(dp[e],dp[go]+1)
print((max(dp)))
if __name__ == '__main__':
main() | p03166 |
from collections import deque
def main():
n, adj = getInputs()
# maxDistance[start]
maxDistance = [0] * n
overallMaxDistance = 0
calculated = [0] * n
for v in range(n):
# distance[dest] (starting at v)
distance = [0] * n
currMaxDistance = 0
toVisit = deque([v])
while len(toVisit) > 0:
curr = toVisit.popleft()
for dest in adj[curr]:
if calculated[dest] == 1:
newDistance = distance[curr] + maxDistance[dest] + 1
if newDistance > distance[dest]:
distance[dest] = newDistance
if distance[dest] > currMaxDistance:
currMaxDistance = distance[dest]
else:
if distance[curr] + 1 > distance[dest]:
distance[dest] = distance[curr] + 1
if distance[dest] > currMaxDistance:
currMaxDistance = distance[dest]
toVisit.append(dest)
maxDistance[v] = currMaxDistance
if currMaxDistance > overallMaxDistance:
overallMaxDistance = currMaxDistance
calculated[v] = 1
print(overallMaxDistance)
def getInputs():
n, m = [int(x) for x in input().split()]
adj = []
for i in range(n):
adj.append([])
for i in range(m):
a, b = [int(x) for x in input().split()]
adj[a - 1].append(b - 1)
return n, adj
main()
| def main():
n, adj = getInputs()
sequence = getTopologicalSort(n, adj)
distance = [-1] * n
longest = -1
for v in sequence:
if len(adj[v]) == 0:
distance[v] = 0
else:
for dest in adj[v]:
distance[v] = max(distance[v], 1 + distance[dest])
longest = max(longest, distance[v])
print(longest)
def getTopologicalSort(n, adj):
state = [0] * n
toVisit = list(range(n))
topologicalSort = []
order = []
while len(toVisit) > 0:
curr = toVisit.pop()
if state[curr] == 0:
order.append(curr)
state[curr] = 1
foundNewDest = False
for dest in adj[curr]:
if state[dest] == 0:
toVisit.append(dest)
foundNewDest = True
if not foundNewDest:
while True:
v = order[-1]
allProcessed = True
for dest in adj[v]:
if state[dest] == 0:
allProcessed = False
break
if allProcessed:
state[v] = 2
topologicalSort.append(order.pop())
if len(order) == 0 or not allProcessed:
break
return topologicalSort
def getInputs():
n, m = [int(x) for x in input().split()]
adj = []
for i in range(n):
adj.append([])
for i in range(m):
a, b = [int(x) for x in input().split()]
adj[a - 1].append(b - 1)
return n, adj
main()
| p03166 |
# coding: utf-8
# Your code here!
from functools import lru_cache
import sys
sys.setrecursionlimit(10**6)
n,m = [int(i) for i in input().split()]
#ko = [[] for _ in range(n)]
oya = [[] for _ in range(n)]
for _ in range(m):
x,y = [int(i)-1 for i in input().split()]
# ko[x].append(y)
oya[y].append(x)
#memo = [-1]*n
@lru_cache(maxsize=None)
def longest(v): #nを終点とするlongest
# if memo[v] >= 0:
# return memo[v]
# else:
c=0
for j in oya[v]:
c = max(c,longest(j)+1)
# memo[v] = c
return c
memo = [longest(i) for i in range(n)]
print((max(memo)))
#print(memo)
| # coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
n,m = [int(i) for i in input().split()]
#ko = [[] for _ in range(n)]
oya = [[] for _ in range(n)]
for _ in range(m):
x,y = [int(i)-1 for i in input().split()]
# ko[x].append(y)
oya[y].append(x)
memo = [-1]*n
def longest(v): #nを終点とするlongest
if memo[v] >= 0:
return memo[v]
else:
c=0
for j in oya[v]:
c = max(c,longest(j)+1)
memo[v] = c
return c
for i in range(n):
longest(i)
print((max(memo)))
#print(memo)
| p03166 |
import collections
N,M = list(map(int,input().split()))
L = [[False for j in range(N)] for i in range(N)]
for i in range(M) :
a,b = list(map(int,input().split()))
a -= 1
b -= 1
L[a][b] = True
dp = [0 for i in range(N)]
for i in range(N) :
q = collections.deque()
q.append(i)
dist = [0 for i in range(N)]
while q :
now = q.pop()
for j in range(N) :
if not L[now][j] :
continue
dist[j] = max(dist[j], dist[now]+1)
if j < i :
dp[i] = max(dp[i], dist[j] + dp[j])
else :
q.append(j)
dp[i] = max(dp[i], max(dist))
ans = max(dp)
print(ans)
| N,M = list(map(int,input().split()))
L = [list(map(int,input().split())) for i in range(M)]
L_minus = [[] for i in range(N)]
L_plus = [0 for i in range(N)]
dp = [0 for i in range(N)]
for i in range(M) :
x,y = L[i]
x -= 1
y -= 1
L_plus[y] += 1
L_minus[x].append(y)
A = []
for i in range(N) :
if L_plus[i] == 0 :
A.append(i)
while A :
x = A.pop()
for y in L_minus[x] :
L_plus[y] -= 1
if L_plus[y] == 0 :
A.append(y)
dp[y] = max(dp[y], dp[x]+1)
ans = max(dp)
print(ans)
| p03166 |
from collections import deque
n,m = list(map(int,input().split()))
g = [[] for i in range(n)]
h = [[] for i in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
x-=1;y-=1
g[x].append(y)
h[y].append(x)
hukasa = [0]*n
MIN = float("inf")
for i in range(n):
MIN = min(MIN,len(h[i]))
def dfs(x,y):
for k in g[x]:
if hukasa[k] < y+1:
que.append([k,y+1])
for i in range(n):
if MIN == len(h[i]):
que = deque([])
que.append([i,0])
while que:
x,y = que.popleft()
hukasa[x] = y
dfs(x,y)
for i in range(n):
hukasa[i] = [hukasa[i],i]
hukasa.sort()
dp = [0] * n
for l,i in hukasa:
for j in g[i]:
if dp[j] < dp[i]+1:
dp[j] = dp[i]+1
print((max(dp))) | import heapq
from collections import deque
n,m = list(map(int,input().split()))
g = [[] for i in range(n)]
h = [[] for i in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
x-=1;y-=1
g[x].append(y)
h[y].append(x)
hukasa = [0]*n
MIN = float("inf")
for i in range(n):
MIN = min(MIN,len(h[i]))
def dfs(x,y):
for k in g[x]:
if hukasa[k] < y+1:
heapq.heappush(que,[-(y+1),k])
for i in range(n):
if MIN == len(h[i]):
que = [[0,i]]
heapq.heapify(que)
while que:
y,x = heapq.heappop(que)
if hukasa[x] < -y:
hukasa[x] = -y
dfs(x,-y)
print((max(hukasa))) | p03166 |
import heapq
from collections import deque
n,m = list(map(int,input().split()))
g = [[] for i in range(n)]
h = [[] for i in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
x-=1;y-=1
g[x].append(y)
h[y].append(x)
hukasa = [0]*n
MIN = float("inf")
for i in range(n):
MIN = min(MIN,len(h[i]))
def dfs(x,y):
for k in g[x]:
if hukasa[k] < y+1:
heapq.heappush(que,[-(y+1),k])
for i in range(n):
if MIN == len(h[i]):
que = [[0,i]]
heapq.heapify(que)
while que:
y,x = heapq.heappop(que)
if hukasa[x] < -y:
hukasa[x] = -y
dfs(x,-y)
print((max(hukasa))) | from collections import deque
n,m = list(map(int,input().split()))
g = [[] for i in range(n)]
h = [[] for i in range(n)]
for i in range(m):
x,y = list(map(int,input().split()))
x-=1;y-=1
g[x].append(y)
h[y].append(x)
topo = []
hukasa = [0] * n
hairu = [0]*n
que = deque([])
for i in range(n):
hairu[i] = len(h[i])
if hairu[i] == 0:
topo.append(i)
que.append(i)
def dfs(x):
for i in g[x]:
hairu[i]-=1
if hairu[i] == 0:
topo.append(i)
que.append(i)
while que:
x = que.popleft()
dfs(x)
def dfs2(x):
for i in g[x]:
hukasa[i] = max(hukasa[i],hukasa[x]+1)
for i in topo:
dfs2(i)
print((max(hukasa)))
| p03166 |
import sys
from collections import deque
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def naa(N): return [na() for _ in range(N)]
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
N, M = na()
node_dic = {}
no_in = [1] * N
for _ in range(M):
x, y = na()
if x-1 in node_dic:
node_dic[x-1].append(y-1)
else:
node_dic[x-1] = [y-1]
no_in[y-1] = 0
# print(node_dic, no_in)
ans_array = [0] * N
edge = deque([])
for i, x in enumerate(no_in):
if x == 1:
deque.append(edge, i)
while(len(edge)):
e = deque.popleft(edge)
if e in node_dic:
for x in node_dic[e]:
deque.append(edge, x)
ans_array[x] = max(ans_array[x], ans_array[e] + 1)
# print(ans_array)
print((max(ans_array))) | import sys
from collections import deque
sys.setrecursionlimit(10**8)
stdin = sys.stdin
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))
def naa(N): return [na() for _ in range(N)]
def ns(): return stdin.readline().rstrip() # ignore trailing spaces
def cal(e):
if ans_array[e] != -1:
return ans_array[e]
ans = 0
if e in node_dic:
for x in node_dic[e]:
ans = max(ans, cal(x) + 1)
ans_array[e] = ans
return ans
N, M = na()
node_dic = {}
no_in = [1] * N
for _ in range(M):
x, y = na()
if x-1 in node_dic:
node_dic[x-1].append(y-1)
else:
node_dic[x-1] = [y-1]
no_in[y-1] = 0
# print(node_dic, no_in)
ans_array = [-1] * N
edge = deque([])
for i, x in enumerate(no_in):
if x == 1:
cal(i)
print((max(ans_array)))
| p03166 |
int1 = lambda x: int(x) - 1
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
N, M = list(map(int, input().split()))
start_point = set(range(N))
to_point = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int1, input().split()))
start_point = start_point - {y}
to_point[x].append(y)
dp_memo = [-1]*N
for x in range(N):
if len(to_point[x]) == 0:
dp_memo[x] = 0
# 点i始点のLongest Pathの長さ
def dp(i):
if dp_memo[i] >= 0:
return dp_memo[i]
lp = 0
for j in to_point[i]:
lp = max(lp, dp(j)+1)
dp_memo[i] = lp
return lp
for i in range(N):
dp(i)
print((max(dp_memo))) | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
int1 = lambda x: int(x) - 1
N, M = list(map(int, input().split()))
to_point = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int1, input().split()))
to_point[x].append(y)
dp_memo = [-1]*N
for x in range(N):
if len(to_point[x]) == 0:
dp_memo[x] = 0
# 点i始点のLongest Pathの長さ
def dp(i):
if dp_memo[i] >= 0:
return dp_memo[i]
lp = 0
for j in to_point[i]:
lp = max(lp, dp(j)+1)
dp_memo[i] = lp
return lp
for i in range(N):
dp(i)
print((max(dp_memo))) | p03166 |
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
int1 = lambda x: int(x) - 1
N, M = list(map(int, input().split()))
to_point = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int1, input().split()))
to_point[x].append(y)
dp_memo = [-1]*N
for x in range(N):
if len(to_point[x]) == 0:
dp_memo[x] = 0
# 点i始点のLongest Pathの長さ
def dp(i):
if dp_memo[i] >= 0:
return dp_memo[i]
lp = 0
for j in to_point[i]:
lp = max(lp, dp(j)+1)
dp_memo[i] = lp
return lp
for i in range(N):
dp(i)
print((max(dp_memo))) | import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(1000000000)
int1 = lambda x: int(x) - 1
N, M = list(map(int, input().split()))
not_start_point = set()
to_point = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int1, input().split()))
not_start_point.add(y)
to_point[x].append(y)
start_point = set(range(N)) - not_start_point
dp_memo = [-1]*N
for x in range(N):
if len(to_point[x]) == 0:
dp_memo[x] = 0
# 点i始点のLongest Pathの長さ
def dp(i):
if dp_memo[i] >= 0:
return dp_memo[i]
lp = 0
for j in to_point[i]:
lp = max(lp, dp(j)+1)
dp_memo[i] = lp
return lp
ans = 0
for s in start_point:
ans = max(ans, dp(s))
print(ans) | p03166 |
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
####################################################
import threading
sys.setrecursionlimit(10**5)
threading.stack_size(10**8)
def dfs(x):
global l,adj,v
v[x]=1
for i in adj[x]:
l[i]=max(l[i],l[x]+1)
dfs(i)
def main():
global l,adj,v
n,m=list(map(int,input().split()))
l=[0]*(n+1)
v=[0]*(n+1)
adj=[]
for i in range(n+1):
adj.append([])
for i in range(m):
x,y=list(map(int,input().split()))
adj[x].append(y)
for i in range(1,n+1):
if not v[i]:
dfs(i)
print((max(l)))
t=threading.Thread(target=main)
t.start()
t.join()
| import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
import threading
sys.setrecursionlimit(10**5)
threading.stack_size(10**8)
def dfs(x):
global l,adj,v
if v[x]==1:
return(l[x])
v[x]=1
c=0
for i in adj[x]:
c=max(c,dfs(i)+1)
l[x]=c
return c
def main():
global l,adj,v
n,m=list(map(int,input().split()))
l=[0]*(n+1)
v=[0]*(n+1)
adj=[]
for i in range(n+1):
adj.append([])
for i in range(m):
x,y=list(map(int,input().split()))
adj[x].append(y)
ans=0
for i in range(1,n+1):
if not v[i]:
ans=max(ans,dfs(i))
print(ans)
t=threading.Thread(target=main)
t.start()
t.join()
| p03166 |
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 7)
def input():
return sys.stdin.readline().strip()
def dfs(v):
if dp[v] >= 0:
return dp[v]
res = 0
for nv in g[v]:
res = max(res, dfs(nv) + 1)
dp[v] = res
return res
n, m = list(map(int, input().split()))
g = {i: set() for i in range(n)}
for _ in range(m):
x, y = list(map(int, input().split()))
g[x - 1].add(y - 1)
dp = defaultdict(lambda: -1)
for v in g:
dp[v] = max(dp[v], dfs(v))
print((max(dp.values())))
| import sys
sys.setrecursionlimit(10 ** 7)
def input():
return sys.stdin.readline().strip()
def dfs(v):
if dp[v] >= 0:
return dp[v]
res = 0
for nv in g[v]:
res = max(res, dfs(nv) + 1)
dp[v] = res
return res
n, m = list(map(int, input().split()))
g = [[] for i in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
g[x - 1].append(y - 1)
dp = [-1] * n
for v in range(n):
dp[v] = max(dp[v], dfs(v))
print((max(dp)))
| p03166 |
import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for i in range(m)]
graph = [[] for i in range(n+1)]
path = [0 for i in range(n+1)]
for a,b in ab:
graph[b].append(a)
path[a] = -1
stack = []
for i in range(1,n+1):
if path[i] == 0:
stack.append(i)
while stack:
x = stack.pop()
for y in graph[x]:
if path[x]+1 > path[y]:
stack.append(y)
path[y] = path[x]+1
print((max(path))) | import sys
input = sys.stdin.readline
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for i in range(m)]
graph = [[] for i in range(n+1)]
path = [0 for i in range(n+1)]
con = [0 for i in range(n+1)]
for a,b in ab:
graph[b].append(a)
path[a] = -1
con[a] += 1
stack = []
for i in range(1,n+1):
if path[i] == 0:
stack.append(i)
while stack:
x = stack.pop()
for y in graph[x]:
path[y] = max(path[y],path[x]+1)
con[y] -= 1
if con[y] == 0:
stack.append(y)
print((max(path))) | p03166 |
from collections import deque
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
indeg = [0 for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
indeg[y-1] += 1
q = deque([])
dp = [-1 for _ in range(n)]
for i in range(n):
if indeg[i] == 0:
q.append(i)
dp[i] = 0
while q:
v = q.popleft()
for w in g[v]:
if dp[w] < dp[v]+1:
dp[w] = dp[v]+1
q.append(w)
print((max(dp)))
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
indeg = [0 for _ in range(n)]
for _ in range(m):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
indeg[y-1] += 1
dp = [-1 for _ in range(n)]
def LP(v):
if dp[v] != -1:
return dp[v]
ans = 0
for w in g[v]:
ans = max(ans, LP(w)+1)
dp[v] = ans
return dp[v]
for i in range(n):
LP(i)
print((max(dp)))
| p03166 |
import sys
sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
to[x - 1].append(y - 1)
count = 0
def dfs(v, seen, temp=0):
global count
seen[v] = 1
if to[v]:
for nv in to[v]:
dfs(nv, seen, temp + 1)
else:
count = max(count, temp)
def main():
ans = 0
seen = [0] * N
for i in range(N):
if not seen[i]:
dfs(i, seen)
ans = max(ans, count)
print(ans)
if __name__ == "__main__":
main() | import sys
sys.setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(M):
x, y = list(map(int, input().split()))
to[x - 1].append(y - 1)
# dp[i] : iを始点とする最長経路
dp = [0] * N
seen = [0] * N
def dfs(v):
if seen[v]:
return dp[v]
seen[v] = 1
res = 0
for nv in to[v]:
res = max(res, dfs(nv) + 1)
dp[v] = res
return res
def main():
ans = 0
for i in range(N):
ans = max(ans, dfs(i))
print(ans)
if __name__ == "__main__":
main() | p03166 |
import sys
sys.setrecursionlimit(10**6)
def dfs(v):
seen[v]=1
for nv in G[v]:
if seen[nv]:
continue
dfs(nv)
topo.append(v)
N,M=list(map(int,input().split()))
G=[[] for i in range(N)]
for i in range(M):
x,y=[int(x)-1 for x in input().split()]
G[x].append(y)
seen=[0]*N
topo=[]
for i in range(N):
if not seen[i]:
dfs(i)
dp=[0]*N
for v in reversed(topo):
for nv in G[v]:
dp[nv]=max(dp[nv],dp[v]+1)
print((max(dp))) | import sys
sys.setrecursionlimit(10**6)
def dfs(v):
if(dp[v]==-1):
dp[v]=0
for nv in G[v]:
dp[v]=max(dp[v],dfs(nv)+1)
return dp[v]
N,M=list(map(int,input().split()))
G=[[] for i in range(N)]
for i in range(M):
x,y=[int(x)-1 for x in input().split()]
G[x].append(y)
dp=[-1]*N
res=-1
for v in range(N):
res=max(res,dfs(v))
print(res) | p03166 |
n, m = list(map(int, input().split()))
path = {}
ans = []
for i in range(m):
x, y = list(map(int, input().split()))
if not x in list(path.keys()):
path[x] = []
path[x].append(y)
def get_next_node(current):
next_node = []
for c in current:
if not c in list(path.keys()):
continue
next_node += path[c]
return next_node
for j in range(1, n+1):
count = 0
if not j in list(path.keys()):
continue
next_node = path[j]
while len(next_node) != 0:
next_node = get_next_node(next_node)
count += 1
ans.append(count)
print((max(ans))) | n, m = list(map(int, input().split()))
path = {}
ans = []
for i in range(m):
x, y = list(map(int, input().split()))
if not x in list(path.keys()):
path[x] = []
path[x].append(y)
def get_next_node(current):
next_node = []
for c in current:
if not c in list(path.keys()):
continue
next_node += path[c]
return list(set(next_node))
for j in range(1, n+1):
count = 0
if not j in list(path.keys()):
continue
next_node = path[j]
while len(next_node) != 0:
next_node = get_next_node(next_node)
count += 1
ans.append(count)
print((max(ans))) | p03166 |
import sys
sys.setrecursionlimit(10**6)
edges, vertices = list(map(int, input().split()))
dp = [None for _ in range(edges)]
nodes = [[] for _ in range(edges)]
for i in range(vertices):
start, end = list(map(int, input().split()))
nodes[end -1].append(start-1)
def find(arr):
if not len(arr):
return 0
for x in arr:
if dp[x] is None:
dp[x] = find(nodes[x])
return 1 + max(dp[x] for x in arr)
for i in range(edges):
dp[i] = find(nodes[i])
print((max(dp)))
| import sys
sys.setrecursionlimit(10**6)
edges, vertices = list(map(int, input().split()))
dp = [None for _ in range(edges)]
nodes = [[] for _ in range(edges)]
for i in range(vertices):
start, end = list(map(int, input().split()))
nodes[end -1].append(start-1)
for i in range(edges):
if not len(nodes[i]):
dp[i] = 0
def find(arr):
if not len(arr):
return 0
for x in arr:
if dp[x] is None:
dp[x] = find(nodes[x])
return 1 + max(dp[x] for x in arr)
for i in range(edges):
dp[i] = find(nodes[i])
print((max(dp)))
| p03166 |
from sys import stdin
import math
import fractions
from collections import deque
import sys
# 再起の上限を変更
sys.setrecursionlimit(100000)
INF = 10 ** 10
# 深さ優先探索
def dfs(i):
global is_visited
global tsort_res
if is_visited[i]:
return
is_visited[i] = True
for j in nextl[i]:
dfs(j)
# 帰りがけ順で追加
# 追加は先頭に行う
tsort_res.insert(0, i)
# トポロジカルソート
def tsort():
for i in range(1, N+1):
dfs(i)
if __name__ == "__main__":
N, M = [int(x) for x in stdin.readline().rstrip().split()]
xv = [list(map(int, stdin.readline().rstrip().split())) for _ in range(M)]
# トポロジカルソートで頂点iより後ろのパスの最大長
dp = [0] * (N+1)
# 頂点xから頂点vへの有向辺
nextl = [[] for _ in range(N+1)]
for x, v in xv:
nextl[x].append(v)
# トポロジカルソートされた結果の入るリスト
tsort_res = []
is_visited = [False] * (N+1)
tsort()
# 今回は逆順に使うのでリバースする
# 汎用性のため、dfsでは先頭に追加するようにしている
tsort_res = tsort_res[::-1]
for x in tsort_res:
for v in nextl[x]:
dp[x] = max(dp[x], dp[v] + 1)
# for DEBUG
#print(dp)
print((max(dp))) | from sys import stdin
import math
import fractions
from collections import deque
import sys
# 再起の上限を変更
sys.setrecursionlimit(100000)
INF = 10 ** 10
# 深さ優先探索
def dfs(i):
global is_visited
global tsort_res
if is_visited[i]:
return
is_visited[i] = True
for j in nextl[i]:
dfs(j)
# 帰りがけ順で追加
# 追加は先頭に行う
tsort_res.appendleft(i)
# トポロジカルソート
def tsort():
for i in range(1, N+1):
dfs(i)
if __name__ == "__main__":
N, M = [int(x) for x in stdin.readline().rstrip().split()]
# トポロジカルソートで頂点iより後ろのパスの最大長
dp = [0] * (N+1)
# 頂点xから頂点vへの有向辺
nextl = [[] for _ in range(N+1)]
for _ in range(M):
x, v = list(map(int, stdin.readline().rstrip().split()))
nextl[x].append(v)
# トポロジカルソートされた結果の入るリスト
tsort_res = deque([])
is_visited = [False] * (N+1)
tsort()
# 今回は逆順に使うのでリバースする
# 汎用性のため、dfsでは先頭に追加するようにしている
tsort_res = list(tsort_res)[::-1]
for x in tsort_res:
for v in nextl[x]:
dp[x] = max(dp[x], dp[v] + 1)
# for DEBUG
#print(dp)
print((max(dp))) | p03166 |
from sys import stdin
import math
import fractions
from collections import deque
import sys
# 再起の上限を変更
sys.setrecursionlimit(100000)
INF = 10 ** 10
# 深さ優先探索
def dfs(i):
global is_visited
global tsort_res
if is_visited[i]:
return
is_visited[i] = True
for j in nextl[i]:
dfs(j)
# 帰りがけ順で追加
# 追加は先頭に行う
tsort_res.appendleft(i)
# トポロジカルソート
def tsort():
for i in range(1, N+1):
dfs(i)
if __name__ == "__main__":
N, M = [int(x) for x in stdin.readline().rstrip().split()]
# トポロジカルソートで頂点iより後ろのパスの最大長
dp = [0] * (N+1)
# 頂点xから頂点vへの有向辺
nextl = [[] for _ in range(N+1)]
for _ in range(M):
x, v = list(map(int, stdin.readline().rstrip().split()))
nextl[x].append(v)
# トポロジカルソートされた結果の入るリスト
tsort_res = deque([])
is_visited = [False] * (N+1)
tsort()
# 今回は逆順に使うのでリバースする
# 汎用性のため、dfsでは先頭に追加するようにしている
tsort_res = list(tsort_res)[::-1]
for x in tsort_res:
for v in nextl[x]:
dp[x] = max(dp[x], dp[v] + 1)
# for DEBUG
#print(dp)
print((max(dp))) | from sys import stdin
import math
import fractions
from collections import deque
import sys
# 再起の上限を変更
sys.setrecursionlimit(100000)
INF = 10 ** 10
# 深さ優先探索
def dfs(i):
global is_visited
global tsort_res
if is_visited[i]:
return
is_visited[i] = True
for j in nextl[i]:
dfs(j)
# 帰りがけ順で追加
# 追加は先頭に行う
tsort_res.appendleft(i)
# トポロジカルソート
def tsort():
for i in range(1, N+1):
dfs(i)
if __name__ == "__main__":
N, M = [int(x) for x in stdin.readline().rstrip().split()]
# トポロジカルソートで頂点iより後ろのパスの最大長
dp = [0] * (N+1)
# 頂点xから頂点vへの有向辺
nextl = [[] for _ in range(N+1)]
for _ in range(M):
x, v = list(map(int, stdin.readline().rstrip().split()))
nextl[x].append(v)
# トポロジカルソートされた結果の入るリスト
tsort_res = deque([])
is_visited = [False] * (N+1)
# トポロジカルソートの実行
tsort()
# 今回は逆順に使うのでリバースする
# つまり、トポロジカルオーダーの最後の番号に該当する頂点から処理を行う
# 汎用性のため、dfsでは先頭に追加するようにしている
#tsort_res = list(tsort_res)[::-1]
"""
for x in tsort_res:
for v in nextl[x]:
dp[x] = max(dp[x], dp[v] + 1)
"""
for x in tsort_res:
for v in nextl[x]:
dp[v] = max(dp[v], dp[x] + 1)
# for DEBUG
#print(dp)
print((max(dp))) | p03166 |
import heapq
INF=float('inf')
n,m=list(map(int,input().split()))
adj=[[] for _ in range(n)]
for _ in range(m):
x,y=list(map(int,input().split()))
x-=1
y-=1
adj[x].append(y)
ans=-INF
for i in range(n):
dist=[-INF for _ in range(n)]
Q=[(0,i)]
dist[i]=0
heapq.heapify(Q)
while Q:
d,v=heapq.heappop(Q)
for nv in adj[v]:
if dist[nv]<dist[v]+1:
dist[nv]=dist[v]+1
heapq.heappush(Q,(dist[nv],nv))
ans=max(ans,max(dist))
print(ans) | import sys
sys.setrecursionlimit(10**9)
INF=float('inf')
n,m=list(map(int,input().split()))
adj=[[] for _ in range(n+1)]
for _ in range(m):
x,y=list(map(int,input().split()))
adj[x].append(y)
dp=[-1 for _ in range(n+1)]
def f(k):
if dp[k]!=-1:
return dp[k]
dp[k]=0
if adj[k]:
for v in adj[k]:
dp[k]=max(dp[k],f(v)+1)
return dp[k]
ans=-INF
for i in range(1,n+1):
ans=max(ans,f(i))
print(ans) | p03166 |
import sys
input = sys.stdin.readline
N,M = list(map(int,input().split()))
matrix = [[0]*N for i in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1; y -= 1
matrix[x][y] = 1
dp = [-1]*N
def rec(nodes):
if dp[nodes] != -1:
return dp[nodes]
res = 0
for ne,bit in enumerate(matrix[nodes]):
if bit == 0:continue
option = rec(ne)+1
if res < option:
res = option
dp[nodes] = res
return dp[nodes]
ans = 0
for i in range(N):
res = rec(i)
if ans < res:
ans = res
print(ans) | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,M = list(map(int,input().split()))
ad = [[] for i in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1; y -= 1
ad[x].append(y)
dp = [-1]*N
def rec(nodes):
if dp[nodes] != -1:
return dp[nodes]
res = 0
for ne in ad[nodes]:
option = rec(ne)+1
if res < option:
res = option
dp[nodes] = res
return dp[nodes]
ans = 0
for i in range(N):
res = rec(i)
if ans < res:
ans = res
print(ans) | p03166 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,M = list(map(int,input().split()))
ad = [[] for i in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1; y -= 1
ad[x].append(y)
dp = [-1]*N
def rec(nodes):
if dp[nodes] != -1:
return dp[nodes]
res = 0
for ne in ad[nodes]:
option = rec(ne)+1
if res < option:
res = option
dp[nodes] = res
return dp[nodes]
ans = 0
for i in range(N):
res = rec(i)
if ans < res:
ans = res
print(ans) | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N,M = list(map(int,input().split()))
ad = [[] for i in range(N)]
for _ in range(M):
x,y = list(map(int,input().split()))
x -= 1; y -= 1
ad[x].append(y)
dp = [-1]*N
def rec(nodes):
if dp[nodes] != -1:
return dp[nodes]
res = 0
for ne in ad[nodes]:
option = rec(ne)+1
if res < option:
res = option
dp[nodes] = res
return dp[nodes]
ans = 0
for i in range(N):
res = rec(i)
if ans < res:
ans = res
print(ans)
main() | p03166 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, readline().split()))
outdeg = {i: [] for i in range(N)}
for _ in range(M):
a, b = list(map(int, readline().split()))
a -= 1
b -= 1
outdeg[a].append(b)
dp = [-1] * (N)
def rec(s):
if dp[s] != -1:
return dp[s]
res = 0
for t in outdeg[s]:
res = max(res, rec(t)+1)
dp[s] = res
return res
ans = 0
for s in range(N):
ans = max(ans, rec(s))
print(ans)
| import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for _ in range(M):
s, t = list(map(int, input().split()))
s -= 1
t -= 1
edge[s].append(t)
dp = [-1]*N
def dfs(s):
if dp[s] != -1:
return dp[s]
if len(edge[s]) == 0:
dp[s] = 0
return 0
res = 0
for t in edge[s]:
res = max(res, dfs(t)+1)
dp[s] = res
return res
for i in range(N):
dfs(i)
print((max(dp)))
| p03166 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.