input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n, m = map(int, input().split())
s = input()
s = s[::-1]
if s[0] == "1":
print(-1)
exit()
pre = [-1] * (n + 1)
stack = [0]
while stack:
now = stack.pop()
if now == n:
break
for i in range(1, m + 1):
tsugi = now + i
if tsugi > n:
continue
if s[tsugi] == "1":
continue
pre[tsugi] = now
stack.append(tsugi)
else:
print(-1)
exit()
ato = n
mae = pre[n]
ans = []
while mae >= 0:
ans.append(ato - mae)
ato = mae
mae = pre[ato]
print(*ans, sep=" ")
| n, m = map(int, input().split())
s = input()
out_s='1'*(m)
if out_s in s:
print(-1)
exit()
s = s[::-1]
if s[0] == "1":
print(-1)
exit()
pre = [-1] * (n + 1)
stack = [0]
while stack:
now = stack.pop()
if now == n:
break
for i in range(1, m + 1):
tsugi = now + i
if tsugi > n:
continue
if s[tsugi] == "1":
continue
pre[tsugi] = now
stack.append(tsugi)
else:
print(-1)
exit()
ato = n
mae = pre[n]
ans = []
while mae >= 0:
ans.append(ato - mae)
ato = mae
mae = pre[ato]
print(*ans, sep=" ")
| p02852 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
if S[-1] == 's':
S += ['e','s']
else:
S += ['s']
print((''.join(S)))
| import sys
def S(): return sys.stdin.readline().rstrip()
S = S()
print((S+'es' if S[-1] == 's' else S+'s'))
| p02546 |
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
s = iss()
print((s + 'es' if s[-1] == 's' else s + 's'))
if __name__ == '__main__':
main()
| import sys
import os
import math
import bisect
import itertools
import collections
import heapq
import queue
import array
# 時々使う
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
# 再帰の制限設定
sys.setrecursionlimit(10000000)
def ii(): return int(sys.stdin.buffer.readline().rstrip())
def il(): return list(map(int, sys.stdin.buffer.readline().split()))
def fl(): return list(map(float, sys.stdin.buffer.readline().split()))
def iln(n): return [int(sys.stdin.buffer.readline().rstrip())
for _ in range(n)]
def iss(): return sys.stdin.buffer.readline().decode().rstrip()
def sl(): return list(map(str, sys.stdin.buffer.readline().decode().split()))
def isn(n): return [sys.stdin.buffer.readline().decode().rstrip()
for _ in range(n)]
def lcm(x, y): return (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
INF = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = iss()
if S[-1] == 's':
print((S + 'es'))
else:
print((S + 's'))
if __name__ == '__main__':
main()
| p02546 |
temp = list(input().split())
print(((temp[0][0]+temp[1][0]+temp[2][0]).upper())) | a, b, c = input().split()
print(((a[0]+b[0]+c[0]).upper())) | p03737 |
s = list(input().split())
print(((s[0][0] + s[1][0] + s[2][0]).upper())) | s = list(input().split())
#print((s[0][0] + s[1][0] + s[2][0]).upper())
print((''.join([x[0].upper() for x in s])))
| p03737 |
a,b,c=input().split()
print((a[0].upper()+b[0].upper()+c[0].upper())) | a,b,c=input().split()
print(((a[0]+b[0]+c[0]).upper())) | p03737 |
a,b,c = input().split()
ans = a[0]+b[0]+c[0]
print((ans.upper())) | a,b,c = input().split()
print(((a[0] + b[0] + c[0]).upper()))
| p03737 |
s1,s2,s3=list(map(str,input().upper().split())) #文字列
print((s1[0]+s2[0]+s3[0])) | s1,s2,s3=input().upper().split() #文字列
print((s1[0]+s2[0]+s3[0])) | p03737 |
s1,s2,s3 = input().split()
print(((s1[0]+s2[0]+s3[0]).upper())) | a,b,c=input().upper().split();print((a[0]+b[0]+c[0])) | p03737 |
s1,s2,s3 = list(map(str,input().split()))
s = s1[0] + s2[0] + s3[0]
s = s.upper()
print(s) | a,b,c = input().split()
print(((a[0]+b[0]+c[0]).upper())) | p03737 |
s1,s2,s3 = input().strip().split()
print((s1[0].upper()+s2[0].upper()+s3[0].upper())) | s1,s2,s3 = input().split()
s1 = s1.upper()
s2 = s2.upper()
s3 = s3.upper()
print((s1[0]+s2[0]+s3[0])) | p03737 |
a,b,c=input().upper().split();print((''.join([a[0],b[0],c[0]]))) | a,*_=zip(*input().upper().split());print(*a,sep='')
| p03737 |
a,b,c = list(map(str,input().split()))
A = list(a)[0].upper()
B = list(b)[0].upper()
C = list(c)[0].upper()
print((A+B+C))
| s = input().split()
for i in range(3):
print(s[i][0].upper(), end = "")
print()
| p03737 |
s = input().split()
print(''.join([w[0] for w in s]).upper())
| print(''.join([w[0] for w in input().split()]).upper()) | p03737 |
def main():
S_1 , S_2 , S_3 = list(map(str, input().split(' ')))
print((S_1[0].upper() + S_2[0].upper() + S_3[0].upper()))
if __name__ == '__main__':
main()
|
if __name__ == "__main__":
S = input().split()
print(((S[0][0] + S[1][0] + S[2][0]).upper()))
| p03737 |
import bisect
INF = 10 ** 10
N = int(input())
As = list(map(int, input().split()))
edges = [tuple(map(int, input().split())) for _ in range(N-1)]
dfs_stack = [1]
ans = [-1] * N
lis = [INF] * (N+1)
rewinder = []
while dfs_stack:
pos = dfs_stack.pop()
for u, v in edges:
if u == pos:
if ans[v-1] == -1:
dfs_stack.append(v)
else:
parent = v
elif v == pos:
if ans[u-1] == -1:
dfs_stack.append(u)
else:
parent = u
while rewinder:
i, before, after = rewinder.pop()
if after == As[parent-1]:
rewinder.append( (i, before, after) )
break
else:
lis[i] = before
index = bisect.bisect_left(lis, As[pos-1])
rewinder.append( (index, lis[index], As[pos-1]) )
lis[index] = As[pos-1]
ans[pos-1] = lis.index(INF)
print(*ans, sep = '\n')
| from bisect import bisect_left
INF = 10 ** 9
N = int(input())
As = list(map(int, input().split()))
adj = [[] for _ in range(N)]
for _ in range(N-1):
u, v = map(int, input().split())
adj[u-1].append(v-1)
adj[v-1].append(u-1)
ans = [0] * N
LIS = [INF] * (N+1)
rewinder = []
parent = [-1] * N
stack = [0]
while stack:
node = stack.pop()
for next_node in adj[node]:
if ans[next_node] == 0:
parent[next_node] = node
stack.append(next_node)
while rewinder and rewinder[-1][0] != parent[node]:
_, index, prev_value = rewinder.pop()
LIS[index] = prev_value
index = bisect_left(LIS, As[node])
rewinder.append((node, index, LIS[index]))
LIS[index] = As[node]
ans[node] = bisect_left(LIS, INF)
print(*ans, sep = '\n')
| p02698 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.readline
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import combinations
def run():
N = int(eval(input()))
A = [0] + list(map(int, sysread().split()))
to = [[] for _ in range(N+1)]
for _ in range(N-1):
u,v = list(map(int, sysread().split()))
to[u].append(v)
to[v].append(u)
seen = [False] * (N+1)
dp = [float('inf')] * (N+2)
dp[0] = -float('inf')
ddp2 = [0]
paths = []
actions = []# (idx, pre, pro)
ans = [0] * (N+1)
def dfs(node, parent=None):
a = A[node]
seen[node] = True
if parent == None:
paths.append(node)
actions.append((1, dp[1], a, 1))
dp[1] = a
ddp2[0] += 1
else:
paths.append(node)
idx = bin_search(dp[:len(paths)+1], a)
if idx == float('inf'):
actions.append((len(paths), float('inf'), a, 1))
dp[len(paths)] = a
ddp2[0] += 1
else:
if dp[idx] == float('inf'):
actions.append((idx, dp[idx], a, 1))
ddp2[0] += 1
else:
actions.append((idx, dp[idx], a, 0))
dp[idx] = a
ans[node] = ddp2[0]
for next in to[node]:
if not seen[next]:
dfs(next, node)
idx, pre, pro, change = actions.pop()
paths.pop()
dp[idx] = pre
ddp2[0] -= change
dfs(1)
for s in ans[1:]:
print(s)
return None
def bin_search(A, x):
'''
return index which is lowest in values more than or equal to x
'''
low = 0
high = len(A) - 1
c = (low + high) // 2
if A[-1] < x: return float('inf')
while high - low > 1:
if A[c] < x:
low = c
c = (low + high) // 2
elif A[c] > x:
high = c
c = (high + low) // 2
else:
return c
return high
if __name__ == "__main__":
run() | # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.readline
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import combinations
def run():
N = int(eval(input()))
A = [0] + list(map(int, sysread().split()))
to = [[] for _ in range(N+1)]
for _ in range(N-1):
u,v = list(map(int, sysread().split()))
to[u].append(v)
to[v].append(u)
seen = [False] * (N+1)
dp = [float('inf')] * (N+2)
dp[0] = -float('inf')
ddp2 = [0]
paths = []
actions = []# (idx, pre, pro)
ans = [0] * (N+1)
def dfs(node, parent=None):
a = A[node]
seen[node] = True
if parent == None:
actions.append((1, dp[1], a, 1))
dp[1] = a
ddp2[0] += 1
else:
idx = bin_search(dp, a)
if dp[idx] == float('inf'):
actions.append((idx, dp[idx], a, 1))
ddp2[0] += 1
else:
actions.append((idx, dp[idx], a, 0))
dp[idx] = a
ans[node] = ddp2[0]
for next in to[node]:
if not seen[next]:
dfs(next, node)
idx, pre, pro, change = actions.pop()
dp[idx] = pre
ddp2[0] -= change
dfs(1)
for s in ans[1:]:
print(s)
return None
def bin_search(A, x):
'''
return index which is lowest in values more than or equal to x
'''
low = 0
high = len(A) - 1
c = (low + high) // 2
if A[-1] < x: return float('inf')
while high - low > 1:
if A[c] < x:
low = c
c = (low + high) // 2
elif A[c] > x:
high = c
c = (high + low) // 2
else:
return c
return high
if __name__ == "__main__":
run() | p02698 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
import math
import bisect
def solve(seq):
dp = [math.inf] * (len(seq) + 1)
dp[0] = -1 * math.inf
for value in seq:
key = bisect.bisect_left(dp, value)
dp[key] = value
print('dp') # debug
print(dp) # debug
key = bisect.bisect_left(dp, math.inf)
return key - 1
class Tree:
"""
node id starts from 1
"""
DUMMY = 0 # used as dummy_node_id and dummy_node_value
def __init__(self, num_node, node_values):
self.node_values = [-1] + node_values # [0] is dummy
self.edges = [None] * (num_node + 1) # [0] is dummy, var[a] = set of links
for i, _ in enumerate(self.edges):
self.edges[i] = set()
self.seq = [self.DUMMY] * num_node
self.dp = [math.inf] * (num_node + 1)
self.dp[0] = -1 * math.inf
self.ans = [0] * (num_node + 1) # [0] is dummy
def node_values(self, node_values):
self.node_values = [-1] + node_values # [0] is dummy
def make_edge(self, a, b):
self.edges[a].add(b)
self.edges[b].add(a)
def dps(self, node_id, prev=0, depth=0):
# process
value = self.node_values[node_id]
key = bisect.bisect_left(self.dp, value)
old_value = self.dp[key]
self.dp[key] = value
self.ans[node_id] = max(key, self.ans[prev])
# recursive
for to in self.edges[node_id]:
if to == prev:
continue
self.dps(to, node_id, depth + 1)
# recursive back
self.dp[key] = old_value
if __name__ == '__main__':
num_node = int(eval(input()))
node_values = list(map(int, input().split()))
tree = Tree(num_node, node_values)
for i in range(num_node - 1):
frm, to = list(map(int, input().split()))
tree.make_edge(frm, to)
tree.dps(1)
for a in tree.ans[1:]:
print(a)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
import math
import bisect
class Tree:
"""
node id starts from 1
"""
DUMMY = 0 # used as dummy_node_id and dummy_node_value
def __init__(self, num_node, node_values):
self.node_values = [-1] + node_values # [0] is dummy
self.edges = [None] * (num_node + 1) # [0] is dummy, var[a] = set of links
for i, _ in enumerate(self.edges):
self.edges[i] = set()
self.seq = [self.DUMMY] * num_node
self.dp = [math.inf] * (num_node + 1)
self.dp[0] = -1 * math.inf
self.ans = [0] * (num_node + 1) # [0] is dummy
def node_values(self, node_values):
self.node_values = [-1] + node_values # [0] is dummy
def make_edge(self, a, b):
self.edges[a].add(b)
self.edges[b].add(a)
def dps(self, node_id, prev=0, depth=0):
# process
value = self.node_values[node_id]
key = bisect.bisect_left(self.dp, value)
old_value = self.dp[key]
self.dp[key] = value
self.ans[node_id] = max(key, self.ans[prev])
# recursive
for to in self.edges[node_id]:
if to == prev:
continue
self.dps(to, node_id, depth + 1)
# recursive back
self.dp[key] = old_value
if __name__ == '__main__':
num_node = int(eval(input()))
node_values = list(map(int, input().split()))
tree = Tree(num_node, node_values)
for i in range(num_node - 1):
frm, to = list(map(int, input().split()))
tree.make_edge(frm, to)
tree.dps(1)
for a in tree.ans[1:]:
print(a)
| p02698 |
n=int(eval(input()))
l=[0]+list(map(int,input().split()))
edge=[[] for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
edge[a].append(b)
edge[b].append(a)
s=1
ans=[0 for i in range(n+1)]
from bisect import bisect_left, bisect_right
INF=float('inf')
import sys
sys.setrecursionlimit(10**6)
dep=[-1 for i in range(n+1)]
def dfs(s,d,c):
dep[s]=d
cc=c[:]
cc[bisect_left(cc,l[s])]=l[s]
ans[s]=bisect_left(cc,INF)
for i in edge[s]:
if dep[i]==-1:
dfs(i,d+1,cc)
c=[INF]*len(l)
dfs(1,0,c)
for i in range(1,n+1):
print((ans[i])) | n=int(eval(input()))
l=[0]+list(map(int,input().split()))
edge=[[] for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
edge[a].append(b)
edge[b].append(a)
s=1
ans=[0 for i in range(n+1)]
from bisect import bisect_left, bisect_right
INF=float('inf')
import sys
sys.setrecursionlimit(10**6)
dep=[-1 for i in range(n+1)]
def dfs(s,d,c):
dep[s]=d
x=bisect_left(c,l[s])
c[x],y=l[s],c[x]
ans[s]=bisect_left(c,INF)
for i in edge[s]:
if dep[i]==-1:
dfs(i,d+1,c)
c[x]=y
c=[INF]*len(l)
dfs(1,0,c)
for i in range(1,n+1):
print((ans[i])) | p02698 |
class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [None for _ in range(self.n)]
self.parent[root] = -1
self.depth = [None for _ in range(self.n)]
self.depth[root] = 0
self.order = []
self.order.append(root)
stack = [root]
while stack:
node = stack.pop()
for adj in self.tree[node]:
if self.parent[adj] is None:
self.parent[adj] = node
self.depth[adj] = self.depth[node] + 1
self.order.append(adj)
stack.append(adj)
def euler_tour(self):
res = []
begin = [None for _ in range(self.n)]
end = [None for _ in range(self.n)]
visited = [0 for _ in range(self.n)]
visited[self.root] = 1
stack = [self.root]
while stack:
node = stack.pop()
res.append(node)
end[node] = len(res)
if begin[node] is None:
begin[node] = len(res) - 1
for adj in self.tree[node]:
if visited[adj]:
continue
visited[adj] = 1
stack.append(node)
stack.append(adj)
return res, begin, end
from bisect import bisect_left
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
E = [tuple(map(int, input().split())) for _ in range(N - 1)]
T = Tree(N, E)
T.setroot(0)
et, _, _ = T.euler_tour()
res = [None for _ in range(N)]
lis = []
rec = [None for _ in range(N)]
prev = None
for node in et:
if res[node] is None:
if not lis or A[node] > lis[-1]:
lis.append(A[node])
else:
idx = bisect_left(lis, A[node])
rec[node] = (idx, lis[idx])
lis[idx] = A[node]
res[node] = len(lis)
else:
if rec[prev] is not None:
lis[rec[prev][0]] = rec[prev][1]
else:
lis.pop()
prev = node
print(('\n'.join(map(str, res)))) | class Tree():
def __init__(self, n, edge):
self.n = n
self.tree = [[] for _ in range(n)]
for e in edge:
self.tree[e[0] - 1].append(e[1] - 1)
self.tree[e[1] - 1].append(e[0] - 1)
def setroot(self, root):
self.root = root
self.parent = [None for _ in range(self.n)]
self.parent[root] = -1
self.depth = [None for _ in range(self.n)]
self.depth[root] = 0
self.order = []
self.order.append(root)
stack = [root]
while stack:
node = stack.pop()
for adj in self.tree[node]:
if self.parent[adj] is None:
self.parent[adj] = node
self.depth[adj] = self.depth[node] + 1
self.order.append(adj)
stack.append(adj)
def euler_tour(self):
res = []
begin = [None for _ in range(self.n)]
end = [None for _ in range(self.n)]
visited = [0 for _ in range(self.n)]
visited[self.root] = 1
stack = [self.root]
while stack:
node = stack.pop()
if node >= 0:
res.append(node)
stack.append(~node)
if begin[node] is None:
begin[node] = len(res) - 1
for adj in self.tree[node]:
if visited[adj]:
continue
visited[adj] = 1
stack.append(adj)
else:
end[~node] = len(res)
if ~node != self.root:
res.append(self.parent[~node])
return res, begin, end
from bisect import bisect_left
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
E = [tuple(map(int, input().split())) for _ in range(N - 1)]
T = Tree(N, E)
T.setroot(0)
et, _, _ = T.euler_tour()
res = [None for _ in range(N)]
lis = []
rec = [None for _ in range(N)]
prev = None
for node in et:
if res[node] is None:
if not lis or A[node] > lis[-1]:
lis.append(A[node])
else:
idx = bisect_left(lis, A[node])
rec[node] = (idx, lis[idx])
lis[idx] = A[node]
res[node] = len(lis)
else:
if rec[prev] is not None:
lis[rec[prev][0]] = rec[prev][1]
else:
lis.pop()
prev = node
print(('\n'.join(map(str, res)))) | p02698 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
from bisect import bisect_left
n = int(readline())
a = list(map(int,readline().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = map(int, readline().split())
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
que = deque()
L = [a[0]]
que.append((0,1,L))
chk = [False]*n
chk[0] = True
cnt = 1
ans = [1]*n
while que:
now,m,L = que.popleft()
if cnt == n:
break
for i in g[now]:
if not chk[i]:
ind = bisect_left(L,a[i])
if m == ind:
newm = m+1
newL = L+[a[i]]
else:
newm = m
newL = L[:ind]+[a[i]]+L[ind+1:]
ans[i] = newm
chk[i] = True
cnt += 1
que.append((i,newm,newL))
print(*ans,sep='\n')
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
from bisect import bisect_left
n = int(readline())
A = list(map(int,readline().split()))
g = [[] * n for i in range(n)]
for i in range(n-1):
u, v = map(int, readline().split())
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
que = deque()
inf = 10**9+1
dp = [inf]*n
que.append((0,-1))
chk = [False]*n
chk[0] = True
cnt = 0
ans = [1]*n
while que:
now,d = que.pop()
if d != -1:
dp[now] = d
else:
ind = bisect_left(dp,A[now])
que.append((ind,dp[ind]))
dp[ind] = A[now]
ans[now] = bisect_left(dp,inf)
cnt += 1
for i in g[now]:
if not chk[i]:
chk[i] = True
que.append((i,-1))
if cnt == n:
break
print(*ans,sep='\n')
| p02698 |
import sys
from collections import deque
from bisect import bisect_left as bisect
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)
def inpl():
return list(map(int, input().split()))
def main():
N = int(eval(input()))
A = inpl()
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
u, v = inpl()
edges[u].append(v)
edges[v].append(u)
DPs = [None] * (N + 1)
DPs[0] = []
Q = deque()
Q.append(1)
parent = [-1] * (N + 1)
parent[1] = 0
while Q:
nv = Q.popleft()
DPs[nv] = DPs[parent[nv]].copy()
t = bisect(DPs[nv], A[nv - 1])
if t >= len(DPs[nv]):
DPs[nv].append(A[nv - 1])
else:
DPs[nv][t] = A[nv - 1]
for kouho in edges[nv]:
if parent[kouho] == -1:
Q.append(kouho)
parent[kouho] = nv
for i in range(1, N + 1):
print((len(DPs[i])))
# print(edges)
# print(parent)
# print(DPs)
if __name__ == '__main__':
main()
| import sys
from bisect import bisect_left as bisect
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)
def inpl():
return list(map(int, input().split()))
class solve:
def __init__(self, N):
self.ans = [0] * N
self.DP = []
def recur(self, i, pi=-1):
# DPテーブルを更新し、答えを求める。
# また、巻き戻す値を覚える。
rev_i = bisect(self.DP, self.A[i])
if rev_i == len(self.DP):
self.DP.append(self.A[i])
rev_v = None
else:
rev_v = self.DP[rev_i]
self.DP[rev_i] = self.A[i]
self.ans[i] = len(self.DP)
for nv in self.edges[i]:
if nv != pi:
self.recur(nv, i)
# 巻き戻す。.
if rev_v is None:
self.DP.pop()
else:
self.DP[rev_i] = rev_v
return
def main():
N = int(input())
S = solve(N)
S.A = inpl()
S.edges = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = inpl()
S.edges[u - 1].append(v - 1)
S.edges[v - 1].append(u - 1)
S.recur(0)
print(*S.ans, sep='\n')
# print(edges)
# print(parent)
# print(DPs)
if __name__ == '__main__':
main()
| p02698 |
import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
while s:
c = s[-1]
ci, clis = c[0], c[1]
# lis処理
if ci not in v:
if len(clis) == 0:
clis.append(A[ci - 1])
else:
if clis[-1] < A[ci - 1]:
clis.append(A[ci - 1])
else:
i = bisect.bisect_left(clis, A[ci - 1])
clis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(clis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, clis.copy()])
continue
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci, clis = c[0], c[1]
# lis処理
if ci not in v:
if len(clis) == 0:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
if clis[-1] < A[ci - 1]:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(clis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(clis[i])
clis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(clis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, clis])
continue
if memo[ci][0] == -1:
if len(clis) >= 1:
clis.pop()
else:
clis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| p02698 |
import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci, clis = c[0], c[1]
# lis処理
if ci not in v:
if len(clis) == 0:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
if clis[-1] < A[ci - 1]:
clis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(clis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(clis[i])
clis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(clis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, clis])
continue
if memo[ci][0] == -1:
if len(clis) >= 1:
clis.pop()
else:
clis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci = c[0]
# lis処理
if ci not in v:
if len(lis) == 0:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
if lis[-1] < A[ci - 1]:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(lis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(lis[i])
lis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(lis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, lis])
continue
if memo[ci][0] == -1:
if len(lis) >= 1:
lis.pop()
else:
lis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| p02698 |
import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
v = set()
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci = c[0]
# lis処理
if ci not in v:
if len(lis) == 0:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
if lis[-1] < A[ci - 1]:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(lis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(lis[i])
lis[i] = A[ci - 1]
v.add(ci)
ans[ci] = len(lis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if n in v:
continue
s.append([n, lis])
continue
if memo[ci][0] == -1:
if len(lis) >= 1:
lis.pop()
else:
lis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| import sys
import bisect
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [int(x) for x in input().split()]
UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
T = [[] for j in range(N + 1)]
for u, v in UV:
T[u].append(v)
T[v].append(u)
s = collections.deque()
lis = []
s.append([1, lis])
ans = [0] * (N + 1)
memo = [[] for j in range(N + 1)]
while s:
c = s[-1]
ci = c[0]
# lis処理
if ans[ci] == 0:
if len(lis) == 0:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
if lis[-1] < A[ci - 1]:
lis.append(A[ci - 1])
memo[ci].append(-1)
else:
i = bisect.bisect_left(lis, A[ci - 1])
memo[ci].append(i)
memo[ci].append(lis[i])
lis[i] = A[ci - 1]
ans[ci] = len(lis)
if len(T[ci]) >= 1:
n = T[ci].pop()
if ans[n] != 0:
continue
s.append([n, lis])
continue
if memo[ci][0] == -1:
if len(lis) >= 1:
lis.pop()
else:
lis[memo[ci][0]] = memo[ci][1]
s.pop()
for i in range(1, N + 1):
print((ans[i]))
if __name__ == '__main__':
main()
| p02698 |
import sys
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
repn = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = list(map(int, input().split()))
repn[u - 1].append(v - 1)
repn[v - 1].append(u - 1)
length = [0] * (N + 1)
dp = [-1]
"""
やはり各頂点でLIS配列を取ると配列コピーの時間がかかってTLEするので、
配列は唯一つを扱って、DFSからバックするときに配列も元に戻す操作を行いたい
（ここの実装の仕方がわからなかった）
これはdfsを再帰で書いた後に復元操作を追記すれば異常に楽に書ける。。。
"""
def dfs(v, p=N):
if A[v] > dp[-1]:
dp.append(A[v])
length[v] = length[p] + 1
for u in repn[v]:
if u == p: continue
dfs(u, v)
dp.pop()
else:
length[v] = length[p]
idx = bisect_left(dp[:length[p]], A[v]) # bisect_rightだとdpに重複する値を書き込んでしまうのでダメ
old = dp[idx]
dp[idx] = A[v]
for u in repn[v]:
if u == p: continue
dfs(u, v)
dp[idx] = old
#print("v={}, len={}, dp={}".format(v, length[v], dp))
dfs(0)
length.pop()
for ans in length:
print(ans)
if __name__ == "__main__":
main()
| import sys
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(2*10**5)
def input(): return sys.stdin.readline().strip()
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
repn = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = list(map(int, input().split()))
repn[u - 1].append(v - 1)
repn[v - 1].append(u - 1)
length = [0] * (N + 1)
dp = [-1]
"""
やはり各頂点でLIS配列を取ると配列コピーの時間がかかってTLEするので、
配列は唯一つを扱って、DFSからバックするときに配列も元に戻す操作を行いたい
（ここの実装の仕方がわからなかった）
これはdfsを再帰で書いた後に復元操作を追記すれば異常に楽に書ける。。。
"""
def dfs(v, p=N):
if A[v] > dp[-1]:
dp.append(A[v])
length[v] = length[p] + 1
for u in repn[v]:
if u == p: continue
dfs(u, v)
dp.pop()
else:
length[v] = length[p]
idx = bisect_left(dp, A[v]) # bisect_rightだとdpに重複する値を書き込んでしまうのでダメ
old = dp[idx]
dp[idx] = A[v]
for u in repn[v]:
if u == p: continue
dfs(u, v)
dp[idx] = old
#print("v={}, len={}, dp={}".format(v, length[v], dp))
dfs(0)
length.pop()
for ans in length:
print(ans)
if __name__ == "__main__":
main()
| p02698 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
a = na()
g = []
for i in range(n):
g.append([])
for i in range(n-1):
x, y = na()
g[x-1].append(y-1)
g[y-1].append(x-1)
sys.setrecursionlimit(300000)
import bisect
def dfs(cur, pre, g, lis, la, anss, a):
ind = bisect.bisect_left(la, a[cur])
old = la[ind]
la[ind] = a[cur]
nlis = lis + 1 if ind == lis + 1 else lis
anss[cur] = nlis
for e in g[cur]:
if e == pre: continue
dfs(e, cur, g, nlis, la, anss, a)
la[ind] = old
anss = [0] * n
la = [999999999999] * (n+1)
la[0] = 0
dfs(0, -1, g, 0, la, anss, a)
for v in anss:
print(v) | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n = ni()
a = na()
g = []
for i in range(n):
g.append([])
for i in range(n-1):
x, y = na()
g[x-1].append(y-1)
g[y-1].append(x-1)
sys.setrecursionlimit(230000)
import bisect
def dfs(cur, pre, g, lis, la, anss, a):
ind = bisect.bisect_left(la, a[cur], 0, lis+1)
old = la[ind]
la[ind] = a[cur]
nlis = lis + 1 if ind == lis + 1 else lis
anss[cur] = nlis
for e in g[cur]:
if e == pre: continue
dfs(e, cur, g, nlis, la, anss, a)
la[ind] = old
anss = [0] * n
la = [999999999999] * (n+2)
la[0] = 0
dfs(0, -1, g, 0, la, anss, a)
for v in anss:
print(v) | p02698 |
from collections import deque
import sys
import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
n = int(eval(input()))
a = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n-1):
u, v = list(map(int, input().split()))
edges[u-1].append(v-1)
edges[v-1].append(u-1)
d = [0 for _ in range(n)]
memo = [[] for _ in range(n)]
seen = [False for _ in range(n)]
que = deque()
que.append(0)
memo[0] = [a[0]]
d[0] = 1
seen[0] = True
while len(que):
cur = que.popleft()
for to in edges[cur]:
if not seen[to]:
seen[to] = True
memo[to] = memo[cur].copy()
if memo[cur][-1] < a[to]:
d[to] = d[cur] + 1
memo[to].append(a[to])
else:
d[to] = d[cur]
memo[to][bisect.bisect_left(memo[to], a[to])] = a[to]
que.append(to)
for i in range(n):
print((d[i])) | from collections import deque
import sys
import bisect
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
n = int(eval(input()))
a = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n-1):
u, v = list(map(int, input().split()))
edges[u-1].append(v-1)
edges[v-1].append(u-1)
d = [0 for _ in range(n)]
memo = [[] for _ in range(n)]
seen = [False for _ in range(n)]
que = deque()
que.append(0)
memo[0] = [a[0]]
d[0] = 1
seen[0] = True
while len(que):
cur = que.popleft()
for to in edges[cur]:
if not seen[to]:
seen[to] = True
memo[to] = memo[cur].copy()
if memo[cur][-1] < a[to]:
d[to] = d[cur] + 1
memo[to].append(a[to])
else:
d[to] = d[cur]
memo[to][bisect.bisect_left(memo[to], a[to])] = a[to]
que.append(to)
memo[cur] = []
for i in range(n):
print((d[i])) | p02698 |
from bisect import bisect_left
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
lis = [float('inf')] * N
ans = [0] * N
visited = [False] * N
def dfs(v):
visited[v] = True
i = bisect_left(lis, a[v])
tmp = lis[i]
lis[i] = a[v]
ans[v] = bisect_left(lis, float('inf'))
for c in G[v]:
if visited[c]:
continue
dfs(c)
lis[i] = tmp
dfs(0)
print(('\n'.join(map(str, ans)))) | from bisect import bisect_left
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
lis = [float('inf')] * N
ans = [0] * N
def dfs(v, p):
i = bisect_left(lis, a[v])
tmp = lis[i]
lis[i] = a[v]
ans[v] = bisect_left(lis, float('inf'))
for c in G[v]:
if c == p:
continue
dfs(c, v)
lis[i] = tmp
dfs(0, -1)
print(('\n'.join(map(str, ans)))) | p02698 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
# 頂点1から頂点kまでの最短パス上
# ルートはO(n)で求められる
N = getN()
A = getList()
query = [getList() for i in range(N - 1)]
dist = [[] for i in range(N)]
for i in range(N - 1):
a, b = query[i]
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
ignore = [0] * N
ignore[0] = 1
lis = [A[0]]
rec = [0] * N
rec[0] = 1
# 行きがけ帰りがけの要領
def dfs(u):
global lis
for i in dist[u]:
if ignore[i] != 1:
ignore[i] = 1
ar = deepcopy(lis) # 元の状態をレコード
if A[i] > ar[-1]:
lis.append(A[i])
else:
lis[bisect_left(ar, A[i])] = A[i]
rec[i] = len(lis)
dfs(i)
lis = deepcopy(ar) # 元に戻す
dfs(0)
for i in rec:
print(i) | def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
# 頂点1から頂点kまでの最短パス上
# ルートはO(n)で求められる
N = getN()
A = getList()
query = [getList() for i in range(N - 1)]
dist = [[] for i in range(N)]
for i in range(N - 1):
a, b = query[i]
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
ignore = [0] * N
ignore[0] = 1
lis = [A[0]]
rec = [0] * N
rec[0] = 1
# 行きがけ帰りがけの要領
def dfs(u):
global lis
for i in dist[u]:
if ignore[i] != 1:
ignore[i] = 1
# 巻き戻し用
plus = 0 # true or false
change = (0, 0, 0) # true or false, 変更した場所、変更した数値
if A[i] > lis[-1]:
lis.append(A[i])
plus = 1
else:
index = bisect_left(lis, A[i])
change = (1, index, lis[index])
lis[index] = A[i]
rec[i] = len(lis)
dfs(i)
# 巻き戻す
if plus:
lis.pop()
else:
lis[change[1]] = change[2]
dfs(0)
for i in rec:
print(i) | p02698 |
from bisect import bisect_left
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
adj = [set() for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
adj[u-1].add(v-1)
adj[v-1].add(u-1)
ans = [0] * N
q = [(0, -1, [], True)]
while len(q):
cur, prev, lis, override = q.pop()
idx = bisect_left(lis, A[cur])
if override:
nxt_lis = lis
else:
nxt_lis = list(lis)
if idx == len(nxt_lis):
nxt_lis.append(A[cur])
else:
nxt_lis[idx] = A[cur]
ans[cur] = len(nxt_lis)
nxt_override = (cur != 0)
for nxt in adj[cur]:
if nxt == prev:
continue
q.append((nxt, cur, nxt_lis, nxt_override))
nxt_override = False
for i in range(N):
print((ans[i]))
if __name__ == "__main__":
main()
| from bisect import bisect_left
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
adj = [set() for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
adj[u-1].add(v-1)
adj[v-1].add(u-1)
ans = [0] * N
q = [(0, -1, [], 0)]
history = []
while len(q):
cur, prev, lis, depth = q.pop()
while depth < len(history):
pos, val = history.pop()
if val is None:
lis.pop()
else:
lis[pos] = val
idx = bisect_left(lis, A[cur])
if idx == len(lis):
history.append((idx, None))
lis.append(A[cur])
else:
history.append((idx, lis[idx]))
lis[idx] = A[cur]
ans[cur] = len(lis)
for nxt in adj[cur]:
if nxt == prev:
continue
q.append((nxt, cur, lis, depth+1))
for i in range(N):
print((ans[i]))
if __name__ == "__main__":
main()
| p02698 |
import bisect
import sys
sys.setrecursionlimit(10**7)
def dfs(v,l,tr):
ans[v]=l
for u in g[v]:
if checked[u]==0:
checked[u]=1
pos=bisect.bisect_left(tr,arr[u])
if pos==l:
dfs(u,l+1,tr+[arr[u]])
elif tr[pos]==arr[u]:
dfs(u,l,tr)
else:
dfs(u,l,tr[:pos]+[arr[u]]+tr[pos+1:])
n=int(eval(input()))
arr=[0]+list(map(int,input().split()))
g=[[] for _ in range(n+1)]
for _ in range(n-1):
a,b=list(map(int,input().split()))
g[a].append(b)
g[b].append(a)
ans=[0]*(n+1)
checked=[0]*(n+1)
checked[1]=1
dfs(1,1,[arr[1]])
for i in range(1,n+1):
print((ans[i])) | import bisect
import sys
sys.setrecursionlimit(10**7)
def dfs(v):
pos=bisect.bisect_left(dp,arr[v])
changes.append((pos,dp[pos]))
dp[pos]=arr[v]
ans[v]=bisect.bisect_left(dp,10**18)
for u in g[v]:
if checked[u]==0:
checked[u]=1
dfs(u)
pos,val=changes.pop()
dp[pos]=val
n=int(eval(input()))
arr=[0]+list(map(int,input().split()))
g=[[] for _ in range(n+1)]
for _ in range(n-1):
a,b=list(map(int,input().split()))
g[a].append(b)
g[b].append(a)
ans=[0]*(n+1)
checked=[0]*(n+1)
checked[1]=1
dp=[10**18 for _ in range(n+1)]
changes=[]
dfs(1)
for i in range(1,n+1):
print((ans[i])) | p02698 |
import queue
n = int(eval(input()))
a = list(map(int,input().split()))
way = [[] for i in range(n)]
for i in range(n-1):
u,v = list(map(int,input().split()))
u,v = u-1,v-1
way[u].append(v)
way[v].append(u)
stst = [[] for i in range(n)]
stst[0] = [a[0]]
q = queue.Queue()
for i in way[0]:
q.put((i,0))
while not q.empty():
i,pi = q.get()
for j in way[i]:
if pi == j:
continue
q.put((j,i))
stst[i] = stst[pi]+[a[i]]
def lenlis(arr):
mns = [10**18 for i in range(len(arr)+2)]
mns[0] = 0
mai = 0
for i in arr:
for j in range(len(arr)):
if i > mns[j]:
if i < mns[j+1]:
mns[j+1] = i
break
else:
break
return mns.index(10**18)-1
for i in stst:
print((lenlis(i)))
| import queue
inf = 10**18
n = int(eval(input()))
a = list(map(int,input().split()))
way = [[] for i in range(n)]
for i in range(n-1):
u,v = list(map(int,input().split()))
u,v = u-1,v-1
way[u].append(v)
way[v].append(u)
def Mnsr(ni,mns):
mnsi = mns + [inf]
l = 0
r = len(mns)
while l < r:
mid = (r-l)//2+l
if ni < mnsi[mid]:
r = mid
else:
l = mid+1
if not mnsi[l-1] == ni:
mnsi[l] = ni
return mnsi
def ansfind(arr):
l = 0
r = len(arr)-1
while l < r:
mid = l + (r-l)//2
if arr[mid] == inf:
r = mid
else:
l = mid+1
return l-1
ans = [1 for i in range(n)]
q = queue.Queue()
for i in way[0]:
q.put((i,0,Mnsr(a[i],[0,a[0],inf])))
while not q.empty():
i,pi,mns = q.get()
ans[i] = ansfind(mns)
for j in way[i]:
if pi == j:
continue
q.put((j,i,Mnsr(a[j],mns)))
for i in ans:
print(i)
| p02698 |
import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict,deque
import bisect
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int,input().split()))
g = defaultdict(list)
for i in range(N-1):
u, v = list(map(int,input().split()))
g[u].append(v)
g[v].append(u)
def eulerTour(g,s):
n = len(g)
dq = [s]
ls = [-1]*(n+1)
rs = [-1]*(n+1)
index = []
visited = [False]*(n+1)
def dfs(v):
visited[v] = True
ls[v] = len(index)
index.append(v)
for nv in g[v]:
if not visited[nv]:
dfs(nv)
rs[v] = len(index)
index.append(v)
dfs(s)
return ls,rs,index
ls,rs,index = eulerTour(g,1)
inf = 10**10
l = [inf] * (N+1)
ans = [0] * (N+1)
ans[1] = 1
visited = [False]*(N+1)
rollback = []
for v in index:
if visited[v]:
i, pa = rollback.pop()
l[i] = pa
else:
A = a[v-1]
i = bisect.bisect_left(l,A)
rollback.append((i,l[i]))
l[i] = A
ans[v] = l.index(inf)
visited[v] = True
for i in range(1,N+1):
print((ans[i]))
| import sys
sys.setrecursionlimit(10**9)
from collections import defaultdict,deque
import bisect
input = sys.stdin.readline
N = int(eval(input()))
a = list(map(int,input().split()))
g = defaultdict(list)
for i in range(N-1):
u, v = list(map(int,input().split()))
g[u].append(v)
g[v].append(u)
def eulerTour(g,s):
n = len(g)
dq = [s]
ls = [-1]*(n+1)
rs = [-1]*(n+1)
index = []
visited = [False]*(n+1)
def dfs(v):
visited[v] = True
ls[v] = len(index)
index.append(v)
for nv in g[v]:
if not visited[nv]:
dfs(nv)
rs[v] = len(index)
index.append(v)
dfs(s)
return ls,rs,index
ls,rs,index = eulerTour(g,1)
dq = deque([1])
visited = [False]*(N+1)
inf = 10**10
l = [inf] * (N+1)
ans = [0] * (N+1)
ans[1] = 1
visited = [False]*(N+1)
rollback = []
k = 1
for v in index:
if visited[v]:
i, pa = rollback.pop()
l[i] = pa
if pa == inf:
k -= 1
else:
A = a[v-1]
i = bisect.bisect_left(l,A)
rollback.append((i,l[i]))
if k <= i:
k += 1
l[i] = A
#ans[v] = l.index(inf)
ans[v] = k
visited[v] = True
for i in range(1,N+1):
print((ans[i]))
| p02698 |
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_tuple(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(tuple(map(int, read().split())))
return ret
def read_col(H):
'''
H is number of rows
A列、B列が与えられるようなとき
ex1)A,B=read_col(H) ex2) A,=read_col(H) #一列の場合
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return tuple(map(list, zip(*ret)))
def read_matrix(H):
'''
H is number of rows
'''
ret = []
for _ in range(H):
ret.append(list(map(int, read().split())))
return ret
# return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため
from bisect import bisect_left, bisect_right, insort_left
class BinarySearchTree:
def __init__(self, ls: list = []):
'''
C++でいうsetを実装する。二分探索木をガチで実装しようとすると大変なので、ここでは配列二分法を用いる。
pythonの標準ライブラリがヨイショに抱っこしてくれるおかげで楽に実装できる。
https://docs.python.org/ja/3/library/bisect.html
ls ... 渡す初期配列
'''
self.bst = ls # insertをO(1)にするためにlistの代わりにdequeを用います
def __repr__(self):
return f'BST:{self.bst}'
def __len__(self):
return len(self.bst)
def __getitem__(self, idx):
return self.bst[idx]
def size(self):
return len(self.bst)
def insert(self, x):
insort_left(self.bst, x)
def remove(self, x):
'''
xを取り除く。xがself.bstに存在することを保証してください。
同一のものが存在した場合は左から消していく
'''
del self.bst[self.find(x)]
def bisect_left(self, x):
'''
ソートされた順序を保ったまま x を self.bst に挿入できる点を探し当てます。
lower_bound in C++
'''
return bisect_left(self.bst, x)
def bisect_right(self, x):
'''
bisect_left() と似ていますが、 self.bst に含まれる x のうち、どのエントリーよりも後ろ(右)にくるような挿入点を返します。
upper_bound in C++
'''
return bisect_right(self.bst, x)
def find(self, x):
'''
xのidxを探索
'''
idx = bisect_left(self.bst, x)
if idx != len(self.bst) and self.bst[idx] == x:
return idx
raise ValueError
def insert_replace_left(self, x):
'''
xを挿入して、xの左の数字(次に小さい)を削除する。idxがはみ出す場合は挿入だけ
'''
idx_del = self.bisect_left(x) - 1
if idx_del + 1 == 0: # xがどの要素よりも小さい
self.insert(x)
if idx_del < len(self.bst):
self.insert(x)
del self.bst[idx_del]
def insert_replace_right(self, x):
'''
xを挿入して、xの右の数字(次に大きい)を削除する。idxがはみ出す場合は挿入だけ
'''
idx_del = self.bisect_left(x) + 1
if idx_del - 1 == len(self.bst): # xがどの要素よりも大きい
self.insert(x)
else:
self.insert(x)
del self.bst[idx_del]
MOD = 10**9 + 7
INF = 2**31 # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right # , insort_left, insort_right
from math import gcd
# 各ノードに今までの最長増加部分列と現在の増加部分列長の記録があれば、たかだた分岐地点から探索できるのでは？
N = read_a_int()
A = read_ints()
Tree = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = read_ints()
u -= 1
v -= 1
Tree[u].append(v)
Tree[v].append(u)
LIS = BinarySearchTree([-1])
ans = [-1] * N
def dfs(u, p, LIS): # これって参照渡しに成るんすかねすると厄介かもしれない
'''現在のノード、親、最長増加部分列の状態'''
LIS.insert_replace_right(A[u])
ans[u] = len(LIS) - 1
# print(u, LIS.bst)
if len(Tree[u]) > 2 or u == 0: # 配列のコピーを渡す
for nu in Tree[u]:
if nu == p:
continue
dfs(nu, u, BinarySearchTree(LIS.bst.copy())) # ここでTLE
elif len(Tree[u]) == 2: # 参照渡しでok
for nu in Tree[u]:
if nu == p:
continue
dfs(nu, u, LIS)
# def dfs(u, p, LIS): # これって参照渡しに成るんすかねすると厄介かもしれない
# '''現在のノード、親、最長増加部分列の状態'''
# LIS.insert_replace_right(A[u])
# ans[u] = len(LIS) - 1
# for nu in Tree[u]:
# if nu == p:
# continue
# dfs(nu, u, BinarySearchTree(LIS.bst.copy()))
dfs(0, -1, LIS)
print(*ans, sep='\n')
| # 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=False):
if mina:
return list(map(mina1, read().split()))
else:
return list(map(int, read().split()))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
####################
# dp = []
# for a in A:
# print(dp)
# idx = bisect_left(dp, a) # 初めて真に大きい要素になるidx
# if idx == len(dp):
# dp.append(a)
# else:
# dp[idx] = a # aに更新
# print(dp)
# print(len(dp))
####################
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=True)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
# 終了条件# 子が無いとき
# LISの更新
idx = bisect_left(LIS, A[now])
is_append = False
if idx == len(LIS):
LIS.append(A[now])
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = A[now] # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| p02698 |
# 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=False):
if mina:
return list(map(mina1, read().split()))
else:
return list(map(int, read().split()))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
####################
# dp = []
# for a in A:
# print(dp)
# idx = bisect_left(dp, a) # 初めて真に大きい要素になるidx
# if idx == len(dp):
# dp.append(a)
# else:
# dp[idx] = a # aに更新
# print(dp)
# print(len(dp))
####################
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=True)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
# 終了条件# 子が無いとき
# LISの更新
idx = bisect_left(LIS, A[now])
is_append = False
if idx == len(LIS):
LIS.append(A[now])
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = A[now] # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| # 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=False):
if mina:
return list(map(mina1, read().split()))
else:
return list(map(int, read().split()))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=True)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
a = A[now]
# LISの更新
idx = bisect_left(LIS, a)
is_append = False
if idx == len(LIS):
LIS.append(a)
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = a # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| p02698 |
# 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=None):
ret = map(int, read().split())
if mina == None:
return list(ret)
else:
return list(map(lambda x: x - mina, ret))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=1)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
a = A[now]
# LISの更新
idx = bisect_left(LIS, a)
is_append = False
if idx == len(LIS):
LIS.append(a)
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = a # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| # 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=None):
ret = map(int, read().split())
if mina == None:
return list(ret)
else:
return list(map(lambda x: x - 1, ret))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=1)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
a = A[now]
# LISの更新
idx = bisect_left(LIS, a)
is_append = False
if idx == len(LIS):
LIS.append(a)
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = a # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| p02698 |
# 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x):
return int(x) - 1
def read_ints(mina=None):
ret = map(int, read().split())
if mina == None:
return list(ret)
else:
return list(map(mina1, ret))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(mina=1)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
a = A[now]
# LISの更新
idx = bisect_left(LIS, a)
is_append = False
if idx == len(LIS):
LIS.append(a)
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = a # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| # 木によってLISを作り、dfsで抜けるときにLISをその前の状態まで復元する
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate
def mina1(x): return int(x) - 1
def read_ints(tozero=False):
if tozero == False:
return list(map(int, read().split()))
else:
return list(map(mina1, read().split()))
def read_a_int():
return int(read())
from bisect import bisect_left, bisect_right
from collections import defaultdict
N = read_a_int()
A = read_ints()
tree = defaultdict(lambda: [])
for _ in ra(N - 1):
u, v = read_ints(True)
tree[u].append(v)
tree[v].append(u)
LIS = []
ans = [0] * N # 各ノードのlen(LIS)を記録
def dfs(now, p): # 現在のノード、親
a = A[now]
# LISの更新
idx = bisect_left(LIS, a)
is_append = False
if idx == len(LIS):
LIS.append(a)
is_append = True
else:
old = LIS[idx] # なんの値だったか持っておく
LIS[idx] = a # aに更新
ans[now] = len(LIS) # 答えを記録
# 次のノードを探索
for to in tree[now]:
if to == p:
continue
dfs(to, now)
# 抜けるときにLISを復元
if is_append:
del LIS[idx]
else:
LIS[idx] = old
dfs(0, -1)
print(*ans, sep='\n')
| p02698 |
#!/usr/bin/env python3
#F
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
edges = [[] for _ in range(n)]
for _ in range(n-1):
u, v = LI()
edges[u-1].append(v-1)
edges[v-1].append(u-1)
dp = [inf]*n
ans = [None]*n
ans[0] = 1
dp[0] = a[0]
def dfs(s, p, dp, num):
for u in edges[s]:
flag = False
if u == p:
continue
r = bl(dp, a[u])
tmp = dp[r]
if dp[r] == inf:
num += 1
flag = True
ans[u] = num
dp[r] = min(dp[r], a[u])
dfs(u, s, dp, num)
dp[r] = tmp
if flag:
num -= 1
return
dfs(0, -1, dp, 1)
for i in ans:
print(i)
| #!/usr/bin/env python3
#F
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
a = LI()
edges = [[] for _ in range(n)]
for _ in range(n-1):
u, v = LI()
edges[u-1].append(v-1)
edges[v-1].append(u-1)
dp = [inf]*n
ans = [None]*n
ans[0] = 1
dp[0] = a[0]
def dfs(s, p, dp, num):
for u in edges[s]:
flag = False
if u == p:
continue
if ans[u] != None:
continue
r = bl(dp, a[u])
tmp = dp[r]
if dp[r] == inf:
num += 1
flag = True
ans[u] = num
dp[r] = min(dp[r], a[u])
dfs(u, s, dp, num)
dp[r] = tmp
if flag:
num -= 1
return
dfs(0, -1, dp, 1)
for i in ans:
print(i)
| p02698 |
import sys
sys.setrecursionlimit(10 ** 9)
from bisect import bisect_left
N = int(input())
A = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
root = 0
stack = [root]
visited = set()
visited.add(root)
done = set()
vs = []
ans = [0] * N
memo = [None] * N
memo[root] = (0, A[root])
INF = 10 ** 10
dp = [INF] * N
while stack:
now_ = stack[-1]
if now_ in done:
j, a = memo[now_]
dp[j] = a
stack.pop()
vs.append(now_)
else:
for next_ in G[now_][::-1]:
if next_ in visited:
continue
visited.add(next_)
stack.append(next_)
done.add(now_)
tmp = bisect_left(dp, A[now_])
memo[now_] = (tmp, dp[tmp])
dp[tmp] = A[now_]
ans[now_] = bisect_left(dp, INF)
# print (vs)
print (*ans, sep = '\n')
| def main():
import sys
input = sys.stdin.readline
from bisect import bisect_left
N = int(input())
A = list(map(int, input().split()))
G = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
root = 0
stack = [root]
visited = set()
visited.add(root)
done = set()
vs = []
ans = [0] * N
memo = [None] * N
memo[root] = (0, A[root])
INF = 10 ** 10
dp = [INF] * N
while stack:
now_ = stack[-1]
if now_ in done:
j, a = memo[now_]
dp[j] = a
stack.pop()
vs.append(now_)
else:
for next_ in G[now_][::-1]:
if next_ in visited:
continue
visited.add(next_)
stack.append(next_)
done.add(now_)
tmp = bisect_left(dp, A[now_])
memo[now_] = (tmp, dp[tmp])
dp[tmp] = A[now_]
ans[now_] = bisect_left(dp, INF)
# print (vs)
print (*ans, sep = '\n')
if __name__ == '__main__':
main()
| p02698 |
# -*- coding: utf-8 -*-
import bisect
# import heapq
# import math
# import random
import sys
# from collections import Counter, defaultdict, deque
# from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
# from functools import lru_cache, reduce
# from itertools import combinations, combinations_with_replacement, product, permutations
# from operator import add, mul, sub
sys.setrecursionlimit(100000)
# input = sys.stdin.buffer.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
ans = [-1] * (2*10**5+1)
@mt
def slv(N, A, UV):
A.insert(0, -1)
g = [list() for _ in range(0, N+1)]
for u, v in UV:
g[u].append(v)
g[v].append(u)
def dfs(u, p, dp):
global ans
for v in g[u]:
if v == p:
continue
i = bisect.bisect_left(dp, A[v])
if len(dp) <= i:
dp.append(A[v])
ans[v] = len(dp)
dfs(v, u, dp)
dp.pop()
else:
b = dp[i]
dp[i] = A[v]
ans[v] = len(dp)
dfs(v, u, dp)
dp[i] = b
dp = [A[1]]
dfs(1, 0, dp)
ans[1] = 1
for i in range(1, N+1):
print(ans[i])
# return ans[:N]
def main():
N = read_int()
A = read_int_n()
UV = [read_int_n() for _ in range(N-1)]
(slv(N, A, UV))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import sys
sys.setrecursionlimit(100000)
input = sys.stdin.buffer.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
ans = [-1] * (2*10**5+1)
@mt
def slv(N, A, UV):
A.insert(0, -1)
g = [list() for _ in range(0, N+1)]
for u, v in UV:
g[u].append(v)
g[v].append(u)
def dfs(u, p, dp):
global ans
for v in g[u]:
if v == p:
continue
i = bisect.bisect_left(dp, A[v])
if len(dp) <= i:
dp.append(A[v])
ans[v] = len(dp)
dfs(v, u, dp)
dp.pop()
else:
b = dp[i]
dp[i] = A[v]
ans[v] = len(dp)
dfs(v, u, dp)
dp[i] = b
dp = [A[1]]
dfs(1, 0, dp)
ans[1] = 1
for i in range(1, N+1):
print(ans[i])
# return ans[:N]
def main():
N = read_int()
A = read_int_n()
UV = [read_int_n() for _ in range(N-1)]
(slv(N, A, UV))
if __name__ == '__main__':
main()
| p02698 |
def main():
import sys
input = sys.stdin.readline
import bisect
from collections import deque
from copy import deepcopy
n = int(eval(input()))
l = list(map(int,input().split()))
e = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
ans = [[] for i in range(n)]
ans[0] = [[l[0]],1]
q = deque([])
q.append((0,-1))
while q:
now,bef = q.popleft()
for nex in e[now]:
if nex != bef:
a = l[nex]
b = ans[now][1]
c = deepcopy(ans[now][0])
if a > c[-1]:
c.append(l[nex])
ans[nex] = [c,b+1]
else:
c[bisect.bisect_left(c, l[nex])] = l[nex]
ans[nex] = [c,b]
q.append((nex,now))
for i in ans:
print((i[1]))
if __name__ == "__main__":
main() |
import sys
input = sys.stdin.readline
import bisect
sys.setrecursionlimit(10**7)
n = int(eval(input()))
l = list(map(int,input().split()))
e = [[] for i in range(n)]
for i in range(n-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
ans = [0]*n
ans[0] = 1
dp = [l[0]]
def dfs(now,bef):
change = True
if l[now] > dp[-1]:
dp.append(l[now])
else:
index = bisect.bisect_left(dp,l[now])
change = False
s = dp[index]
dp[index] = l[now]
ans[now] = len(dp)
for nex in e[now]:
if nex != bef:
dfs(nex,now)
if change:
dp.pop()
else:
dp[index] = s
for i in e[0]:
dfs(i,0)
for i in ans:
print(i)
| p02698 |
import bisect
import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
A = list(map(int, input().split()))
edges = [[] for _ in range(n)]
for _ in range(n-1):
from_, to = list(map(int, input().split()))
edges[from_-1].append(to-1)
edges[to-1].append(from_-1)
DP = [10**9+7] * (n+1)
DP[0] = 0
ans = [0] * n
def dfs(node):
node = node
num = A[node]
update_idx = bisect.bisect_left(DP, num)
prev = DP[update_idx]
DP[update_idx] = num
lis = bisect.bisect_left(DP, 10**9+1) - 1
ans[node] = lis
for nex in edges[node]:
if not ans[nex]:
dfs(nex)
DP[update_idx] = prev
dfs(0)
for res in ans:
print(res)
| import bisect
n = int(eval(input()))
A = list(map(int, input().split()))
edges = [[] for _ in range(n+1)]
for _ in range(n-1):
from_, to = list(map(int, input().split()))
edges[from_].append(to)
edges[to].append(from_)
DP = [10**9+7] * (n+1)
limit = 10**9 + 1
DP[0] = 0
olds = [None] * (n+1)
ans = [0] * n
todo = [1]
while todo:
node = todo.pop()
if node > 0:
num = A[node-1]
update_idx = bisect.bisect_left(DP, num)
old = DP[update_idx]
olds[node] = (old, update_idx)
DP[update_idx] = num
lis = bisect.bisect_left(DP, limit) - 1
ans[node-1] = lis
todo.append(-node)
for to in edges[node]:
if ans[to-1]:
continue
todo.append(to)
else:
node = -node
old, update_idx = olds[node]
DP[update_idx] = old
for res in ans:
print(res)
| p02698 |
import bisect
n = int(eval(input()))
A = list(map(int, input().split()))
edges = [[] for _ in range(n+1)]
for _ in range(n-1):
from_, to = list(map(int, input().split()))
edges[from_].append(to)
edges[to].append(from_)
DP = [10**9+7] * (n+1)
limit = 10**9 + 1
DP[0] = 0
olds = [None] * (n+1)
ans = [0] * n
todo = [1]
while todo:
node = todo.pop()
if node > 0:
num = A[node-1]
update_idx = bisect.bisect_left(DP, num)
old = DP[update_idx]
olds[node] = (old, update_idx)
DP[update_idx] = num
lis = bisect.bisect_left(DP, limit) - 1
ans[node-1] = lis
todo.append(-node)
for to in edges[node]:
if ans[to-1]:
continue
todo.append(to)
else:
node = -node
old, update_idx = olds[node]
DP[update_idx] = old
for res in ans:
print(res)
| import bisect
import sys
input = sys.stdin.readline
n = int(eval(input()))
A = list(map(int, input().split()))
edges = [[] for _ in range(n+1)]
for _ in range(n-1):
from_, to = list(map(int, input().split()))
edges[from_].append(to)
edges[to].append(from_)
DP = [10**9+7] * (n+1)
limit = 10**9 + 1
DP[0] = 0
olds = [None] * (n+1)
ans = [0] * n
todo = [1]
while todo:
node = todo.pop()
if node > 0:
num = A[node-1]
update_idx = bisect.bisect_left(DP, num)
old = DP[update_idx]
olds[node] = (old, update_idx)
DP[update_idx] = num
lis = bisect.bisect_left(DP, limit) - 1
ans[node-1] = lis
todo.append(-node)
for to in edges[node]:
if ans[to-1]:
continue
todo.append(to)
else:
node = -node
old, update_idx = olds[node]
DP[update_idx] = old
for res in ans:
print(res)
| p02698 |
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): return int(sys.stdin.readline())
def MI(): return 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 S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**5+10)
#input = sys.stdin.readline
from bisect import bisect_left
def dfs(i,before):
global seq
global ans
added = 0
#現在地のAの値を、以前までのseqリストのどこに追加するか決める
pos = bisect_left(seq,a[i-1])
old = seq[pos]
seq[pos]=a[i-1]
ans[i-1]=bisect_left(seq,INF)
#隣接する頂点に関して再帰
for u in to[i]:
if u==before:
continue
dfs(u,i)
#seq配列をもとに戻す
seq[pos]=old
N = I()
a = LI()
to = [[] for i in range(N+1)]
to[0] += [1]
for i in range(N-1):
u,v = MI()
to[u].append(v)
to[v].append(u)
seq = [INF]*N
ans = [-1]*N
dfs(1,-1)
[print(i) for i in ans]
| import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): return int(sys.stdin.readline())
def MI(): return 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 S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)
#'0.01'や'1E1'などで指定、整数に戻すならintをかます
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**6+10)
#input = sys.stdin.readline
from bisect import bisect_left
def dfs(i,before):
global seq
global ans
added = 0
#現在地のAの値を、以前までのseqリストのどこに追加するか決める
pos = bisect_left(seq,a[i-1])
old = seq[pos]
seq[pos]=a[i-1]
ans[i-1]=bisect_left(seq,INF)
#隣接する頂点に関して再帰
for u in to[i]:
if u==before:
continue
dfs(u,i)
#seq配列をもとに戻す
seq[pos]=old
N = I()
a = LI()
to = [[] for i in range(N+1)]
to[0] += [1]
for i in range(N-1):
u,v = MI()
to[u].append(v)
to[v].append(u)
seq = [INF]*N
ans = [-1]*N
dfs(1,-1)
[print(i) for i in ans]
| p02698 |
#!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = list(map(int, input().split()))
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
dp = [ float('inf') ] * n
def getmlen(cur, p, ctail):
idx = bisect_left(dp, a[cur])
ov = dp[idx]
if ctail < idx:
ctail = idx
dp[idx] = a[cur]
mlen[cur] = ctail + 1
for ch in nbs[cur]:
if ch == p:
continue
getmlen(ch, cur, ctail)
dp[idx] = ov
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| #!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = list(map(int, input().split()))
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
dp = [ float('inf') ] * n
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| p02698 |
#!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = list(map(int, input().split()))
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
dp = [ float('inf') ] * n
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
from bisect import bisect_left
N = int(eval(input()))
a = [int(i) for i in input().split()]
vec = [[] for _ in range(N)]
for _ in range(N - 1) :
u, v = list(map(int, input().split()))
vec[u - 1].append(v - 1)
vec[v - 1].append(u - 1)
lis = [a[0]]
ret = [0] * N
def dfs(cur, pre) :
for nex in vec[cur] :
if nex == pre : continue
if a[nex] > lis[-1] :
lis.append(a[nex])
ret[nex] = len(lis)
dfs(nex, cur)
lis.pop()
else :
pos = bisect_left(lis, a[nex])
v = lis[pos]
lis[pos] = a[nex]
ret[nex] = len(lis)
dfs(nex, cur)
lis[pos] = v
dfs(0, -1)
ret[0] = 1
for i in range(N) :
print((ret[i])) | p02698 |
#!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = {}
dp = [ float('inf') for i in range(n) ]
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| #!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 for i in range(n) ]
dp = [ float('inf') for i in range(n) ]
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| p02698 |
#!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 for i in range(n) ]
dp = [ float('inf') for i in range(n) ]
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| #!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
dp = [ float('inf') ] * n
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| p02698 |
#!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
dp = [ float('inf') ] * n
def getmlen(cur, p, ctail):
for ch in nbs[cur]:
if ch == p:
continue
idx = bisect_left(dp, a[ch])
ov = dp[idx]
ntail = max(ctail, idx)
dp[idx] = a[ch]
mlen[ch] = ntail + 1
getmlen(ch, cur, ntail)
dp[idx] = ov
dp[0] = a[0]
mlen[0] = 1
getmlen(0, -1, 0)
for i in range(n):
print((mlen[i]))
| #!/usr/bin/python3
import sys
from bisect import bisect_left
sys.setrecursionlimit(1000000)
n = int(eval(input()))
a = [int(i) for i in input().split()]
nbs = [ [] for _ in range(n) ]
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
nbs[u - 1].append(v - 1)
nbs[v - 1].append(u - 1)
mlen = [ 0 ] * n
def getmlen(cur, p):
for ch in nbs[cur]:
if ch == p:
continue
if a[ch] > dp[-1]:
dp.append(a[ch])
mlen[ch] = len(dp)
getmlen(ch, cur)
dp.pop(-1)
else:
idx = bisect_left(dp, a[ch])
ov = dp[idx]
dp[idx] = a[ch]
mlen[ch] = len(dp)
getmlen(ch, cur)
dp[idx] = ov
dp = []
dp.append(a[0])
mlen[0] = 1
getmlen(0, -1)
for i in range(n):
print((mlen[i]))
| p02698 |
from bisect import bisect_left
import sys
sys.setrecursionlimit(10 ** 7)
N = int(input())
A = list(map(int, input().split()))
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to = map(lambda a: int(a) - 1, input().split())
edges[fr].append(to)
edges[to].append(fr)
ans = [0] * N
L = [-10**18]
def search(now, pr):
a = A[now]
i = bisect_left(L, a)
isAppended = False
prevValue = -1
if i == len(L):
L.append(a)
isAppended = True
else:
prevValue = L[i]
if L[i] > a:
L[i] = a
ans[now] = len(L) - 1
for to in edges[now]:
if to == pr:
continue
search(to, now)
if isAppended:
L.pop()
else:
L[i] = prevValue
search(0, -1)
print(*ans, sep='\n')
| from bisect import bisect_left
N = int(input())
A = list(map(int, input().split()))
edges = [[] for _ in range(N + 1)]
for _ in range(N - 1):
fr, to = map(int, input().split())
edges[fr].append(to)
edges[to].append(fr)
order = []
parent = [-1] * (N + 1)
st = [1]
while st:
now = st.pop()
order.append(now)
if now > 0:
st.append(-now)
for to in edges[now]:
if to == parent[now]:
continue
st.append(to)
parent[to] = now
L = [-10**18]
ans = [-1] * (N + 1)
st = [(-1, -1)] * (N + 1)
for now in order:
if now < 0:
val, idx = st[-now]
if val == -1:
L.pop()
if val > 0:
L[idx] = val
continue
a = A[now - 1]
i = bisect_left(L, a)
if len(L) == i:
L.append(a)
else:
st[now] = (L[i], i)
if L[i] > a:
L[i] = a
ans[now] = len(L) - 1
print(*ans[1:], sep='\n')
| p02698 |
from bisect import bisect_left
N=int(input())
*A,=map(int,input().split())
G=[[] for _ in range(N)]
ab = [tuple(map(int,input().split())) for _ in range(N-1)]
for a,b in ab:
G[a-1].append(b-1)
G[b-1].append(a-1)
def bfs():
from collections import deque
dp = [[] for _ in range(N)]
dp[0] = [A[0]]
seen = [0]*N
todo = deque()
seen[0]=1
todo.append(0)
while todo:
a = todo.popleft()
for b in G[a]:
if seen[b] == 0:
idx = bisect_left(dp[a],A[b])
if idx == len(dp[a]): dp[b] = dp[a]+[A[b]]
else: dp[b] = [dp[a][i] if i != idx else A[b] for i in range(len(dp[a]))]
seen[b] = 1
todo.append(b)
return dp
dp = bfs()
print(*[len(dp[i]) for i in range(N)],sep="\n")
| from bisect import bisect_left
N=int(input())
*A,=map(int,input().split())
INF=10**20
G=[[] for _ in range(N)]
ab = [tuple(map(int,input().split())) for _ in range(N-1)]
for a,b in ab:
G[a-1].append(b-1)
G[b-1].append(a-1)
def dfs(a0):
seen =[0]*len(G)
todo = [~a0, a0]
while todo:
a = todo.pop()
if a >= 0:
seen[a] = 1
idx = bisect_left(lis,A[a])
his[a] = (idx,lis[idx])
lis[idx] = A[a]
dp[a] = bisect_left(lis,INF)
for b in G[a]:
if seen[b]: continue
todo.append(~b)
todo.append(b)
else:
idx,val = his[~a]
lis[idx] = val
return
lis = [INF]*N
dp = [0]*N
his = {}
dfs(0)
print(*dp,sep="\n")
| p02698 |
from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
# input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input()
log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| p02698 |
from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
log(n)
log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline().strip()
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
# log(n)
# log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
# log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| p02698 |
from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
# def input(): return sys.stdin.readline().strip()
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
# log(n)
# log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
#for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input().strip()
# log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| from bisect import bisect_left
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline().strip()
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
n = int(input())
A = [-INF] + get_nums_l()
# log(n)
# log(A)
edges = [ [] for _ in range(n+1) ]
for _ in range(n-1):
# for line in map(lambda s: s.strip(), sys.stdin.readlines()):
line = input()
# log(line)
u,v = map(int, line.split())
edges[u].append(v)
edges[v].append(u)
def dfs(dp, u, p=None):
# log(u)
# log(dp)
# dpの中でA[u]以上の値が入っている最小のindex
i = bisect_left(dp, A[u])
old = dp[i]
dp[i] = A[u]
# 有効値(INF以外)が入っている最大のindex
ans[u] = bisect_left(dp, INF) - 1
for v in edges[u]:
if v == p:
continue
dfs(dp, v, u)
# 巻き戻し
dp[i] = old
# ans[i] = ノード1からノードiへの経路中の最長増加部分列長
ans = [0] * (n+1)
# dp[i] = 最長増加部分列長がiの場合の末尾ノード値の最小
# dp[0]は使用しないので負の無限大を入れておく
dp = [INF] * (n+1)
dp[0] = -INF
dfs(dp, 1, None)
for i in range(1, n+1):
print(ans[i])
| p02698 |
import bisect
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = list(map(int, input().split()))
tree[u - 1].append(v - 1)
tree[v - 1].append(u - 1)
ans = [0] * n
visited = [0] * n
visited[0] = 1
def dfs(i, l):
s = a[i]
if len(l) == 0 or s > l[-1]:
l.append(s)
else:
l[bisect.bisect_left(l, s)] = s
ans[i] = len(l)
for ni in tree[i]:
if not visited[ni]:
visited[ni] = 1
dfs(ni, l[:])
dfs(0, [])
for i in ans:
print(i)
| import bisect
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
tree = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = list(map(int, input().split()))
tree[u - 1].append(v - 1)
tree[v - 1].append(u - 1)
ans = [0] * n
visited = [0] * n
visited[0] = 1
l = []
def dfs(i):
s = a[i]
pi = -1
pv = -1
if len(l) == 0 or s > l[-1]:
l.append(s)
else:
pi = bisect.bisect_left(l, s)
pv = l[pi]
l[pi] = s
ans[i] = len(l)
for ni in tree[i]:
if not visited[ni]:
visited[ni] = 1
dfs(ni)
if pi == -1:
l.pop()
else:
l[pi] = pv
dfs(0)
for i in ans:
print(i)
| p02698 |
from collections import deque
from bisect import bisect_left, bisect_right
n = int(eval(input()))
a = list(map(int, input().split()))
result = [-1 for _ in range(n)]
tree = [[] for _ in range(n)]
for _i in range(n-1):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
tree[u].append(v)
tree[v].append(u)
dp = [float('inf') for _i in range(n+1)]
q = [[0, dp]]
q = deque(q)
while q:
p, d = q.popleft()
i = bisect_left(d, a[p])
d[i] = a[p]
result[p] = bisect_left(d, float("inf")-1)
for i in tree[p]:
if result[i] < 0:
q.appendleft([i, d.copy()])
for i in result:
print(i) | from bisect import bisect_left
n = int(eval(input()))
a = list(map(int, input().split()))
result = [-1 for _ in range(n)]
tree = [[] for _ in range(n)]
for _i in range(n-1):
u, v = list(map(int, input().split()))
u, v = u-1, v-1
tree[u].append(v)
tree[v].append(u)
INF = float('inf')
dp = [INF for _i in range(n+1)]
def dfs(p, d, x):
i = bisect_left(d, a[p])
d[i] = a[p]
result[p] = bisect_left(d, INF)
for j in tree[p]:
if j != x:
dfs(j, d.copy(), p)
dfs(0, dp, -1)
for i in result:
print(i) | p02698 |
import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#l=deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
#dequeを使うときはpython3を使う、pypyはダメ
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
#mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#start 4:00
N = int(input())
#N, K = map(int, input().split())
#L = [int(input()) for i in range(N)]
#A = list(map(int, input().split()))
#S = [list(map(int, input().split())) for i in range(N)]
A = list(map(int, input().split()))
edge = [[] for i in range(N)]
for i in range(N-1):
x,y = map(int,input().split())
edge[x-1].append(y-1)
edge[y-1].append(x-1)
#始点sから各頂点への最短距離
d = [[] for i in range(N)]
visited=[False]*N
q=[0]
q=deque(q)
d[0]=[0]
while len(q):
cp=q.pop()
a=A[cp]
#print(cp)
dp=d[cp]
visited[cp]=True
if a>dp[-1]:
dp.append(a)
for i in reversed(range(1,len(dp))):
if dp[i-1]<a:
dp[i]=min(a,dp[i])
d[cp]=dp
for e in edge[cp]:
if visited[e]==False:
d[e]=dp.copy()
q.appendleft(e)
#print(d)
for dc in d:
print(len(dc)-1)
#print(d[4])
| import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#l=deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
#dequeを使うときはpython3を使う、pypyはダメ
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
#mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#start 4:00
N = int(input())
#N, K = map(int, input().split())
#L = [int(input()) for i in range(N)]
#A = list(map(int, input().split()))
#S = [list(map(int, input().split())) for i in range(N)]
A = list(map(int, input().split()))
edge = [[] for i in range(N)]
for i in range(N-1):
x,y = map(int,input().split())
edge[x-1].append(y-1)
edge[y-1].append(x-1)
#始点sから各頂点への最短距離
inf=10**10
dp = [inf]*N
visited=[False]*N
q=[]
q=deque(q)
ans=[0]*N
def dfs(e):
visited[e]=True
a=A[e]
ci=bisect_left(dp,a)
q.append((ci,dp[ci]))
dp[ci]=a
ans[e]=bisect_left(dp,inf)
#print(edge[e])
for ne in edge[e]:
if not visited[ne]:
dfs(ne)
pi,px=q.pop()
dp[pi]=px
dfs(0)
#print(d)
for x in ans:
print(x)
#print(d[4])
| p02698 |
n = int(eval(input()))
a = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(n - 1)]
import sys
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
g = defaultdict(list)
for i in range(n - 1):
u = uv[i][0] - 1
v = uv[i][1] - 1
g[u].append(v)
g[v].append(u)
from bisect import bisect_left
ans = [0] * n
visited = [0] * n
def dfs(cur, dp):
visited[cur] = 1
idx = bisect_left(dp, a[cur])
#print(cur, dp, idx)
dp_new = dp.copy()
if idx == len(dp_new):
dp_new.append(a[cur])
else:
dp_new[idx] = a[cur]
ans[cur] = len(dp_new)
for target in g[cur]:
if visited[target] == 0:
dfs(target, dp_new)
dfs(0, [])
for _ans in ans:
print(_ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(n - 1)]
from collections import defaultdict
g = defaultdict(list)
for i in range(n - 1):
u = uv[i][0] - 1
v = uv[i][1] - 1
g[u].append(v)
g[v].append(u)
from bisect import bisect_left
ans = [0] * n
visited = [0] * n
from collections import deque
q = deque([(0, [])])
visited[0] = 1
while q:
cur, dp = q.popleft()
idx = bisect_left(dp, a[cur])
dp_new = dp.copy()
if idx == len(dp_new):
dp_new.append(a[cur])
else:
dp_new[idx] = a[cur]
ans[cur] = len(dp_new)
for target in g[cur]:
if visited[target] == 0:
visited[target] = 1
q.append((target, dp_new))
for _ans in ans:
print(_ans)
| p02698 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
A = LI()
G = [[] for _ in range(N)]
dp = [inf for _ in range(N)]
ans = [0] * N
for i in range(N-1):
a, b = LI_()
G[a].append(b)
G[b].append(a)
def update_dp(i):
j = bisect.bisect_left(dp, A[i])
before_val = dp[j]
dp[j] = A[i]
return j, before_val
visited = set()
def dfs(v):
visited.add(v)
changed_i, before_val = update_dp(v)
ans[v] = bisect.bisect_left(dp, inf)
for next_v in G[v]:
if next_v in visited:
continue
dfs(next_v)
# restore dp
dp[changed_i] = before_val
dfs(0)
for a in ans:
print(a)
main()
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
A = LI()
G = [[] for _ in range(N)]
dp = [inf for _ in range(N)]
ans = [0] * N
for i in range(N-1):
a, b = LI_()
G[a].append(b)
G[b].append(a)
def update_dp(i):
j = bisect.bisect_left(dp, A[i])
before_val = dp[j]
dp[j] = A[i]
return j, before_val
visited = set()
def dfs(v):
visited.add(v)
j = bisect.bisect_left(dp, A[v])
before_val = dp[j]
dp[j] = A[v]
ans[v] = bisect.bisect_left(dp, inf)
for next_v in G[v]:
if next_v in visited:
continue
dfs(next_v)
# restore dp
dp[j] = before_val
dfs(0)
for a in ans:
print(a)
main()
| p02698 |
import sys
from copy import copy
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
n = int(input())
a = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
graph[u].append(v)
graph[v].append(u)
ans = [0] * n
def dfs(v, v_p, dp):
# print(v, v_p, dp)
ans[v] = len(dp)
for v_next in graph[v]:
if v_next == v_p:
continue
# print(dp)
dp2 = copy(dp)
if a[v_next] > dp2[-1]:
dp2.append(a[v_next])
dfs(v_next, v, dp2)
dp2 = dp2[:len(dp2) - 1]
else:
idx = bisect_left(dp2, a[v_next])
past = dp2[idx]
dp2[idx] = a[v_next]
dfs(v_next, v, dp2)
dp2[idx] = past
dfs(0, -1, [a[0]])
print(*ans, sep='\n')
| import sys
from copy import copy
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
n = int(input())
a = list(map(int, input().split()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
graph[u].append(v)
graph[v].append(u)
ans = [0] * n
dp = [float('inf')] * n
dp[0] = a[0]
def dfs(v, v_p, dp_len):
# print(v, v_p, dp)
ans[v] = dp_len
for v_next in graph[v]:
if v_next == v_p:
continue
# print(dp)
if a[v_next] > dp[dp_len - 1]:
past = dp[dp_len]
dp[dp_len] = a[v_next]
dfs(v_next, v, dp_len + 1)
dp[dp_len] = past
else:
idx = bisect_left(dp, a[v_next])
# always idx < dp_len
past = dp[idx]
dp[idx] = a[v_next]
dfs(v_next, v, dp_len)
dp[idx] = past
dfs(0, -1, 1)
print(*ans, sep='\n')
| p02698 |
def main():
from bisect import bisect_left
from collections import deque
import sys
input = sys.stdin.readline
inf = 1 << 30
N = int(input())
*a, = map(int, input().split())
g = tuple(set() for _ in range(N))
for _ in range(N - 1):
u, v = (int(x) - 1 for x in input().split())
g[u].add(v)
g[v].add(u)
ans = [0] * N
lis = [None for _ in range(N)]
lis[0] = [inf] * N
dq = deque([0])
while dq:
v = dq.popleft()
if ans[v]: continue
i = bisect_left(lis[v], a[v])
lis[v][i] = a[v]
ans[v] = bisect_left(lis[v], inf)
for u in g[v]:
if ans[u]: continue
dq.append(u)
lis[u] = lis[v].copy()
print(*ans, sep='\n')
if __name__ == '__main__':
main()
# dp[i]=長さiの増加部分列の末尾としてありえる最小値
# というテーブルを持っておいて、数列を列を前から見ながら二分探索で更新箇所を探す
| def main():
from bisect import bisect_left
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
inf = 1 << 30
N = int(input())
*a, = map(int, input().split())
g = tuple(set() for _ in range(N))
for _ in range(N - 1):
u, v = (int(x) - 1 for x in input().split())
g[u].add(v)
g[v].add(u)
ans = [0] * N
lis = [inf] * N
lis[0] = a[0]
def dfs(v, p=-1):
ans[v] = bisect_left(lis, inf)
for u in g[v]:
if p == u: continue
i = bisect_left(lis, a[u])
prev_at_i = lis[i]
lis[i] = a[u]
dfs(u, v)
lis[i] = prev_at_i
dfs(0)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
# dp[i]=長さiの増加部分列の末尾としてありえる最小値
# というテーブルを持っておいて、数列を列を前から見ながら二分探索で更新箇所を探す
| p02698 |
n=int(eval(input()))
a=list(map(int,input().split()))
g = [[]for _ in range(n)]
for i in range(n-1):
u,v=list(map(int,input().split()))
g[u-1].append(v-1)
g[v-1].append(u-1)
import copy
import queue
import bisect
check = [False]*n
check[0] = True
li = [a[0]]
q= queue.Queue()
q.put([0,li])
ans = [0]*n
ans[0] = 1
while not q.empty():
now,lisOrigin= q.get()
for ne in g[now]:
if check[ne]:
continue
check[ne] = True
lis = copy.deepcopy(lisOrigin)
if a[ne] > lis[-1]:
lis.append(a[ne])
else:
lis[bisect.bisect_left(lis,a[ne])] = a[ne]
q.put([ne,lis])
ans[ne] = len(lis)
for i in range(n):
print((ans[i])) | from bisect import bisect_left
import sys
sys.setrecursionlimit(10**6)
n=int(eval(input()))
a=list(map(int,input().split()))
g = [[]for _ in range(n)]
for i in range(n-1):
u,v=list(map(int,input().split()))
g[u-1].append(v-1)
g[v-1].append(u-1)
lis = [float('inf')]*n
ans = [0]*n
def dfs(now, pre):
idx = bisect_left(lis, a[now])
tmp = lis[idx]
lis[idx] = a[now]
ans[now] = bisect_left(lis, float('inf'))
for to in g[now]:
if to == pre:
continue
dfs(to, now)
lis[idx] = tmp
dfs(0,-1)
for x in ans:
print(x) | p02698 |
import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
aa = {}
j = 0
for i in [int(i) for i in input().split()]:
if i in aa:
aa[i].append(j)
else:
aa[i] = [j]
j += 1
a = [0] * n
k = 1
for i in sorted(list(aa)):
for j in aa[i]:
a[j] = k
k += 1
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(list(range(self.n - 1))):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r):
l += self.n
r += self.n
s = self.one
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.b[r - 1])
if l & 1:
s = self.func(s, self.b[r - 1])
l += 1
l >>= 1
r >>= 1
return s
e = [[] for _ in range(n)]
for _ in range(n - 1):
aa, bb = [int(i) - 1 for i in input().split()]
e[aa].append(bb)
e[bb].append(aa)
seg = SegmentTree([0] * (max(a)+10), max, 0)
ans1 = [0] * n
ans1[0] = 1
ans2 = [0] * n
ans2[0] = 1
def dfs(i=0, r=-1):
y = seg.get_segment(0, a[i])
ans1[i] = y + 1
ans2[i] = max(ans2[r], ans1[i])
be = seg.get_item(a[i])
seg.update_func(a[i], ans1[i])
for j in e[i]:
if j == r:
continue
dfs(j, i)
seg.update(a[i], be)
dfs()
print(("\n".join(map(str,(ans2)))))
| import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
aa = {}
for j,i in enumerate(map(int,input().split())):
if i in aa:
aa[i].append(j)
else:
aa[i] = [j]
a = [0] * n
for k,i in enumerate(sorted(list(aa))):
for j in aa[i]:
a[j] = k+1
class SegmentTree:
def __init__(self, a, func=max, one=-10 ** 18):
self.logn = (len(a) - 1).bit_length()
self.n = 1 << self.logn
self.func = func
self.one = one
self.b = [self.one] * (2 * self.n - 1)
for i, j in enumerate(a):
self.b[i + self.n - 1] = j
for i in reversed(list(range(self.n - 1))):
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_item(self, i):
return self.b[i + self.n - 1]
def update(self, index, x):
i = index + self.n - 1
self.b[i] = x
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def update_func(self, index, x):
i = index + self.n - 1
self.b[i] = self.func(self.b[i], x)
while i != 0:
i = (i - 1) // 2
self.b[i] = self.func(self.b[i * 2 + 1], self.b[i * 2 + 2])
def get_segment(self, l, r):
l += self.n
r += self.n
s = self.one
while l < r:
if r & 1:
r -= 1
s = self.func(s, self.b[r - 1])
if l & 1:
s = self.func(s, self.b[r - 1])
l += 1
l >>= 1
r >>= 1
return s
e = [[] for _ in range(n)]
for _ in range(n - 1):
aa, bb = [int(i) - 1 for i in input().split()]
e[aa].append(bb)
e[bb].append(aa)
seg = SegmentTree([0] * (max(a)+2), max, 0)
ans1 = [0] * n
ans1[0] = 1
ans2 = [0] * n
ans2[0] = 1
def dfs(i=0, r=-1):
y = seg.get_segment(0, a[i])
ans1[i] = y + 1
ans2[i] = max(ans2[r], ans1[i])
be = seg.get_item(a[i])
seg.update_func(a[i], ans1[i])
for j in e[i]:
if j == r:
continue
dfs(j, i)
seg.update(a[i], be)
dfs()
print(("\n".join(map(str,(ans2)))))
| p02698 |
import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
aa = [int(i) for i in input().split()]
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(i) - 1 for i in input().split()]
e[a].append(b)
e[b].append(a)
dp = [10 ** 18] * (n + 10)
dp[0] = 0
ans1 = [0] * n
ans2 = [0] * n
def dfs(i=0, r=-1):
global dp, ans1, ans2
mi = 0
ma = n
while mi != ma:
mm = (mi + ma) // 2
if dp[mm] >= aa[i]:
ma = mm
else:
mi = mm + 1
be = dp[mi]
dp[mi] = min(dp[mi], aa[i])
ans1[i] = mi
ans2[i] = max(ans1[i], ans2[r])
for j in e[i]:
if j == r:
continue
dfs(j, i)
dp[mi] = be
dfs()
for i in ans2:
print(i)
| import sys
sys.setrecursionlimit(1000000)
def input():
return sys.stdin.readline()
n = int(eval(input()))
aa = [int(i) for i in input().split()]
e = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(i) - 1 for i in input().split()]
e[a].append(b)
e[b].append(a)
dp = [10 ** 9] * (n + 10)
dp[0] = 0
ans1 = [0] * n
ans2 = [0] * n
def dfs(i=0, r=-1):
global dp, ans1, ans2
mi = 0
ma = n
while mi != ma:
mm = (mi + ma) // 2
if dp[mm] >= aa[i]:
ma = mm
else:
mi = mm + 1
be = dp[mi]
dp[mi] = min(dp[mi], aa[i])
ans1[i] = mi
ans2[i] = max(ans1[i], ans2[r])
for j in e[i]:
if j == r:
continue
dfs(j, i)
dp[mi] = be
dfs()
print(("\n".join(map(str, ans2))))
| p02698 |
from bisect import bisect_left as bl
import sys
sys.setrecursionlimit(10**6)
n=int(eval(input()))
a=list(map(int,input().split()))
t=[[]for i in range(n)]
for i in range(n-1):
u,v=list(map(int,input().split()))
t[u-1].append(v-1)
t[v-1].append(u-1)
b=[0]*n
dp=[float("inf")]*n
def f(c,d,dp):
h=bl(dp,a[c])
q=dp[::]
q[h]=a[c]
b[c]=bl(q,float("INF"))
for i in t[c]:
if i!=d:f(i,c,q)
f(0,-1,dp)
for i in b:
print(i) | from bisect import bisect_left as bl
import sys
sys.setrecursionlimit(10**6)
n=int(eval(input()))
a=list(map(int,input().split()))
t=[[]for i in range(n)]
for i in range(n-1):
u,v=list(map(int,input().split()))
t[u-1].append(v-1)
t[v-1].append(u-1)
b=[0]*n
dp=[float("inf")]*n
def f(c,d):
h=bl(dp,a[c])
g=dp[h]
dp[h]=min(dp[h],a[c])
b[c]=bl(dp,float("INF"))
for i in t[c]:
if i!=d:f(i,c)
dp[h]=g
f(0,-1)
for i in b:
print(i)
| p02698 |
import sys
sys.setrecursionlimit(10**8)
from bisect import bisect_left, bisect_right
from copy import copy, deepcopy
N = int(input())
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(v,LIS):
if len(edge[v])==0:
return
for u in edge[v]:
if visited[u]==False:
visited[u]=True
lis = copy(LIS)
if A[u] > lis[-1]:
lis.append(A[u])
else:
ind = bisect_left(LIS,A[u])
lis[ind] = A[u]
ans[u] = len(lis)
dfs(u,lis)
return
ans = [0]*N
visited = [False]*N
visited[0]=True
LIS = [A[0]]
ans[0] = 1
dfs(0,LIS)
print(*ans, sep='\n')
| import sys
sys.setrecursionlimit(10**8)
from bisect import bisect_left, bisect_right
N = int(input())
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = map(int, input().split())
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(v,LIS):
if len(edge[v])==0:
return
for u in edge[v]:
if visited[u]==False:
visited[u]=True
if A[u] > LIS[-1]:
LIS.append(A[u])
ans[u] = len(LIS)
dfs(u,LIS)
LIS.pop()
else:
ind = bisect_left(LIS,A[u])
stack = LIS[ind]
LIS[ind] = A[u]
ans[u] = len(LIS)
dfs(u,LIS)
LIS[ind] = stack
return
ans = [0]*N
visited = [False]*N
visited[0]=True
LIS = [A[0]]
ans[0] = 1
dfs(0,LIS)
print(*ans, sep='\n')
| p02698 |
import sys
sys.setrecursionlimit(10**7)
import sys
input = sys.stdin.readline
n = int(eval(input()))
al = list(map(int,input().split()))
from collections import defaultdict
G = defaultdict(list)
for _ in range(n-1):
u,v = list(map(int,input().split()))
G[u-1].append(v-1)
G[v-1].append(u-1)
from bisect import bisect
ansl = [0 for i in range(n)]
dp = [float("inf") for _ in range(n+1)]
dp[0] = -1
used = [0 for i in range(n)]
used[0] = 1
stack = []
def dfs(pos):
idx = bisect(dp, al[pos] - 1)
stack.append((idx, dp[idx]))
dp[idx] = min(al[pos], dp[idx])
ansl[pos] = bisect(dp, 10**18) - 1
for i in range(n):
if dp[i] == "inf":
ansl[pos] = i
break
for v in G[pos]:
if used[v] == 0:
used[v] = 1
dfs(v)
idx, k = stack.pop()
dp[idx] = k
dfs(0)
flag = False
for i in range(n):
print((ansl[i]))
| import sys
sys.setrecursionlimit(10**7)
import sys
input = sys.stdin.readline
n = int(eval(input()))
al = list(map(int,input().split()))
from collections import defaultdict
G = defaultdict(list)
for _ in range(n-1):
u,v = list(map(int,input().split()))
G[u-1].append(v-1)
G[v-1].append(u-1)
from bisect import bisect
ansl = [0 for i in range(n)]
dp = [float("inf") for _ in range(n+1)]
dp[0] = -1
used = [0 for i in range(n)]
used[0] = 1
stack = []
def dfs(pos):
idx = bisect(dp, al[pos] - 1)
stack.append((idx, dp[idx]))
dp[idx] = min(al[pos], dp[idx])
ansl[pos] = bisect(dp, 10**18) - 1
for v in G[pos]:
if used[v] == 0:
used[v] = 1
dfs(v)
idx, k = stack.pop()
dp[idx] = k
dfs(0)
flag = False
for i in range(n):
print((ansl[i]))
| p02698 |
# -*- coding: utf-8 -*-
import sys
from bisect import bisect_left,bisect_right
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
N=int(input())
a=list(map(int,input().split()))
edge=[[] for _ in range(N)]
for _ in range(N-1):
x,y=map(int1,input().split())
edge[x].append(y)
edge[y].append(x)
stack=[(0,1)]
used=[False]*N
ans=[0]*N
dpdp=[[0]+[INF]*(N+10)]
prev_l=1
while stack:
v,l=stack.pop()
used[v]=True
for _ in range(prev_l-l):
dpdp.pop()
prev_l=l
dp=dpdp[-1][:]
dp[bisect_right(dp,a[v]-1,hi=l)]=a[v]
ans[v]=bisect_left(dp,INF,hi=l+1)-1
f=True
for nv in edge[v]:
if not used[nv]:
if f:
dpdp.append(dp)
f=False
stack.append((nv,l+1))
for a in ans:
print(a)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
from bisect import bisect_left,bisect_right
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
N=int(input())
a=list(map(int,input().split()))
edge=[[] for _ in range(N)]
for _ in range(N-1):
x,y=map(int1,input().split())
edge[x].append(y)
edge[y].append(x)
stack=[(0,1)]
used=[False]*N
ans=[0]*N
dp=[INF]*(N+1)
dp[0]=0
dpdp=[]
prev_l=1
def dfs(v,l):
used[v]=True
index=bisect_right(dp,a[v]-1,hi=l)
dpdp=(index,dp[index])
dp[index]=a[v]
ans[v]=bisect_left(dp,INF,hi=l+1)-1
for nv in edge[v]:
if not used[nv]:
i,x=dfs(nv,l+1)
dp[i]=x
return dpdp
dfs(0,1)
for a in ans:
print(a)
if __name__ == '__main__':
main()
| p02698 |
import sys
import bisect
from collections import deque
sys.setrecursionlimit(4100000)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
edge[u].append(v)
edge[v].append(u)
dp = [[] for _ in range(N)]
B = [[] for _ in range(N)]
dist = [-1]*N
dist[0] = 0
dp[0] = [A[0]]
B[0] = [A[0]]
queue = deque([0])
while queue:
now = queue.popleft()
d = dist[now]
for i in edge[now]:
if dist[i] > -1:
continue
dist[i] = d + 1
queue.append(i)
dp[i] += dp[now]
if A[i] > dp[i][-1]:
dp[i].append(A[i])
else:
dp[i][bisect.bisect_left(dp[i], A[i])] = A[i]
for i in range(N):
print((len(dp[i])))
if __name__ == "__main__":
main() | import sys
import bisect
from collections import deque
sys.setrecursionlimit(4100000)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
edge[u].append(v)
edge[v].append(u)
LIS = [A[0]]
dist = [-1]*N
dist[0] = 0
ans = [0] * N
ans[0] = 1
queue = deque()
queue.append((0,LIS))
while queue:
now, LIS_tmp = queue.popleft()
d = dist[now]
for i in edge[now]:
tmp = LIS_tmp[:]
if dist[i] > -1:
continue
dist[i] = d + 1
if A[i] > tmp[-1]:
tmp.append(A[i])
else:
tmp[bisect.bisect_left(tmp, A[i])] = A[i]
queue.append((i,tmp))
ans[i] = len(tmp)
for i in range(N):
print((ans[i]))
if __name__ == "__main__":
main() | p02698 |
import sys
import bisect
from collections import deque
sys.setrecursionlimit(4100000)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
edge[u].append(v)
edge[v].append(u)
LIS = [A[0]]
dist = [-1]*N
dist[0] = 0
ans = [0] * N
ans[0] = 1
queue = deque()
queue_append = queue.append
queue_append((0,LIS))
while queue:
now, LIS_tmp = queue.popleft()
d = dist[now]
for i in edge[now]:
tmp = LIS_tmp[:]
tmp_append = tmp.append
A_now = A[i]
if dist[i] > -1:
continue
dist[i] = d + 1
if A_now > tmp[-1]:
tmp_append(A_now)
else:
tmp[bisect.bisect_left(tmp, A_now)] = A_now
queue_append((i,tmp))
ans[i] = len(tmp)
for i in range(N):
print((ans[i]))
if __name__ == "__main__":
main() | import sys
import bisect
from collections import deque
sys.setrecursionlimit(4100000)
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
edge = [[] for _ in range(N)]
for i in range(N-1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
edge[u].append(v)
edge[v].append(u)
ans = [0] * (N + 1)
LIS = [-1]
def dfs(v, p = N):
if A[v] > LIS[-1]:
LIS.append(A[v])
ans[v] = ans[p] + 1
for u in edge[v]:
if u == p:
continue
dfs(u,v)
LIS.pop()
else:
ans[v] = ans[p]
idx = bisect.bisect_left(LIS, A[v])
old = LIS[idx]
LIS[idx] = A[v]
for u in edge[v]:
if u == p:
continue
dfs(u,v)
LIS[idx] = old
dfs(0)
for i in range(N):
print((ans[i]))
if __name__ == "__main__":
main() | p02698 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
N = int(eval(input()))
As = list(map(int, input().split()))
query = (list(map(int, readline().strip().split())) for _ in range(N-1))
tree = [[] for _ in range(N)]
for u, v in query:
tree[u-1].append(v-1)
tree[v-1].append(u-1)
inf = 10 ** 9 + 7
dp = [inf] * (N+1)
ans = [0] * N
def dfs(node, parent):
v = As[node]
lb = binary_search(dp, v)
old = dp[lb]
dp[lb] = v
ans[node] = dp.index(inf)
for child in tree[node]:
if child == parent:
continue
dfs(child, node)
dp[lb] = old
dfs(0, 0)
for k in range(N):
print((ans[k]))
def binary_search(seq, v):
left = 0
right = len(seq) - 1
center = right // 2
while left != right:
if v <= seq[center]:
right = center
else:
left = center+1
center = (right + left) // 2
return center
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
N = int(eval(input()))
As = list(map(int, input().split()))
query = (list(map(int, readline().strip().split())) for _ in range(N-1))
tree = [[] for _ in range(N)]
for u, v in query:
tree[u-1].append(v-1)
tree[v-1].append(u-1)
inf = 10 ** 18
dp = [inf] * (N+1)
ans = [0] * N
def dfs(node, parent):
v = As[node]
lb = binary_search(dp, v)
old = dp[lb]
dp[lb] = v
ans[node] = binary_search(dp, inf)
for child in tree[node]:
if child == parent:
continue
dfs(child, node)
dp[lb] = old
dfs(0, 0)
for k in range(N):
print((ans[k]))
def binary_search(seq, v):
left = 0
right = len(seq) - 1
center = right // 2
while left != right:
if v <= seq[center]:
right = center
else:
left = center+1
center = (right + left) // 2
return center
if __name__ == "__main__":
main()
| p02698 |
from collections import deque
import bisect
from copy import copy
n = int(input())
a = list(map(int, input().split()))
to=[list() for _ in range(n)]
for i in range(n-1):
u,v = map(int, input().split())
u-=1
v-=1
to[u].append(v)
to[v].append(u)
d= deque()
INF=10010001001
dpinit = [a[0]]
d.append((0,-1,copy(dpinit)))
ansls=[0]*n
ansls[0]=1
while d:
u,p,dp = d.popleft()
for v in to[u]:
if v==p:
continue
idx=bisect.bisect_left(dp,a[v])
if idx<len(dp):
prv=dp[idx]
dp[idx]=a[v]
else:
dp.append(a[v])
prv=-1
ansls[v]=len(dp)
d.append((v,u,copy(dp)))
if prv!=-1:
dp[idx]=prv
else:
dp.pop()
print(*ansls,sep='\n')
| from collections import deque
import bisect
import sys
sys.setrecursionlimit(500000)
n = int(input())
a = list(map(int, input().split()))
to=[list() for _ in range(n)]
for i in range(n-1):
u,v = map(int, input().split())
u-=1
v-=1
to[u].append(v)
to[v].append(u)
INF=1001001001
dp = [INF]*n
dp[0]=a[0]
ansls=[0]*n
ansls[0]=1
history=deque()
def dfs(u,p,rank):
for v in to[u]:
if v==p:
continue
idx=bisect.bisect_left(dp,a[v])
prv=dp[idx]
dp[idx]=a[v]
history.append((idx,prv))
ansls[v]=bisect.bisect_left(dp,INF)
dfs(v,u,rank+1)
while len(history)>rank:
idx,prv =history.pop()
dp[idx] = prv
dfs(0,-1,0)
print(*ansls,sep='\n')
| p02698 |
from collections import deque
import bisect
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(input())
graph = [[] for _ in range(n+1)]
A = [0]+list(map(int, input().split()))
for i in range(n-1):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
dist = [-1] * (n+1)
dist[0] = 0
dist[1] = 1
d = deque()
d.append((1, [0, A[1]]))
while d:
v, dp = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
if dp[-1] < A[i]:
dp.append(A[i])
d.append((i, dp.copy()))
dist[i] = len(dp)-1
dp.pop()
else:
bis = bisect.bisect_left(dp, A[i])
updatetask=dp[bis]
dp[bis] = A[i]
dist[i] = len(dp)-1
d.append((i, dp.copy()))
dp[bis]=updatetask
print(*dist[1:], sep="\n")
if __name__ == '__main__':
main()
| from collections import deque
import sys
import bisect
def input(): return sys.stdin.readline().rstrip()
n=int(input())
A=[0]+list(map(int, input().split()))
graph = [[] for _ in range(n+1)]
for i in range(n-1):
a, b = map(int, input().split())
graph[a].append(b)
graph[b].append(a)
visited = [-1] * (n+1)
visited[0] = 0
visited[1] = 1
d = deque()
d.append(1)
dp=[10**10]*(n+1)
dp[0]=0
dp[1]=A[1]
update_task=[() for _ in range(n+1)]
update_task[1]=(1,0)
while d:
v = d[-1]
if graph[v] == []:
d.pop()
index,atai=update_task[v]
dp[index]=atai
else:
i = graph[v].pop()
if visited[i] != -1:
continue
bis = bisect.bisect_left(dp, A[i])
update_task[i]=(bis,dp[bis])
dp[bis] = A[i]
visited[i] = bisect.bisect_left(dp, 10**10-100)-1
d.append(i)
print(*visited[1:], sep="\n")
| p02698 |
import bisect
import sys
N = int(eval(input()))
a = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
to[u].append(v)
to[v].append(u)
del u, v
ans = [-1] * N
def dfs(v, dp):
# dp は参照渡し
if len(dp) == 0 or a[v] > dp[-1]:
dp.append(a[v])
back = -1
else:
pos = bisect.bisect_left(dp, a[v])
back = dp[pos]
dp[pos] = a[v]
ans[v] = len(dp)
for u in to[v]:
if ans[u] == -1:
dfs(u, dp)
if back == -1:
dp.pop()
else:
dp[pos] = back
sys.setrecursionlimit(10 ** 6)
dfs(0, [])
for an in ans:
print(an)
| import bisect
import sys
N = int(eval(input()))
a = list(map(int, input().split()))
to = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
to[u].append(v)
to[v].append(u)
del u, v
def dfs(v):
if len(dp) == 0 or a[v] > dp[-1]:
dp.append(a[v])
pos = -1
else:
pos = bisect.bisect_left(dp, a[v])
back = dp[pos]
dp[pos] = a[v]
ans[v] = len(dp)
for u in to[v]:
if ans[u] == -1:
dfs(u)
if pos == -1:
dp.pop()
else:
dp[pos] = back
ans = [-1] * N
sys.setrecursionlimit(10 ** 6)
dp = []
dfs(0)
for an in ans:
print(an)
| p02698 |
#MLE注意！0や1のケースに注意
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
adj = [[] for _ in range(n)] #頂点数, 場合によって変える
for _ in range(n-1):
c,b = list(map(int, input().split()))
adj[c-1].append(b-1)
adj[b-1].append(c-1)
# 頂点1も含む
res = [0]*n
res[0] = 1
def dfs(v, par, L):
for nv in adj[v]:
temp = L[:]
if nv == par:
continue
if a[nv] > temp[-1]:
temp.append(a[nv])
else:
temp[bisect_left(temp, a[nv])] = a[nv]
res[nv] = len(temp)
dfs(nv, v, temp)
L = [a[0]]
dfs(0, -1, L)
for i in range(n):
print((res[i]))
if __name__ == '__main__':
main() | #MLE注意！0や1のケースに注意
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
adj = [[] for _ in range(n)] #頂点数, 場合によって変える
for _ in range(n-1):
c,b = list(map(int, input().split()))
adj[c-1].append(b-1)
adj[b-1].append(c-1)
# 頂点1も含む
res = [0]*n
res[0] = 1
def dfs(v, par, L):
if v != 0:
if a[v] > L[-1]:
temp = -1
L.append(a[v])
else:
temp = bisect_left(L, a[v])
pre = L[temp]
L[temp] = a[v]
res[v] = len(L)
for nv in adj[v]:
if nv == par:
continue
dfs(nv, v, L)
if v != 0:
if temp == -1:
L.pop(-1)
else:
L[temp] = pre
L = [a[0]]
dfs(0, -1, L)
for i in range(n):
print((res[i]))
if __name__ == '__main__':
main()
| p02698 |
import bisect
from collections import deque
import copy
N = int(eval(input()))
a_array = list(map(int, input().split()))
node_dic = {}
for _ in range(N - 1):
u, v = list(map(int, input().split()))
if u in node_dic:
node_dic[u].append(v)
else:
node_dic[u] = [v]
if v in node_dic:
node_dic[v].append(u)
else:
node_dic[v] = [u]
# print(node_dic)
use_array = [-1] * N
ans_array = [0] * N
edge_array = deque([(1, [0])])
use_array[0] = 1
while(len(edge_array)):
edge, arr = edge_array.popleft()
# print(edge, arr, ans_array)
insert = bisect.bisect_left(arr, a_array[edge - 1])
if insert == len(arr):
arr.append(a_array[edge - 1])
else:
arr[insert] = a_array[edge - 1]
ans_array[edge - 1] = len(arr) - 1
for next_edge in node_dic[edge]:
if use_array[next_edge - 1] == -1:
use_array[next_edge - 1] = 1
arr_next = copy.deepcopy(arr)
edge_array.append((next_edge, arr_next))
print(("\n".join(map(str, ans_array))))
| import sys
import bisect
def dfs(edge):
insert = bisect.bisect_left(lis_array, a_array[edge - 1])
old = lis_array[insert]
lis_array[insert] = a_array[edge - 1]
ans = bisect.bisect_left(lis_array, INF)
ans_array[edge - 1] = ans
for next_edge in node_dic[edge]:
if use_array[next_edge - 1] == -1:
use_array[next_edge - 1] = 1
dfs(next_edge)
lis_array[insert] = old
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
a_array = list(map(int, input().split()))
node_dic = {}
for _ in range(N - 1):
u, v = list(map(int, input().split()))
if u in node_dic:
node_dic[u].append(v)
else:
node_dic[u] = [v]
if v in node_dic:
node_dic[v].append(u)
else:
node_dic[v] = [u]
# print(node_dic)
use_array = [-1] * N
ans_array = [0] * N
INF = 2 * 10 ** 9
lis_array = [INF] * N
use_array[0] = 1
dfs(1)
print(("\n".join(map(str, ans_array))))
| p02698 |
import sys
sys.setrecursionlimit(10 ** 7)
from bisect import bisect_left
n = int(input())
a = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(n - 1)]
adj = [[] for _ in range(n)]
for u, v in uv:
u -= 1
v -= 1
adj[u].append(v)
adj[v].append(u)
arrived = [False] * n
ans = [None] * n
ans[0] = 1
def dfs(u, dp, l):
arrived[u] = True
for v in adj[u]:
if not arrived[v]:
idx = bisect_left(dp, a[v])
if idx == l:
dp_nxt = dp + [a[v]]
ans[v] = l + 1
dfs(v, dp_nxt, l + 1)
else:
dp_nxt = dp[:idx] + [min(a[v], dp[idx])] + dp[idx+1:]
ans[v] = l
dfs(v, dp_nxt, l)
dfs(0, [a[0]], 1)
print(*ans, sep="\n")
| import sys
sys.setrecursionlimit(10 ** 7)
from bisect import bisect_left
n = int(input())
a = list(map(int, input().split()))
uv = [list(map(int, input().split())) for _ in range(n - 1)]
INF = 10 ** 10
adj = [[] for _ in range(n)]
for u, v in uv:
u -= 1
v -= 1
adj[u].append(v)
adj[v].append(u)
arrived = [False] * n
ans = [None] * n
ans[0] = 1
dp = [INF] * n
def dfs(u):
arrived[u] = True
for v in adj[u]:
if not arrived[v]:
idx = bisect_left(dp, a[v])
tmp = dp[idx]
dp[idx] = a[v]
ans[v] = bisect_left(dp, INF - 1)
dfs(v)
dp[idx] = tmp
dp[0] = a[0]
dfs(0)
print(*ans, sep="\n")
| p02698 |
import bisect
import sys
sys.setrecursionlimit(10**9)
N = int(input())
A = list(map(int, input().split()))
tree = [[] for i in range(N)]
for i in range(N-1):
u, v = map(int, input().split())
tree[u-1].append(v-1); tree[v-1].append(u-1)
ans = [0] * N
ans[0] = 1
INF = 10**10
dp = [INF] * N
dp[0] = A[0]
stack = []
def dfs(node, par):
global ans
global dp
global stack
children = tree[node]
for child in children:
if child == par:
continue
num = A[child]
idx = bisect.bisect_left(dp, num)
stack.append([idx, dp[idx]])
dp[idx] = num
ans[child] = bisect.bisect_left(dp, INF)
dfs(child, node)
# 巻き戻し
idx, num = stack.pop()
dp[idx] = num
dfs(0, -1)
print(*ans, sep='\n')
| import bisect
import sys
sys.setrecursionlimit(10**9)
N = int(input())
A = list(map(int, input().split()))
tree = [[] for i in range(N)]
for i in range(N-1):
u, v = map(int, input().split())
tree[u-1].append(v-1); tree[v-1].append(u-1)
ans = [0] * N
ans[0] = 1
INF = 10**10
dp = [INF] * N
dp[0] = A[0]
stack = []
def dfs(node, par, n):
global ans
global dp
global stack
children = tree[node]
for child in children:
if child == par:
continue
num = A[child]
idx = bisect.bisect_left(dp, num)
stack.append([idx, dp[idx]])
dp[idx] = num
ans[child] = max(n, idx+1)
# ans[child] = bisect.bisect_left(dp, INF)
dfs(child, node, max(n, idx+1))
# 巻き戻し
idx, num = stack.pop()
dp[idx] = num
dfs(0, -1, 1)
print(*ans, sep='\n')
| p02698 |
import bisect
import sys
sys.setrecursionlimit(10**9)
N = int(input())
A = list(map(int, input().split()))
tree = [[] for i in range(N)]
for i in range(N-1):
u, v = map(int, input().split())
tree[u-1].append(v-1); tree[v-1].append(u-1)
ans = [0] * N
ans[0] = 1
INF = 10**10
dp = [INF] * N
dp[0] = A[0]
stack = []
n_stack = []
def dfs(node, par, n):
global ans
global dp
global stack
children = tree[node]
for child in children:
if child == par:
continue
num = A[child]
idx = bisect.bisect_left(dp, num)
stack.append([idx, dp[idx]])
n_stack.append(n)
dp[idx] = num
n = max(n, idx + 1)
ans[child] = n
dfs(child, node, n)
# 巻き戻し
idx, num = stack.pop()
dp[idx] = num
n = n_stack.pop()
dfs(0, -1, 1)
print(*ans, sep='\n')
| import bisect
import sys
sys.setrecursionlimit(10**9)
N = int(input())
A = list(map(int, input().split()))
tree = [[] for i in range(N)]
for i in range(N-1):
u, v = map(int, input().split())
tree[u-1].append(v-1); tree[v-1].append(u-1)
ans = [0] * N
ans[0] = 1
INF = 10**10
dp = [INF] * N
dp[0] = A[0]
def dfs(node, par, n):
global ans
global dp
children = tree[node]
for child in children:
if child == par:
continue
num = A[child]
idx = bisect.bisect_left(dp, num)
_idx, _num = idx, dp[idx] # 巻き戻し用に退避
dp[idx] = num
_n = max(n, idx + 1)
ans[child] = _n
dfs(child, node, _n)
# 巻き戻し
dp[_idx] = _num
dfs(0, -1, 1)
print(*ans, sep='\n')
| p02698 |
import sys, bisect, copy
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
p,q = list(map(int,input().split()))
p -= 1
q -= 1
g[p].append(q)
g[q].append(p)
dis = [10**10]*n
dis[0] = 0
que = deque()
que.append(0)
pr = [0 for _ in range(n)]
pr[0] = 1
ans = ['' for _ in range(n)]
ans[0] = [a[0]]
while que:
go = que.pop()
for i in range(len(g[go])):
if dis[g[go][i]] <= dis[go] + 1:
continue
lis = copy.copy(ans[go])
if a[g[go][i]] > lis[-1]:
lis.append(a[g[go][i]])
else:
lis[bisect.bisect_left(lis,a[g[go][i]])] = a[g[go][i]]
ans[g[go][i]] = lis
dis[g[go][i]] = dis[go] + 1
que.append(g[go][i])
for i in range(n):
print((len(ans[i])))
if __name__ == "__main__":
main() | import sys, bisect, copy
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
def main():
n = int(eval(input()))
a = list(map(int,input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
p,q = list(map(int,input().split()))
p -= 1
q -= 1
g[p].append(q)
g[q].append(p)
dis = [10**10]*n
dis[0] = 0
que = deque()
que.append(0)
pr = [0 for _ in range(n)]
pr[0] = 1
ans = ['' for _ in range(n)]
ans[0] = [a[0]]
while que:
go = que.pop()
for i in range(len(g[go])):
if dis[g[go][i]] <= dis[go] + 1:
continue
lis = [0 for _ in range(len(ans[go]))]
for j in range(len(ans[go])):
lis[j] = ans[go][j]
if a[g[go][i]] > lis[-1]:
lis.append(a[g[go][i]])
else:
lis[bisect.bisect_left(lis,a[g[go][i]])] = a[g[go][i]]
ans[g[go][i]] = lis
dis[g[go][i]] = dis[go] + 1
que.append(g[go][i])
for i in range(n):
print((len(ans[i])))
if __name__ == "__main__":
main() | p02698 |
class SegTree:
def __init__(self, init_val, n, ide_ele, seg_func):
self.segfunc = seg_func
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
# k+1ではなくkでは？
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
from collections import defaultdict
import sys;input=sys.stdin.readline
N, = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
G = [[] for _ in range(N+1)]
for v in range(N-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
iA = [(i, a) for i, a in enumerate(A)]
iA.sort(key=lambda x:x[1])
d = dict()
AA = [0]*(N+1)
a2f = [0]*(N+1)
rj = 0
for j, (i, a) in enumerate(iA):
AA[i] = j
if a not in d:
rj = j
a2f[i] = rj
d[a] = 1
#print(AA, a2f)
R = [0]*(N+1)
R[1] = 1
ss = SegTree([0]*(N+1), N+1, -1, max)
ss.update(AA[1], 1)
stack = []
for u in G[1]:
stack += [-1, u]
visited = set([1])
path = [1]
while stack:
v = stack.pop()
if v > 0:
visited.add(v)
path.append(v)
qq = ss.query(0, a2f[v])
ss.update(AA[v], qq+1)
R[v] = ss.query(0, N+1)
for u in G[v]:
if u in visited:
continue
stack += [-v, u]
else:
child = path.pop()
ss.update(AA[child], 0)
for i in range(1, N+1):
print((R[i]))
| class SegTree:
def __init__(self, init_val, n, ide_ele, seg_func):
self.segfunc = seg_func
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
# k+1ではなくkでは？
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
from collections import defaultdict
import sys;input=sys.stdin.readline
N, = list(map(int, input().split()))
A = [0] + list(map(int, input().split()))
G = [[] for _ in range(N+1)]
for v in range(N-1):
a, b = list(map(int, input().split()))
G[a].append(b)
G[b].append(a)
iA = [(i, a) for i, a in enumerate(A)]
iA.sort(key=lambda x:x[1])
d = dict()
AA = [0]*(N+1)
a2f = [0]*(N+1)
rj = 0
for j, (i, a) in enumerate(iA):
AA[i] = j
if a not in d:
rj = j
a2f[i] = rj
d[a] = 1
#print(AA, a2f)
R = [0]*(N+1)
R[1] = 1
ss = SegTree([0]*(N+1), N+1, -1, max)
ss.update(AA[1], 1)
stack = []
for u in G[1]:
stack += [-1, u]
visited = set([1])
path = [1]
while stack:
v = stack.pop()
if v > 0:
visited.add(v)
path.append(v)
qq = ss.query(0, a2f[v])
ss.update(AA[v], qq+1)
R[v] = ss.query(0, N+1)
for u in G[v]:
if u in visited:
continue
stack += [-v, u]
else:
c = path.pop()
ss.update(AA[c], 0)
for i in range(1, N+1):
print((R[i]))
| p02698 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
from bisect import bisect_left
INF = float("inf")
from collections import defaultdict
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, f, t, w=1):
self.E[f].append((t, w))
self.E[t].append((f, w))
def solve(N: int, a: "List[int]", u: "List[int]", v: "List[int]"):
g = Graph(N)
for x, y in zip(u, v):
g.add_edge(x-1, y-1)
ans = [0]*N
dp = [INF]*N
event = []
var = {"last": 0}
def dfs(curr, par):
i = bisect_left(dp, a[curr])
if dp[i] > a[curr]:
if dp[i] == INF:
var["last"] = i
event.append((curr, i, dp[i]))
dp[i] = a[curr]
ans[curr] = len(dp[:var["last"]+1])
for child, w in g.E[curr]:
if child == par:
continue
dfs(child, curr)
c, i, v = event[-1]
if c == curr:
dp[i] = v
if v == INF:
var["last"] = i-1
event.pop()
dfs(0, -1)
print(*ans, sep="\n")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
u = [int()] * (N - 1) # type: "List[int]"
v = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
u[i] = int(next(tokens))
v[i] = int(next(tokens))
solve(N, a, u, v)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
from bisect import bisect_left
INF = float("inf")
from collections import defaultdict
class Graph(object):
def __init__(self, N):
self.N = N
self.E = defaultdict(list)
def add_edge(self, f, t, w=1):
self.E[f].append((t, w))
self.E[t].append((f, w))
def solve(N: int, a: "List[int]", u: "List[int]", v: "List[int]"):
g = Graph(N)
for x, y in zip(u, v):
g.add_edge(x-1, y-1)
ans = [0]*N
dp = [INF]*N
event = []
var = {"last": 0}
def dfs(curr, par):
i = bisect_left(dp, a[curr])
if dp[i] > a[curr]:
if dp[i] == INF:
var["last"] = i
event.append((curr, i, dp[i]))
dp[i] = a[curr]
ans[curr] = var["last"]+1
for child, w in g.E[curr]:
if child == par:
continue
dfs(child, curr)
c, i, v = event[-1]
if c == curr:
dp[i] = v
if v == INF:
var["last"] = i-1
event.pop()
dfs(0, -1)
print(*ans, sep="\n")
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
u = [int()] * (N - 1) # type: "List[int]"
v = [int()] * (N - 1) # type: "List[int]"
for i in range(N - 1):
u[i] = int(next(tokens))
v[i] = int(next(tokens))
solve(N, a, u, v)
if __name__ == '__main__':
main()
| p02698 |
import bisect
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(input())
A = tuple(map(int, input().split()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = map(int, input().split())
edge[x].append(y)
edge[y].append(x)
ans = [-1] * (N + 1)
def DFS(s, LIS, parent=-1):
a = A[s - 1]
if not LIS or a > LIS[-1]:
LIS.append(a)
else:
i = bisect.bisect_left(LIS, a)
LIS[i] = a
ans[s] = len(LIS)
for t in edge[s]:
if t == parent:
continue
DFS(t, LIS[:], s)
return
DFS(1, [])
print(*ans[1:], sep="\n")
| import bisect
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)
N = int(input())
A = tuple(map(int, input().split()))
edge = [[] for _ in range(N + 1)]
for _ in range(N - 1):
x, y = map(int, input().split())
edge[x].append(y)
edge[y].append(x)
ans = [-1] * (N + 1)
inf = 10**18
LIS = [inf] * (N + 10)
def DFS(s, parent=0):
a = A[s - 1]
i = bisect.bisect_left(LIS, a)
v = LIS[i]
LIS[i] = a
ans[s] = bisect.bisect_left(LIS, inf)
for t in edge[s]:
if t == parent:
continue
DFS(t, s)
# 頂点sでの結果をもとに戻す
LIS[i] = v
return
DFS(1)
print(*ans[1:], sep="\n")
| p02698 |
import sys
from itertools import combinations
def solve(n, pairs):
survivors = {v: {v} for v in range(1, n + 1)}
for x, y in reversed(pairs):
for v, srv in list(survivors.copy().items()):
if x in srv:
if y in srv:
del survivors[v]
else:
srv.add(y)
elif y in srv:
srv.add(x)
return sum(su.isdisjoint(sv) for su, sv in combinations(list(survivors.values()), 2))
n, m = list(map(int, input().split()))
pairs = []
for line in sys.stdin.readlines():
x, y = list(map(int, line.split()))
pairs.append((x, y))
print((solve(n, pairs)))
| import sys
from itertools import combinations
def solve(n, pairs):
survivors = {v: {v} for v in range(1, n + 1)}
for x, y in reversed(pairs):
for v, srv in list(survivors.copy().items()):
if x in srv:
if y in srv:
del survivors[v]
else:
srv.add(y)
elif y in srv:
srv.add(x)
return sum(su.isdisjoint(sv) for su, sv in combinations(list(survivors.values()), 2))
n, m = list(map(int, input().split()))
pairs = [tuple(map(int, line.split())) for line in sys.stdin.readlines()]
print((solve(n, pairs)))
| p03691 |
ring = input() * 2
word = input()
if ring.find(word) != -1:
print("Yes")
else:
print("No") | ring = input() * 2
word = input()
if word in ring:
print("Yes")
else:
print("No") | p02418 |
s=input()
target=input()
ring=s*2
f=0
for i in range(len(s)):
if ring[i:i+len(target)]==target:
f=1
break
if f==1:
print("Yes")
else:
print("No") | s=input()
target=input()
ring=s*2
ans="No"
for i in range(len(s)):
if ring[i:i+len(target)]==target:
ans="Yes"
break
print(ans) | p02418 |
a = input()
b = input()
a = a+a
if 0 < a.count(b):
print('Yes')
else:
print('No') | a = input()
b = input()
a = a+a
if 0 <= a.find(b):
print('Yes')
else:
print('No') | p02418 |
from collections import deque
N = int(eval(input()))
M = N - 1
graph = [[] for _ in range(N + 1)]
dis_f = []
dis_s = []
#フェネックの距離
for i in range(M):
a,b = list(map(int,input().rstrip().split(" ")))
graph[a].append(b)
graph[b].append(a)
dist = [-1] * (N + 1)
dist[0] = 0
dist[1] = 0
d = deque()
d.append(1)
while(d):
v = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
dist[i] = dist[v] + 1
d.append(i)
ans_f = dist[1:]
#すぬけくんの距離
dist = [-1] * (N + 1)
dist[0] = 0
dist[N] = 0
d = deque()
d.append(N)
while(d):
v = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
dist[i] = dist[v] + 1
d.append(i)
ans_s = dist[1:]
count_f = 0
count_s = 0
for i in range(N):
if(ans_f[i] <= ans_s[i]):
count_f += 1
else:
count_s += 1
if(count_f > count_s):
print("Fennec")
else:
print("Snuke") | from collections import deque
N = int(eval(input()))
M = N - 1
graph = [[] for _ in range(N + 1)]
dis_f = []
dis_s = []
#フェネックの距離
for i in range(M):
a,b = list(map(int,input().rstrip().split(" ")))
graph[a].append(b)
graph[b].append(a)
dist_f = [-1] * (N + 1)
dist_f[0] = 0
dist_f[1] = 0
d = deque()
d.append(1)
left = N -1
while(d):
v = d.popleft()
for i in graph[v]:
if dist_f[i] != -1:
continue
dist_f[i] = dist_f[v] + 1
d.append(i)
#すぬけくんの距離
dist = [-1] * (N + 1)
dist[0] = 0
dist[N] = 0
d = deque()
d.append(N)
while(d):
v = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
dist[i] = dist[v] + 1
d.append(i)
count_f = 0
count_s = 0
for i in range(N):
if(dist_f[i + 1] <= dist[i + 1]):
count_f += 1
else:
count_s += 1
if(count_f > count_s):
print("Fennec")
else:
print("Snuke") | p03660 |
def bfs(v):
distance=[-1]*n
distance[v]=0
next=connection[v]
next2=set()
visited=[-1]*n
visited[v]=1
visitct=1
ct=0
while visitct!=n:
ct+=1
for i in range(len(next)):
distance[next[i]]=ct
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
import sys
input = sys.stdin.readline
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
f=bfs(0);s=bfs(n-1)
ctf=0;cts=0
for i in range(n):
if f[i]<=s[i]:
ctf+=1
else:
cts+=1
if ctf>cts:
print('Fennec')
else:
print('Snuke') | def bfs(v):
distance=[-1]*n
distance[v]=0
next=connection[v]
next2=set()
visited=[-1]*n
visited[v]=1
visitct=1
ct=0
while len(next)!=0 or visitct!=n:
ct+=1
for i in range(len(next)):
distance[next[i]]=ct
visited[next[i]]=1
visitct+=1
for j in range(len(connection[next[i]])):
if visited[connection[next[i]][j]]==-1:
next2.add(connection[next[i]][j])
next=list(next2)
next2=set()
return distance
import sys
input = sys.stdin.readline
n=int(eval(input()))
l=[list(map(int,input().split())) for i in range(n-1)]
connection=[[] for i in range(n)]
for i in range(n-1):
connection[l[i][0]-1].append(l[i][1]-1)
connection[l[i][1]-1].append(l[i][0]-1)
f=bfs(0);s=bfs(n-1)
ctf=0;cts=0
for i in range(n):
if f[i]<=s[i]:
ctf+=1
else:
cts+=1
if ctf>cts:
print('Fennec')
else:
print('Snuke') | p03660 |
import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
e = [[] for _ in range(n)]
for i in range(n-1):
a, b = [int(item) for item in input().split()]
e[a-1].append(b-1)
e[b-1].append(a-1)
shortest = []
def get_path(start, end, par, path):
global shortest
if end in e[start]:
shortest = path + [end]
return True
for item in e[start]:
if item != par:
if get_path(item, end, start, path + [item]):
return True
def tree_count(start, par, a, b):
count = 0
for item in e[start]:
if start == a and item == b:
continue
if start == b and item == a:
continue
if item != par:
count += 1
count += tree_count(item, start, a, b)
return count
get_path(0, n-1, -1, [0])
cut_l = (len(shortest)-1) // 2
p = tree_count(0, -1, shortest[cut_l], shortest[cut_l+1])
q = n - p - 2
if p > q:
print("Fennec")
else:
print("Snuke") | import sys
sys.setrecursionlimit(10**6)
n = int(eval(input()))
e = [[] for _ in range(n)]
for i in range(n-1):
a, b = [int(item) for item in input().split()]
e[a-1].append(b-1)
e[b-1].append(a-1)
shortest = []
def get_path(start, end, par):
if end in e[start]:
shortest.append(end)
return True
for item in e[start]:
if item != par:
if get_path(item, end, start):
shortest.append(item)
return True
def tree_count(start, par, a, b):
count = 0
for item in e[start]:
if start == a and item == b:
continue
if start == b and item == a:
continue
if item != par:
count += 1
count += tree_count(item, start, a, b)
return count
get_path(0, n-1, -1)
shortest.append(0)
shortest = shortest[::-1]
cut_l = (len(shortest)-1) // 2
p = tree_count(0, -1, shortest[cut_l], shortest[cut_l+1])
q = n - p - 2
if p > q:
print("Fennec")
else:
print("Snuke") | p03660 |
import heapq
N = int(eval(input()))
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
T[a].append([b, 1])
T[b].append([a, 1])
def dijkstra(x):
d = [float('inf')] * N
d[x] = 0
visited = {x}
# d, u
hq = [(0, x)]
while hq:
u = heapq.heappop(hq)[1]
visited.add(u)
for node, cost in T[u]:
if (node not in visited) and d[node] > d[u] + cost:
d[node] = d[u] + cost
heapq.heappush(hq, (d[u]+cost, node))
return d
B = dijkstra(0)
W = dijkstra(N - 1)
result = [("B" if b <= w else "W") for b, w in zip(B, W)]
print(("Fennec" if result.count("B") - result.count("W") > 0 else "Snuke"))
| import sys
sys.setrecursionlimit(10 ** 9)
N = int(eval(input()))
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
T[a].append([b, 1])
T[b].append([a, 1])
def dfs(n):
dist = [-1] * N
dist[n] = 0
stack = [n]
while stack:
u = stack.pop()
for v, c in T[u]:
if dist[v] < 0:
dist[v] = dist[u] + 1
stack.append(v)
return dist
Black = dfs(0)
White = dfs(N - 1)
Black_get = 0
for b, w in zip(Black, White):
if b <= w:
Black_get += 1
if Black_get > N // 2:
print('Fennec')
else:
print('Snuke')
| p03660 |
# ABC067D - Fennec VS. Snuke (ARC078D)
from collections import deque
def bfs(s: int, d: "List[int]") -> None:
q = deque([s])
while q:
v = q.popleft()
for u in G[v]:
if not d[u]:
q.append(u)
d[u] = d[v] + 1
def main():
global G, DB, DW
N, *E = list(map(int, open(0).read().split()))
G = [[] for _ in range(N + 1)]
for i in range(0, (N - 1) * 2, 2):
v, u = E[i : i + 2]
G[v] += [u]
G[u] += [v]
DB, DW = [0] * (N + 1), [0] * (N + 1)
bfs(1, DB), bfs(N, DW)
b, w = 0, 0
for i, j in zip(DB[1:], DW[1:]):
if i <= j:
b += 1
else:
w += 1
flg = b > w
print(("Fennec" if flg else "Snuke"))
if __name__ == "__main__":
main() | # ARC078D - Fennec VS. Snuke (ABC067D)
from collections import deque
def bfs(s: int, d: "List[int]") -> None:
q = deque([s])
while q:
v = q.popleft()
for u in G[v]:
if not d[u]:
q.append(u)
d[u] = d[v] + 1
def main():
global G, DB, DW
N, *E = list(map(int, open(0).read().split()))
G = [[] for _ in range(N + 1)]
for i in range(0, (N - 1) * 2, 2):
v, u = E[i : i + 2]
G[v] += [u]
G[u] += [v]
# DB, DW: distance from G[i] (black) and G[N] (white)
DB, DW = [0] * (N + 1), [0] * (N + 1)
bfs(1, DB), bfs(N, DW)
b, w = 0, 0
for i, j in zip(DB[1:], DW[1:]):
if i <= j:
b += 1
else:
w += 1
flg = b > w
print(("Fennec" if flg else "Snuke"))
if __name__ == "__main__":
main() | p03660 |
#067-D
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(eval(input()))
def S(): return eval(input())
n=I()
prev=[-1 for i in range(n)]
nl=[[] for i in range(n)]
q=[0]
vis=[False for i in range(n)]
for i in range(n-1):
a,b=IL()
nl[a-1].append(b-1)
nl[b-1].append(a-1)
while len(q)!=0:
s=q.pop(0)
vis[s]=True
for v in nl[s]:
if not vis[v]:
prev[v]=s
q.append(v)
path=[n-1]
while True:
if path[-1]==0:
break
path.append(prev[path[-1]])
path.reverse()
for i in range(1,n):
while True:
if prev[i] in path:
break
prev[i]=prev[prev[i]]
if len(path)%2==0:
fenp=path[:len(path)//2]
fen=len(path)//2
else:
fenp=path[:len(path)//2+1]
fen=len(path)//2+1
snu=len(path)-fen
r=list(range(n))
for i in path:
r.remove(i)
for i in r:
if prev[i] in fenp:
fen+=1
else:
snu+=1
if fen>snu:
print("Fennec")
else:
print("Snuke") | #067-D
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(eval(input()))
def S(): return eval(input())
n=I()
nl=[[] for i in range(n)]
distfen=[-1 for i in range(n)]
distsnu=[-1 for i in range(n)]
for i in range(n-1):
a,b=IL()
nl[a-1].append(b-1)
nl[b-1].append(a-1)
q=[[0,0]]
vis=[False for i in range(n)]
while len(q)!=0:
s,d=q.pop(0)
vis[s]=True
for v in nl[s]:
if not vis[v]:
distfen[v]=d+1
q.append([v,d+1])
q=[[n-1,0]]
vis=[False for i in range(n)]
while len(q)!=0:
s,d=q.pop(0)
vis[s]=True
for v in nl[s]:
if not vis[v]:
distsnu[v]=d+1
q.append([v,d+1])
fen=0
snu=0
for i in range(1,n-1):
if distfen[i]<=distsnu[i]:
fen+=1
else:
snu+=1
if fen>snu:
print("Fennec")
else:
print("Snuke") | p03660 |
def resolve():
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
adjlist = {}
for a, b in AB:
adjlist.setdefault(a-1, [])
adjlist.setdefault(b-1, [])
adjlist[a-1].append(b-1)
adjlist[b-1].append(a-1)
import collections
q = collections.deque([[0, []]])
shortest = None
while q:
v, path = q.popleft()
path = path+[v]
if v == N-1:
shortest = collections.deque(path[1:-1])
break
for nxt in adjlist[v]:
q.append([nxt, path])
assert shortest is not None, "bfs error"
# print(adjlist)
# print(shortest)
b_nexts = set(adjlist[0])
b_nexts.discard(N-1)
w_nexts = set(adjlist[N-1])
w_nexts.discard(0)
colored = [False for _ in range(N)]
colored[0] = True
colored[N-1] = True
b_turn = True
while True:
# print(colored)
# print(b_nexts)
# print(w_nexts)
# print(shortest)
if b_turn:
if len(b_nexts) == 0:
print("Snuke")
return
if len(shortest) > 0:
nxt = shortest.popleft()
b_nexts.remove(nxt)
else:
nxt = b_nexts.pop()
if nxt in w_nexts:
w_nexts.remove(nxt)
else:
if len(w_nexts) == 0:
print("Fennec")
return
if len(shortest) > 0:
nxt = shortest.pop()
w_nexts.remove(nxt)
else:
nxt = w_nexts.pop()
if nxt in b_nexts:
b_nexts.remove(nxt)
# print(nxt)
colored[nxt] = True
for v in adjlist[nxt]:
if colored[v] is False:
if b_turn:
b_nexts.add(v)
else:
w_nexts.add(v)
b_turn = not b_turn
#print("Snuke" if b_turn else "Fennec")
if '__main__' == __name__:
resolve() | def resolve():
N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
adjlist = {}
for a, b in AB:
adjlist.setdefault(a-1, [])
adjlist.setdefault(b-1, [])
adjlist[a-1].append(b-1)
adjlist[b-1].append(a-1)
import collections
q = collections.deque([0])
sources = [None for _ in range(N)]
sources[0] = -1
while q:
v = q.popleft()
for nxt in adjlist[v]:
if sources[nxt] is None:
sources[nxt] = v
q.append(nxt)
# print(adjlist)
# print(sources)
shortest = [N-1]
cur = N-1
while True:
shortest.append(sources[cur])
if sources[cur] == 0:
break
cur = sources[cur]
shortest.reverse()
# print(shortest)
shortest = collections.deque(shortest[1:-1])
b_nexts = set(adjlist[0])
b_nexts.discard(N-1)
w_nexts = set(adjlist[N-1])
w_nexts.discard(0)
colored = [False for _ in range(N)]
colored[0] = True
colored[N-1] = True
b_turn = True
while True:
# print(colored)
# print(b_nexts)
# print(w_nexts)
# print(shortest)
if b_turn:
if len(b_nexts) == 0:
print("Snuke")
return
if len(shortest) > 0:
nxt = shortest.popleft()
b_nexts.remove(nxt)
else:
nxt = b_nexts.pop()
if nxt in w_nexts:
w_nexts.remove(nxt)
else:
if len(w_nexts) == 0:
print("Fennec")
return
if len(shortest) > 0:
nxt = shortest.pop()
w_nexts.remove(nxt)
else:
nxt = w_nexts.pop()
if nxt in b_nexts:
b_nexts.remove(nxt)
# print(nxt)
colored[nxt] = True
for v in adjlist[nxt]:
if colored[v] is False:
if b_turn:
b_nexts.add(v)
else:
w_nexts.add(v)
b_turn = not b_turn
#print("Snuke" if b_turn else "Fennec")
if '__main__' == __name__:
resolve() | p03660 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = [int(x)-1 for x in input().split()]
G[a].append(b)
G[b].append(a)
visited = [False] * N
visited[0] = True
def dfs(v):
if v == N-1:
return [N-1]
for u in G[v]:
if visited[u]:
continue
visited[u] = True
ret = dfs(u)
visited[u] = False
if ret:
return [v] + ret
return None
path = dfs(0)
l = len(path)
u, v = 0, 0
if l % 2 == 0:
u = path[l//2-1]
v = path[l//2]
else:
u = path[l//2]
v = path[l//2+1]
G[u].remove(v)
G[v].remove(u)
def dfs2(v):
global fen
fen += 1
for u in G[v]:
if visited[u]:
continue
visited[u] = True
dfs2(u)
visited[u] = False
fen = 0
dfs2(0)
if fen > N // 2:
print('Fennec')
else:
print('Snuke')
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N = int(eval(input()))
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = [int(x)-1 for x in input().split()]
G[a].append(b)
G[b].append(a)
def dfs(v, dist):
for u in G[v]:
if dist[u] != -1:
continue
dist[u] = dist[v] + 1
ret = dfs(u, dist)
dist_fen = [-1] * N
dist_fen[0] = 0
dfs(0, dist_fen)
dist_snu = [-1] * N
dist_snu[N-1] = 0
dfs(N-1, dist_snu)
fen = 0
for v in range(N):
if dist_fen[v] <= dist_snu[v]:
fen += 1
if fen > N // 2:
print('Fennec')
else:
print('Snuke')
| p03660 |
from collections import defaultdict
import queue
N = int(eval(input()))
edge = defaultdict(list)
for i in range(N-1):
a,b = list(map(int,input().split()))
edge[a].append(b)
edge[b].append(a)
def bfs(s):
dist = defaultdict(lambda:float('inf'))
dist[s] = 0
que = queue.Queue()
que.put(s)
while que.qsize():
s = que.get()
for t in edge[s]:
if dist[t] > dist[s] + 1:
dist[t] = dist[s] + 1
que.put(t)
return dist
fdist = bfs(1)
sdist = bfs(N)
f = 0
for i in range(1,N+1):
if fdist[i] <= sdist[i]:
f += 1
s = N-f
if f > s:
print('Fennec')
else:
print('Snuke')
| from collections import defaultdict
from heapq import heappop, heappush
from math import ceil
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To,cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda:float('inf'))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q,(self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q,(alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N = int(eval(input()))
g = Graph()
for _ in range(N-1):
a,b = list(map(int,input().split()))
g.add_edge(a,b)
g.add_edge(b,a)
dij = Dijkstra(g,1)
path = dij.shortest_path(N)
c1 = path[ceil(len(path)/2)-1]
c2 = path[ceil(len(path)/2)]
g.graph[c1] = [(to,cost) for to,cost in g.graph[c1] if to != c2]
g.graph[c2] = [(to,cost) for to,cost in g.graph[c2] if to != c1]
dij = Dijkstra(g,1)
f = 0
for i in range(1,N):
if dij.shortest_distance(i) != float('inf'):
f += 1
if f > N-f:
print('Fennec')
else:
print('Snuke') | p03660 |
from collections import defaultdict
from heapq import heappop, heappush
from math import ceil
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, From, To, cost=1):
self.graph[From].append((To,cost))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda:float('inf'))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
self.Q = []
heappush(self.Q,(self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, cost in self.g[u]:
alt = dist_u + cost
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(self.Q,(alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
def shortest_path(self, goal):
path = []
node = goal
while node is not None:
path.append(node)
node = self.prev[node]
return path[::-1]
N = int(eval(input()))
g = Graph()
for _ in range(N-1):
a,b = list(map(int,input().split()))
g.add_edge(a,b)
g.add_edge(b,a)
dij = Dijkstra(g,1)
path = dij.shortest_path(N)
c1 = path[ceil(len(path)/2)-1]
c2 = path[ceil(len(path)/2)]
g.graph[c1] = [(to,cost) for to,cost in g.graph[c1] if to != c2]
g.graph[c2] = [(to,cost) for to,cost in g.graph[c2] if to != c1]
dij = Dijkstra(g,1)
f = 0
for i in range(1,N):
if dij.shortest_distance(i) != float('inf'):
f += 1
if f > N-f:
print('Fennec')
else:
print('Snuke') | from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
while heap:
cost,thisNode = heappop(heap)
for NextCost,NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
N = int(eval(input()))
g = [[] for _ in range(N)]
for _ in range(N-1):
a,b = list(map(int,input().split()))
g[a-1].append((1,b-1))
g[b-1].append((1,a-1))
df = dijkstra(g,N,0)
ds = dijkstra(g,N,N-1)
f = 0
for i in range(N):
if df[i] <= ds[i]:
f += 1
if f > N-f:
print('Fennec')
else:
print('Snuke') | p03660 |
import sys
input=sys.stdin.readline
N=int(eval(input()))
from collections import defaultdict
from collections import deque
branch=defaultdict(set)
for i in range(N-1):
a,b=list(map(int,input().split()))
branch[a]|={b,}
branch[b]|={a,}
brack=[float('inf')]*(N+1)
brack[1]=0
check=deque([(1,{1,N})])
while len(check)>0:
now=check.popleft()
for i in branch[now[0]]:
if i in now[1]:
continue
brack[i]=brack[now[0]]+1
check.append((i,now[1]|{i,}))
white=[float('inf')]*(N+1)
white[N]=0
check=deque([(N,{N,1}),])
while len(check)>0:
now=check.popleft()
for i in branch[now[0]]:
if i in now[1]:
continue
white[i]=white[now[0]]+1
check.append((i,now[1]|{i,}))
fennec=0
snuke=0
for i in range(1,N+1):
if brack[i]<=white[i]:fennec+=1
elif brack[i]>white[i]:snuke+=1
if fennec>snuke:print('Fennec')
elif fennec<=snuke:print('Snuke') | import sys
input=sys.stdin.readline
N=int(eval(input()))
from collections import defaultdict
from collections import deque
branch=defaultdict(set)
for i in range(N-1):
a,b=list(map(int,input().split()))
branch[a]|={b,}
branch[b]|={a,}
brack=[float('inf')]*(N+1)
brack[1]=0
brack[N]=0
check=deque([1])
while len(check)>0:
now=check.popleft()
for i in branch[now]:
if brack[i]>10**9:
brack[i]=brack[now]+1
check.append(i)
white=[float('inf')]*(N+1)
white[N]=0
white[1]=0
check=deque([N])
while len(check)>0:
now=check.popleft()
for i in branch[now]:
if white[i]>10**9:
white[i]=white[now]+1
check.append(i)
brack[N]=float('inf')
white[1]=float('inf')
fennec=0
snuke=0
for i in range(1,N+1):
if brack[i]<=white[i]:fennec+=1
elif brack[i]>white[i]:snuke+=1
if fennec>snuke:print('Fennec')
elif fennec<=snuke:print('Snuke') | p03660 |
n = int(eval(input()))
g = [set() for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].add(b-1)
g[b-1].add(a-1)
def dfs(s, e, flag):
visited = [-1]*n
visited[0] = 0
cnt = 1
if flag: temp = [[s, [[0]]]]
else: temp = [[s]]
lst = []
while temp:
p = temp.pop()
for a in g[p[0]]:
if flag: q = p[1][:]
if visited[a] != -1:continue
visited[a] = visited[p[0]] + 1
if flag: q.append([a])
if a == e:
lst = q[:]
return lst
if flag: temp.append([a, q])
else: temp.append([a])
cnt += 1
return cnt
lst = dfs(0, n-1, True)
m = (len(lst) - 1) // 2
g[lst[m][0]].discard(lst[m+1][0])
g[lst[m+1][0]].discard(lst[m][0])
c0 = dfs(0, n-1, False)
if c0 > n - c0: print('Fennec')
else:print('Snuke') | n = int(eval(input()))
g = [set() for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
g[a-1].add(b-1)
g[b-1].add(a-1)
def dfs(s):
visited = [-1]*n
visited[s] = 0
temp = [s]
lst = []
while temp:
p = temp.pop()
for a in g[p]:
if visited[a] != -1:continue
visited[a] = visited[p] + 1
temp.append(a)
return visited
lst0 = dfs(0)
lstn = dfs(n-1)
cnt = 0
for i in range(n):
if lst0[i] <= lstn[i]: cnt += 1
if cnt > n - cnt: print('Fennec')
else:print('Snuke') | p03660 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.