input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#!/usr/bin/env python3
#ABC67 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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
n = int(eval(input()))
g = [[] for _ in range(n)]
w = [[float('inf')]*n for _ in range(n)]
for _ in range(n-1):
a,b = list(map(int,input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
w[a-1][b-1] = 1
w[b-1][a-1] = 1
def dijkstra(s,n,w):
dist = [float('inf')]*n
used = [False]*n
dist[s] = 0
while 1:
v = -1
for i in range(n):
if not used[i] and v == -1:
v = i
elif not used[i] and dist[i] < dist[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
dist[j] = min(dist[j],dist[v] + w[v][j])
return dist
white,black = 0,0
for i in range(n):
d = dijkstra(i,n,w)
if d[0] <= d[n-1]:
black += 1
else:
white += 1
if black > white:
print('Fennec')
else:
print('Snuke')
| #!/usr/bin/env python3
#ABC67 D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
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
n = int(eval(input()))
g = [[] for _ in range(n)]
w = [[float('inf')]*n for _ in range(n)]
for _ in range(n-1):
a,b = list(map(int,input().split()))
g[a-1].append(b-1)
g[b-1].append(a-1)
w[a-1][b-1] = 1
w[b-1][a-1] = 1
def dijkstra(s,n,w):
dist = [float('inf')]*n
used = [False]*n
dist[s] = 0
while 1:
v = -1
for i in range(n):
if not used[i] and v == -1:
v = i
elif not used[i] and dist[i] < dist[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
dist[j] = min(dist[j],dist[v] + w[v][j])
return dist
white,black = 0,0
d1 = dijkstra(0,n,w)
d2 = dijkstra(n-1,n,w)
for i in range(n):
if d1[i] <= d2[i]:
black += 1
else:
white += 1
if black > white:
print('Fennec')
else:
print('Snuke')
| p03660 |
import sys
sys.setrecursionlimit(10**7)
def tree(p):
for x in neighbor[p]:
if x==par[p]: continue
par[x]=p
descend[p]+=tree(x)
return descend[p]
n=int(eval(input()))
neighbor=[set() for _ in range(n+1)]
descend=[1]*(n+1)
par=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].add(b)
neighbor[b].add(a)
tree(1)
x=[descend[n]-1]
t=n
while t!=1:
t,pret=par[t],t
x.append(descend[t]-descend[pret]-1)
l=len(x)
p,q=sum(x[:l//2]),sum(x[l//2:])
if l%2==0: print(("Fennec" if p<q else "Snuke"))
else: print(("Fennec" if p<=q else "Snuke")) | import sys
sys.setrecursionlimit(10**7)
def tree(p):
for x in neighbor[p]:
if x==par[p]: continue
par[x]=p
descend[p]+=tree(x)
return descend[p]
n=int(eval(input()))
neighbor=[[] for _ in range(n+1)]
descend=[1]*(n+1)
par=[0]*(n+1)
for _ in range(n-1):
a,b=list(map(int,input().split()))
neighbor[a].append(b)
neighbor[b].append(a)
tree(1)
x=[descend[n]-1]
t=n
while t!=1:
t,pret=par[t],t
x.append(descend[t]-descend[pret]-1)
l=len(x)
p,q=sum(x[:l//2]),sum(x[l//2:])
if l%2==0: print(("Fennec" if p<q else "Snuke"))
else: print(("Fennec" if p<=q else "Snuke")) | p03660 |
import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from collections import deque
N=int(eval(input()))
graph=[[] for _ in range(N+1)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
graph[a].append(b)
graph[b].append(a)
#print(graph)
def dfs_init(u,ls):
global path
visited[u]=True
if u==N:
path=ls
return
for v in graph[u]:
if not visited[v]:
dfs_init(v,ls+[v])
path=[]
visited=[False]*(N+1)
dfs_init(1,[1])
#print(path)
visited=[False]*(N+1)
set_f=set()
set_s=set()
turn=1
dq=deque(path)
while dq:
#Fenec
node_f=dq.popleft()
visited[node_f]=True
set_f.add(node_f)
turn=-1
if dq:
#Snuke
node_s=dq.pop()
visited[node_s]=True
set_s.add(node_s)
turn=1
#print(set_f,set_s,visited,turn)
def dfs_fenec(u):
global cnt_f
if not visited[u]:
visited[u]=True
cnt_f+=1
for v in graph[u]:
if not visited[v]:
dfs_fenec(v)
def dfs_snuke(u):
global cnt_s
if not visited[u]:
visited[u]=True
cnt_s+=1
for v in graph[u]:
if not visited[v]:
dfs_snuke(v)
#fenec
cnt_f=0
for f in set_f:
dfs_fenec(f)
#snuke
cnt_s=0
for s in set_s:
dfs_snuke(s)
#print(cnt_f,cnt_s)
if turn==1:
if cnt_f>cnt_s:
print("Fennec")
else:
print("Snuke")
elif turn==-1:
if cnt_f>=cnt_s:
print("Fennec")
else:
print("Snuke") | import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from collections import deque
N=int(eval(input()))
graph=[[] for _ in range(N+1)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
graph[a].append(b)
graph[b].append(a)
#print(graph)
dist_f=[-1]*(N+1)
d=0
queue=[1]
while queue:
new_queue=set()
for u in queue:
dist_f[u]=d
for v in graph[u]:
if dist_f[v]==-1:
new_queue.add(v)
queue=list(new_queue)
d+=1
#print(dist_f)
dist_s=[-1]*(N+1)
d=0
queue=[N]
while queue:
new_queue=set()
for u in queue:
dist_s[u]=d
for v in graph[u]:
if dist_s[v]==-1:
new_queue.add(v)
queue=list(new_queue)
d+=1
#print(dist_s)
cnt_f,cnt_s=0,0
for i in range(1,N+1):
if dist_f[i]<=dist_s[i]:
cnt_f+=1
else:
cnt_s+=1
#print(cnt_f,cnt_s)
if cnt_f>cnt_s:
print("Fennec")
else:
print("Snuke") | p03660 |
N = int(eval(input()))
G = [[] for _ in range(N)]
visited = [0]*N
visited[0],visited[N-1] = 1,1
visited_all = [1]*N
for i in range(N-1):
a,b = list(map(int,input().split()))
G[a-1].append(b-1)
G[b-1].append(a-1)
nextA,nextB = G[0],G[N-1]
scoreA,scoreB = 1,1
while visited != visited_all:
l = []
for a in nextA:
if visited[a] == 0:
visited[a] = 1
scoreA += 1
for x in G[a]:
l.append(x)
nextA = l
l = []
for b in nextB:
if visited[b] == 0:
visited[b] = 1
scoreB += 1
for x in G[b]:
l.append(x)
nextB = l
print(("Fennec" if scoreA > scoreB else "Snuke"))
| N = int(eval(input()))
A = [[] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int,input().split()))
A[a-1].append(b-1)
A[b-1].append(a-1)
B = [False]*N
visited = [True]*N
Fp,Sp = 0,0
Fi,Si = [0],[N-1]
while B != visited:
# Fennec
nextXi = []
for i in Fi:
if not B[i]:
B[i] = True
Fp += 1
nextXi.extend(A[i])
Fi = nextXi
# Snuke
nextXi = []
for i in Si:
if not B[i]:
B[i] = True
Sp += 1
nextXi.extend(A[i])
Si = nextXi
print(("Fennec" if Fp>Sp else "Snuke")) | p03660 |
import sys
sys.setrecursionlimit(10**6)
def main():
N = int(eval(input()))
d = {}
for _ in range(N-1):
a, b = list(map(int, input().split()))
if a in d:
d[a].append(b)
else:
d[a] = [b]
if b in d:
d[b].append(a)
else:
d[b] = [a]
v = set()
v.add(1)
def dfs(n):
if n == N:
return True, [N]
for i in d[n]:
if i not in v:
v.add(i)
t, l = dfs(i)
if t:
return True, l + [n]
return False, n
_, l = dfs(1)
l.reverse()
v = set()
if len(l) % 2 == 0:
half = len(l) // 2 - 1
else:
half = len(l) // 2
v.add(l[half])
s = l[half+1]
v.add(s)
def dfs2(n):
r = 1
for i in d[n]:
if i not in v:
v.add(i)
r += dfs2(i)
return r
x = dfs2(s)
if N - x > x:
return 'Fennec'
else:
return 'Snuke'
print((main()))
| import sys
sys.setrecursionlimit(10**6)
def main():
N = int(eval(input()))
d = {}
for _ in range(N-1):
a, b = list(map(int, input().split()))
if a in d:
d[a].append(b)
else:
d[a] = [b]
if b in d:
d[b].append(a)
else:
d[b] = [a]
v = set()
v.add(1)
l = []
def dfs(n):
if n == N:
l.append(n)
return True
for i in d[n]:
if i not in v:
v.add(i)
if dfs(i):
l.append(n)
return True
return False
dfs(1)
l.reverse()
v = set()
if len(l) % 2 == 0:
half = len(l) // 2 - 1
else:
half = len(l) // 2
v.add(l[half])
s = l[half+1]
v.add(s)
def dfs2(n):
r = 1
for i in d[n]:
if i not in v:
v.add(i)
r += dfs2(i)
return r
x = dfs2(s)
if N - x > x:
return 'Fennec'
else:
return 'Snuke'
print((main()))
| p03660 |
import sys
sys.setrecursionlimit(1000000)
N=int(eval(input()))
ab=[[] for _ in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b)
ab[b-1].append(a)
def dfs(pre,p,pa):
global path
if p==N:
path=pa
else:
for i in ab[p-1]:
if i!=pre:
dfs(p,i,pa+[i])
dfs(-1,1,[1])
spath=set(path)
def dfs2(pre,p):
a=0
for i in ab[p-1]:
if i in spath:
pass
elif i==pre:
pass
else:
a+=dfs2(p,i)
return 1+a
ff=0
sf=0
L=len(path)
for i in range(L):
if i<=(L-1)//2:
ff+=dfs2(-1,path[i])
else:
sf+=dfs2(-1,path[i])
if ff>sf:
print("Fennec")
else:
print("Snuke")
| import sys
sys.setrecursionlimit(1000000)
N=int(eval(input()))
ab=[[] for _ in range(N)]
for _ in range(N-1):
a,b=list(map(int,input().split()))
ab[a-1].append(b)
ab[b-1].append(a)
"""
N=10**5
ab=[[]]*N
ab[0]=[2]
ab[N-1]=[N-1]
for i in range(1,N-1):
ab[i]=[i,i+2]
"""
par=[0]*N
def dfs(pre,p):
global path
par[p-1]=pre
if p==N:
pass
else:
for i in ab[p-1]:
if i!=pre:
dfs(p,i)
dfs(-1,1)
path=[N]
p=N
while p!=1:
p=par[p-1]
path.append(p)
path.reverse()
spath=set(path)
def dfs2(pre,p):
a=0
for i in ab[p-1]:
if i in spath:
pass
elif i==pre:
pass
else:
a+=dfs2(p,i)
return 1+a
ff=0
sf=0
L=len(path)
for i in range(L):
if i<=(L-1)//2:
ff+=dfs2(-1,path[i])
else:
sf+=dfs2(-1,path[i])
if ff>sf:
print("Fennec")
else:
print("Snuke")
| p03660 |
#高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def DIJKSTRA(point,d):
cost = [float("inf")]*(n+1)
Q = []
cost[point]=0
heappush(Q,(point,cost[point]))
while Q:
prefnd,tmpC=heappop(Q)
if cost[prefnd]<tmpC:
continue
for node,c in d[prefnd]:
altC=c+tmpC
if cost[node]>altC:
cost[node]=altC
heappush(Q,(node,altC))
return cost
n=int(eval(input()))
d={}
for i in range(n-1):
a,b=list(map(int,input().split()))
if a in list(d.keys()):
d[a].append([b,1])
else:
d[a]=[[b,1]]
if b in list(d.keys()):
d[b].append([a,1])
else:
d[b]=[[a,1]]
x=DIJKSTRA(1,d)[1:]
y=DIJKSTRA(n,d)[1:]
#print(x)
#print(y)
F=0
S=0
for i in range(n):
if x[i]<=y[i]:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec") | #高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
heappush(Q,(0,point))
while Q:
c,p=heappop(Q)
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
heappush(Q,(c+1,np))
return cost
n=int(eval(input()))
d={}
for i in range(n-1):
a,b=list(map(int,input().split()))
if a in list(d.keys()):
d[a].append(b)
else:
d[a]=[b]
if b in list(d.keys()):
d[b].append(a)
else:
d[b]=[a]
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec") | p03660 |
#高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
heappush(Q,(0,point))
while Q:
c,p=heappop(Q)
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
heappush(Q,(c+1,np))
return cost
n=int(eval(input()))
d={}
for i in range(n-1):
a,b=list(map(int,input().split()))
if a in list(d.keys()):
d[a].append(b)
else:
d[a]=[b]
if b in list(d.keys()):
d[b].append(a)
else:
d[b]=[a]
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec") | #高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
heappush(Q,(0,point))
while Q:
c,p=heappop(Q)
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
heappush(Q,(c+1,np))
return cost
n=int(eval(input()))
d={}
for i in range(n-1):
a,b=list(map(int,input().split()))
if a in d:
d[a].append(b)
else:
d[a]=[b]
if b in d:
d[b].append(a)
else:
d[b]=[a]
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| p03660 |
#高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
heappush(Q,(0,point))
while Q:
c,p=heappop(Q)
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
heappush(Q,(c+1,np))
return cost
n=int(eval(input()))
d=[deque()for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
Q.append((0,point))
while Q:
c,p=Q.pop()
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
Q.append((c+1,np))
return cost
n=int(eval(input()))
d=[deque()for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| p03660 |
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=[]
Q.append((0,point))
while Q:
c,p=Q.pop()
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
Q.append((c+1,np))
return cost
n=int(eval(input()))
d=[deque()for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=deque()
Q.appendleft((0,point))
while Q:
c,p=Q.pop()
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
Q.appendleft((c+1,np))
return cost
n=int(eval(input()))
d=[[]for i in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec") | p03660 |
from collections import deque
N = int(eval(input()))
edges = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
que = deque([])
que.append((0, 0))
minDist = [float('inf') for _ in range(N)]
while que:
now, dist = que.popleft()
if minDist[now] <= dist:
continue
minDist[now] = dist
for to in edges[now]:
if dist + 1 < minDist[to]:
que.append((to, dist + 1))
now = N - 1
minPath = [now]
dist = minDist[N - 1]
while dist > 0:
for back in edges[now]:
if minDist[back] == dist - 1:
minPath.append(back)
dist -= 1
now = back
break
edges[minPath[len(minPath) // 2]].remove(minPath[len(minPath) // 2 - 1])
edges[minPath[len(minPath) // 2 - 1]].remove(minPath[len(minPath) // 2])
confilm = [0 for _ in range(N)]
que.clear()
que.append(0)
while que:
now = que.popleft()
confilm[now] = 1
for to in edges[now]:
if confilm[to] == 0:
que.append(to)
blackCount = sum(confilm)
witeCount = N - blackCount
if blackCount > witeCount:
print('Fennec')
else:
print('Snuke') | N = int(eval(input()))
edges = [[] for _ in range(N)]
for _ in range(N - 1):
fr, to = list(map(int, input().split()))
fr -= 1
to -= 1
edges[fr].append(to)
edges[to].append(fr)
def calc(s):
st = [s]
minDist = [10**18] * N
minDist[s] = 0
while st:
now = st.pop()
for to in edges[now]:
if minDist[to] > minDist[now] + 1:
minDist[to] = minDist[now] + 1
st.append(to)
return minDist
A = calc(0)
B = calc(N - 1)
ans = 0
for i in range(N):
ans += 1 if A[i] <= B[i] else -1
print(('Fennec' if ans > 0 else 'Snuke'))
| p03660 |
N = int(eval(input()))
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
T[a - 1].append(b - 1)
T[b - 1].append(a - 1)
def dijkstra(N, s0):
D = [N] * N
Q = [s0]
D[s0] = 0
while Q:
s = Q[0]
Q = Q[1:]
for adj in T[s]:
if D[s] + 1 < D[adj]:
D[adj] = D[s] + 1
Q.append(adj)
return D
D1 = dijkstra(N, 0)
D2 = dijkstra(N, N - 1)
score = 0
for i in range(N):
score += 1 if D1[i] <= D2[i] else -1
print(('Fennec' if score > 0 else 'Snuke')) | N = int(eval(input()))
T = [[] for i in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
T[a - 1].append(b - 1)
T[b - 1].append(a - 1)
def dijkstra(N, s0):
D = [N] * N
D[s0] = 0
Q = [N] * N
Q[0] = s0
tail = 1
for i in range(N):
s = Q[i]
for adj in T[s]:
if D[s] + 1 < D[adj]:
D[adj] = D[s] + 1
Q[tail] = adj
tail += 1
return D
D1 = dijkstra(N, 0)
D2 = dijkstra(N, N - 1)
score = 0
for i in range(N):
score += 1 if D1[i] <= D2[i] else -1
print(('Fennec' if score > 0 else 'Snuke')) | p03660 |
N = int(eval(input()))
inf = float('inf')
import heapq
def dijkstra(adj, n, st=1):
dj = [inf] * (n + 1)
paths = dict((x, [x]) for x in range(n + 1))
dj[st] = 0
q = []
heapq.heappush(q, (0, st))
while q:
fc, fn = heapq.heappop(q)
if dj[fn] < fc: continue
for tn, lc in adj[fn]:
if dj[fn] + lc < dj[tn]:
dj[tn] = dj[fn] + lc
paths[tn] = paths[fn] + [tn]
heapq.heappush(q, (dj[tn], tn))
return dj, paths
import itertools
def reachable(adj, st):
reached = set([st])
cur = set([st])
while cur:
nxt = set(itertools.chain(*[[y[0] for y in adj[x]] for x in cur]))
reached.update(cur)
cur = nxt - reached
return reached
adj = dict((x, []) for x in range(N + 1))
for _ in range(N - 1):
a, b = list(map(int, input().split()))
adj[a].append((b, 1))
adj[b].append((a, 1))
costs, paths = dijkstra(adj, N, 1)
main_street = paths[N]
import math
mid = math.ceil(len(main_street) / 2) - 1
mid_v0 = main_street[mid]
mid_v1 = main_street[mid + 1]
adj[mid_v0] = [x for x in adj[mid_v0] if x[0] != mid_v1]
adj[mid_v1] = [x for x in adj[mid_v1] if x[0] != mid_v0]
fennec = len(reachable(adj, 1))
snuke = N - fennec
print(("Fennec" if fennec > snuke else "Snuke")) | N = int(eval(input()))
inf = float('inf')
import heapq
def dijkstra(adj, n, st=1):
dj = [inf] * (n + 1)
dj[st] = 0
q = []
heapq.heappush(q, (0, st))
while q:
fc, fn = heapq.heappop(q)
if dj[fn] < fc: continue
for tn, lc in adj[fn]:
if dj[fn] + lc < dj[tn]:
dj[tn] = dj[fn] + lc
heapq.heappush(q, (dj[tn], tn))
return dj
adj = dict((x, []) for x in range(N + 1))
for _ in range(N - 1):
a, b = list(map(int, input().split()))
adj[a].append((b, 1))
adj[b].append((a, 1))
c_f = dijkstra(adj, N, 1)
c_s = dijkstra(adj, N, N)
score = 0
for i in range(1, N + 1):
if c_f[i] > c_s[i]:
score -= 1
else:
score += 1
print(("Fennec" if score > 0 else "Snuke")) | p03660 |
from collections import deque
def bfs(s, dist):
visited = [False] * (N+1)
q = [(s, 1)]
visited[s] = True
while q:
u, c = q.pop()
for v in graph[u]:
if not visited[v]:
visited[v] = True
dist[v] = c
q.append((v, c+1))
N = int(eval(input()))
graph = [deque() for i in range(N+1)]
dist = [[0] * (N+1) for i in range(2)]
for i in range(N-1):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
bfs(1, dist[0])
bfs(N, dist[1])
b = w = 0
for i in range(2, N):
if dist[0][i] <= dist[1][i]:
b += 1
else:
w += 1
if b <= w:
print('Snuke')
else:
print('Fennec') |
from collections import deque
# BFSで、B/Wそれぞれのスタート地点から拡張点への距離を取得
def bfs(s, distance):
visited = [False] * (N+1)
q = [(s, 1)]
visited[s] = True
while q:
u, dist = q.pop()
for v in graph[u]:
if not visited[v]:
visited[v] = True
distance[v] = dist
q.append((v, dist+1))
# print(distance)
N = int(eval(input()))
graph = [deque() for i in range(N+1)]
distance = [[0] * (N+1) for i in range(2)]
for i in range(N-1):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
#print(graph)
bfs(1, distance[0])
bfs(N, distance[1])
# 各頂点について、より近いほうが塗れたことに
b = w = 0
for i in range(2, N):
if distance[0][i] <= distance[1][i]:
b += 1
else:
w += 1
if b <= w:
print('Snuke')
else:
print('Fennec') | p03660 |
from collections import defaultdict
from heapq import heappop, heappush
N = int(eval(input()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, src, dst, weight=1):
self.graph[src].append((dst, weight))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
Q = []
heappush(Q, (self.dist[start], start))
while Q:
dist_u, u = heappop(Q)
if self.dist[u] < dist_u:
continue
for v, weight in g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(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]
g = Graph()
for _ in range(N - 1):
a, b = list(map(int, input().split()))
g.add_edge(a - 1, b - 1)
g.add_edge(b - 1, a - 1)
d1 = Dijkstra(g, 0)
d2 = Dijkstra(g, N - 1)
c1, c2 = 0, 0
for i in range(N):
if d1.shortest_distance(i) <= d2.shortest_distance(i):
c1 += 1
else:
c2 += 1
if c1 > c2:
print('Fennec')
else:
print('Snuke')
| import sys
from collections import defaultdict
from heapq import heappop, heappush
input = sys.stdin.readline
N = int(eval(input()))
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def __len__(self):
return len(self.graph)
def add_edge(self, src, dst, weight=1):
self.graph[src].append((dst, weight))
def get_nodes(self):
return list(self.graph.keys())
class Dijkstra(object):
def __init__(self, graph, start):
g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[start] = 0
self.prev = defaultdict(lambda: None)
Q = []
heappush(Q, (self.dist[start], start))
while Q:
dist_u, u = heappop(Q)
if self.dist[u] < dist_u:
continue
for v, weight in g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
self.prev[v] = u
heappush(Q, (alt, v))
def shortest_distance(self, goal):
return self.dist[goal]
g = Graph()
for _ in range(N - 1):
a, b = list(map(int, input().split()))
g.add_edge(a - 1, b - 1)
g.add_edge(b - 1, a - 1)
d1 = Dijkstra(g, 0)
d2 = Dijkstra(g, N - 1)
cnt1, cnt2 = 0, 0
for i in range(1, N - 1):
x = d1.shortest_distance(i)
y = d2.shortest_distance(i)
if x <= y:
cnt1 += 1
else:
cnt2 += 1
if cnt1 > cnt2:
print('Fennec')
else:
print('Snuke')
| p03660 |
# [数学、特にグラフ理論の分野における木（き、）とは、連結で閉路を持たないグラフである。]
# なので1->Nは1通り。つまり1->Nの最短経路上にあるマスをつぶすのが先
# で、残ったのを探索できるが、こういう二段構えで実装するのが面倒。
# もうちょっと考えると、1->i とi->Nの距離をみたとき、前者が小さければ先に到達できるので黒で埋められることが分かる
# （進めなくなったら負け、がめんどくさいが、すすめなくなったらパス、とすると、勝敗は変わらないことになる）
# 1とNからスタートして2回BFSすりゃいいか
import sys
from collections import deque
sys.setrecursionlimit(10 ** 8)
n = int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(x) - 1 for x in input().split()]
graph[a].append(b)
graph[b].append(a)
table_from_one = [10 ** 5 for _ in range(n)]
table_from_one[0] = 0
table_from_n = [10 ** 5 for _ in range(n)]
table_from_n[-1] = 0
arr_from_one = deque([0])
arr_from_n = deque([n - 1])
def set_table(table, arr):
while len(arr) > 0:
cur = arr.popleft()
for next_node in graph[cur]:
if table[next_node] < 10 ** 5:
continue
table[next_node] = table[cur] + 1
arr.append(next_node)
set_table(table_from_one, arr_from_one)
set_table(table_from_n, arr_from_n)
result = 0
for i in range(n):
if table_from_one[i] <= table_from_n[i]:
result += 1
else:
result -= 1
print(("Fennec" if result > 0 else "Snuke"))
| from collections import deque
import sys
sys.setrecursionlimit(10**8)
n = int(eval(input()))
graph = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = [int(x) - 1 for x in input().split()]
graph[a].append(b)
graph[b].append(a)
fennec = [10**5 + 10] * n
fennec[0] = 0
snuke = [10**5 + 10] * n
snuke[n - 1] = 0
def bfs(arr, q):
while len(q) > 0:
qq = q.popleft()
for nex in graph[qq[0]]:
if arr[nex] > qq[1] + 1:
arr[nex] = qq[1] + 1
q.append([nex, arr[nex]])
sq, gq = deque(), deque()
sq.append([0, 0])
gq.append([n - 1, 0])
bfs(fennec, sq)
bfs(snuke, gq)
ans = 0
for i in range(n):
if fennec[i] <= snuke[i]:
ans += 1
else:
ans -= 1
# なんでans>=0じゃないん？？？？？？？？？？？
print(("Fennec" if ans > 0 else "Snuke")) | p03660 |
from collections import defaultdict
N = int(eval(input()))
dic = defaultdict(list)
for i in range(N-1):
a, b = list(map(int, input().split()))
dic[a-1] += [b-1]
dic[b-1] += [a-1]
dist1 = [float('inf')]*N
dist2 = [float('inf')]*N
q1 = [0]
q2 = [N-1]
dist1[0] = 0
dist2[N-1] = 0
while q1:
e = q1.pop()
for p in dic[e]:
if dist1[p]>dist1[e]+1:
dist1[p] = dist1[e]+1
q1 += [p]
while q2:
e = q2.pop()
for p in dic[e]:
if dist2[p]>dist2[e]+1:
dist2[p] = dist2[e]+1
q2 += [p]
fennec = 0
snuke = 0
for i in range(N):
if dist1[i]<=dist2[i]:
fennec += 1
else:
snuke += 1
if fennec>snuke:
print('Fennec')
else:
print('Snuke') | from collections import deque
N, *L = list(map(int, open(0).read().split()))
dic = [[] for i in range(N+1)]
for a,b in zip(*[iter(L)]*2):
dic[a] += [b]
dic[b] += [a]
fdist = [-1]*(N+1)
sdist = [-1]*(N+1)
fdist[1] = 0
sdist[N] = 0
q = deque([1])
while q:
v = q.popleft()
for u in dic[v]:
if fdist[u] == -1:
fdist[u] = fdist[v] + 1
q.append(u)
q = deque([N])
while q:
v = q.popleft()
for u in dic[v]:
if sdist[u]==-1:
sdist[u] = sdist[v] + 1
q.append(u)
ans = sum(a<=b for a,b in zip(fdist,sdist))-1
if 2*ans>N:
print('Fennec')
else:
print('Snuke') | p03660 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
graph = [[] for i in range(N)]
for _ in range(N-1):
a,b = IL()
graph[a-1].append(b-1)
graph[b-1].append(a-1)
s = 0
d1 = [INF]*N
d1[s] = 0
q = deque([s])
while q:
u = q.popleft()
for v in graph[u]:
if d1[v] != INF: continue
d1[v] = d1[u] + 1
q.append(v)
s = N-1
d2 = [INF]*N
d2[s] = 0
q = deque([s])
while q:
u = q.popleft()
for v in graph[u]:
if d2[v] != INF: continue
d2[v] = d2[u] + 1
q.append(v)
ans = 0
for i in range(N):
if d1[i]<=d2[i]:
ans += 1
if ans >= -(-(N+1)//2):
print("Fennec")
else:
print("Snuke") | # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
N = I()
graph = [[] for i in range(N)]
for _ in range(N-1):
a,b = IL()
graph[a-1].append(b-1)
graph[b-1].append(a-1)
s = 0
d1 = [INF]*N
d1[s] = 0
q = deque([s])
while q:
u = q.popleft()
for v in graph[u]:
if d1[v] != INF: continue
d1[v] = d1[u] + 1
q.append(v)
s = N-1
d2 = [INF]*N
d2[s] = 0
q = deque([s])
while q:
u = q.popleft()
for v in graph[u]:
if d2[v] != INF: continue
d2[v] = d2[u] + 1
q.append(v)
ans = 0
for i in range(N):
if d1[i]<=d2[i]:
ans += 1
if ans > N//2:
print("Fennec")
else:
print("Snuke") | p03660 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 木の読み込み tree
# サイズが大きいとdefaultdictが早い(for文を書かなくて済む)
from collections import defaultdict
n = int(eval(input()))
ns = defaultdict(set)
for _ in range(n-1):
u,v = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].add(v)
ns[v].add(u)
### BFS 幅優先探索
def bfs(start):
from collections import deque
q = deque([start])
seen = [None] * n
seen[start] = 0
while q:
u = q.pop()
d = seen[u]
for v in ns[u]:
if seen[v] is None:
seen[v] = d + 1
q.appendleft(v)
return seen
d1 = bfs(0)
d2 = bfs(n-1)
v = sum(d1[i]<=d2[i] for i in range(n))
v2 = n-v
if v>v2:
print("Fennec")
else:
print("Snuke") | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
### 木の読み込み tree
# サイズが大きいとdefaultdictが早い(for文を書かなくて済む)
from collections import defaultdict
n = int(eval(input()))
ns = [[] for _ in range(n)]
for _ in range(n-1):
u,v = list(map(int, input().split()))
u -= 1
v -= 1
ns[u].append(v)
ns[v].append(u)
### BFS 幅優先探索
def bfs(start):
from collections import deque
q = deque([start])
seen = [None] * n
seen[start] = 0
while q:
u = q.pop()
d = seen[u]
for v in ns[u]:
if seen[v] is None:
seen[v] = d + 1
q.appendleft(v)
return seen
d1 = bfs(0)
d2 = bfs(n-1)
v = sum(d1[i]<=d2[i] for i in range(n))
v2 = n-v
if v>v2:
print("Fennec")
else:
print("Snuke") | p03660 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import queue
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
n = I()
a = LI()
b = [None for i in range(n-1)]
for i in range(n-1):
a[i+1] += a[i]
for i in range(n-1):
b[i] = abs(2*a[i]-a[n-1])
print(min(b))
"""
#D
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
d_f = [-1 for i in range(n)]
q = queue.Queue()
q.put(0)
d_f[0] = 0
while not q.empty():
x = q.get()
for y in v[x]:
if d_f[y] == -1:
d_f[y] = d_f[x] + 1
q.put(y)
d_s = [-1 for i in range(n)]
q.put(n-1)
d_s[n-1] = 0
while not q.empty():
x = q.get()
for y in v[x]:
if d_s[y] == -1:
d_s[y] = d_s[x] + 1
q.put(y)
f = 0
s = 0
for i in range(n):
if d_f[i] <= d_s[i]:
f += 1
else:
s += 1
if f > s:
print("Fennec")
else:
print("Snuke")
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| #!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import queue
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
#B
#C
"""
n = I()
a = LI()
b = [None for i in range(n-1)]
for i in range(n-1):
a[i+1] += a[i]
for i in range(n-1):
b[i] = abs(2*a[i]-a[n-1])
print(min(b))
"""
#D
n = I()
v = [[] for i in range(n)]
for i in range(n-1):
a,b = LI()
a -= 1
b -= 1
v[a].append(b)
v[b].append(a)
d_f = [-1 for i in range(n)]
q = deque()
q.append(0)
d_f[0] = 0
while q:
x = q.pop()
for y in v[x]:
if d_f[y] == -1:
d_f[y] = d_f[x] + 1
q.append(y)
d_s = [-1 for i in range(n)]
q.append(n-1)
d_s[n-1] = 0
while q:
x = q.pop()
for y in v[x]:
if d_s[y] == -1:
d_s[y] = d_s[x] + 1
q.append(y)
f = 0
s = 0
for i in range(n):
if d_f[i] <= d_s[i]:
f += 1
else:
s += 1
if f > s:
print("Fennec")
else:
print("Snuke")
#E
#F
#G
#H
#I
#J
#K
#L
#M
#N
#O
#P
#Q
#R
#S
#T
| p03660 |
from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [[] for _ in range(N + 1)]
for a, b in zip(*[iter(AB)] * 2):
E[a].append(b)
E[b].append(a)
def get_dist(src):
Q = deque([(src, 0)])
dist = [-1] * (N + 1)
while Q:
v, d = Q.popleft()
dist[v] = d
for u in E[v]:
if dist[u] < 0:
Q.append((u, d + 1))
return dist[1:]
F = get_dist(1)
S = get_dist(N)
fennec, snuke = 0, 0
for f, s in zip(F, S):
if f <= s:
fennec += 1
else:
snuke += 1
if fennec > snuke:
print("Fennec")
else:
print("Snuke")
| from collections import deque
N, *AB = list(map(int, open(0).read().split()))
E = [[] for _ in range(N + 1)]
for a, b in zip(*[iter(AB)] * 2):
E[a].append(b)
E[b].append(a)
def get_dist(src):
Q = deque([src])
dist = [0] * (N + 1)
while Q:
v = Q.popleft()
for u in E[v]:
if dist[u] == 0:
Q.append(u)
dist[u] = dist[v] + 1
return dist[1:]
F = get_dist(1)
S = get_dist(N)
fennec, snuke = 0, 0
for f, s in zip(F, S):
if f <= s:
fennec += 1
else:
snuke += 1
if fennec > snuke:
print("Fennec")
else:
print("Snuke")
| p03660 |
import sys
input = sys.stdin.readline
#O(ElogV)
import heapq
def dijkstra_heap(s):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
################################
n = int(eval(input())) #n:頂点数 w:辺の数
w = n - 1
edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
z = 1
edge[x].append([z,y])
edge[y].append([z,x])
dis_from_f = dijkstra_heap(0)
dis_from_s = dijkstra_heap(n - 1)
cnt = 0
for i, j in zip(dis_from_f, dis_from_s):
if i <= j:
cnt += 1
if cnt > n - cnt:
print("Fennec")
else:
print("Snuke") | import sys
input = sys.stdin.readline
import heapq
def dijkstra(s):
# 始点sから各頂点への最短距離
d = [float('inf')]*n
d[s] = 0
# 各頂点が訪問済みかどうか
used = [False]*n
used[s] = True
# 仮の距離を記録するヒープ
que = []
for e in edge[s]:
heapq.heappush(que, e)
while que:
minedge = heapq.heappop(que)
if used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = True
for e in edge[v]:
if not used[e[1]]:
heapq.heappush(que, [e[0] + d[v], e[1]])
return d
################################
n = int(eval(input())) #n:頂点数 w:辺の数
w = n - 1
edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w):
x,y = list(map(int,input().split()))
x -= 1
y -= 1
z = 1
edge[x].append([z,y])
edge[y].append([z,x])
dis_from_f = dijkstra(0)
dis_from_s = dijkstra(n - 1)
cnt = 0
for i, j in zip(dis_from_f, dis_from_s):
if i <= j:
cnt += 1
if cnt > n - cnt:
print("Fennec")
else:
print("Snuke") | p03660 |
# -*- coding: utf-8 -*-
#Python
import sys
N=eval(input())
a=[[] for i in range(N+1)]
for i in range(N-1):
u,v=list(map(int,input().split()))
a[u].append(v)
a[v].append(u)
#print a
#初期化
kyori=(N+1)*[0]
sys.setrecursionlimit(1000000)
#深さ優先探索
def dfs(Graph, Start, Visited=None):
if (Visited==None): Visited = [] #開始点のときに探索済みリストをつくる
Visited.append(Start) #現在の頂点を探索済みリストに加える
#print(Start, "\n", Visited) #現在の頂点と探索済みリストを表示
for Next in Graph[Start]: #次に探索する頂点の候補
#print "Next::"+str(Next)
if ( Next in Visited ): continue #訪問済みリストにある頂点は飛ばす
kyori[Next]=kyori[Start]+1
dfs(Graph, Next, Visited) #再帰
return kyori
kyori_from_start=dfs(a,1)
kyori=(N+1)*[0]
dfs(a,N)
f_p=0
s_p=0
for k in range(1,N+1):
if kyori_from_start[k]<=kyori[k]:
f_p+=1
else:
s_p+=1
#print f_p
#print s_p
if f_p>s_p:
print('Fennec')
else:
print('Snuke')
| # -*- coding: utf-8 -*-
#Python
import sys
N=eval(input())
adj=[[] for i in range(N+1)]
#隣接リスト
for i in range(N-1):
x,y=list(map(int,input().split()))
adj[x].append(y)
adj[y].append(x)
#print adj
#訪問判別フラグ
F=(N+1)*[0]
#Stack
S=[]
#距離
dist=(N+1)*[0]
#先頭から深さ優先探索
S.append(1)
while len(S) != 0:
#print S
v=S.pop()
#print v
if F[v]==0:
F[v]=1
#print F
for u in adj[v]:
#print "u::"+str(u)
if F[u]==0:
S.append(u)
dist[u]=dist[v]+1
#print S
#print dist
#訪問判別フラグ
F=(N+1)*[0]
#Stack
S=[]
#距離
dist2=(N+1)*[0]
#最後から深さ優先探索
S.append(N)
while len(S) != 0:
#print S
v=S.pop()
#print v
if F[v]==0:
F[v]=1
#print F
for u in adj[v]:
#print "u::"+str(u)
if F[u]==0:
S.append(u)
dist2[u]=dist2[v]+1
#print S
#print dist2
f_p=0
s_p=0
for k in range(1,N+1):
if dist[k]<=dist2[k]:
f_p+=1
else:
s_p+=1
if f_p>s_p:
print('Fennec')
else:
print('Snuke')
| p03660 |
from collections import deque
N = int(eval(input()))
G = {}
for i in range(N-1):
a,b = list(map(int,input().split()))
if a not in G:
G[a] = []
G[a].append(b)
if b not in G:
G[b] = []
G[b].append(a)
hist = [-1 for _ in range(N+1)]
heapF = deque([(1,0)])
hist[1] = 0
heapS = deque([(N,0)])
hist[N] = 1
turn = 0
while heapF or heapS:
if turn%2==0:
while heapF:
cur = heapF.popleft()
if cur[1]==turn//2:
for x in G[cur[0]]:
if hist[x]<0:
heapF.append((x,cur[1]+1))
hist[x] = 0
else:
heapF.append(cur)
break
else:
while heapS:
cur = heapS.popleft()
if cur[1]==turn//2:
for x in G[cur[0]]:
if hist[x]<0:
heapS.append((x,cur[1]+1))
hist[x] = 1
else:
heapS.append(cur)
break
turn += 1
n = hist.count(0)
m = hist.count(1)
if m>=n:
print("Snuke")
else:
print("Fennec") | from collections import deque
N = int(eval(input()))
G = {i:[] for i in range(1,N+1)}
for _ in range(N-1):
a,b = list(map(int,input().split()))
G[a].append(b)
G[b].append(a)
dist = [0 for _ in range(N+1)]
que = deque([(1,0)])
hist = [0 for _ in range(N+1)]
hist[1] = 1
while que:
x,d = que.popleft()
for y in G[x]:
if hist[y]==0:
hist[y] = 1
dist[y] = d+1
que.append((y,d+1))
pa ={}
x = N
while x!=1:
for y in G[x]:
if dist[y]==dist[x]-1:
pa[x] = y
break
x = pa[x]
ch = {}
x=N
while x!=1:
y = pa[x]
ch[y] = x
x = y
if dist[N]%2==1:
k = dist[N]//2
cnt = 0
x = 1
y = N
while cnt<k:
x = ch[x]
y = pa[y]
cnt += 1
G[x].remove(y)
G[y].remove(x)
hist = [0 for _ in range(N+1)]
que = deque([1])
hist[1] = 1
while que:
a = que.popleft()
for b in G[a]:
if hist[b]==0:
hist[b]=1
que.append(b)
n1 = sum(hist)
n2 = N-n1
if n1>n2:
print("Fennec")
else:
print("Snuke")
else:
k = dist[N]//2
cnt = 0
x = 1
while cnt<k:
x = ch[x]
cnt += 1
y = ch[x]
G[x].remove(y)
G[y].remove(x)
hist = [0 for _ in range(N+1)]
que = deque([1])
hist[1] = 1
while que:
a = que.popleft()
for b in G[a]:
if hist[b]==0:
hist[b]=1
que.append(b)
n1 = sum(hist)
n2 = N-n1
if n1>n2:
print("Fennec")
else:
print("Snuke") | p03660 |
import sys
sys.setrecursionlimit(2000000)
def input():
return sys.stdin.readline()[:-1]
n=int(eval(input()))
ab=[list(map(int,input().split())) for i in range(n-1)]
ki=[[] for i in range(n+1)]
for i in range(n-1):
ki[ab[i][0]].append(ab[i][1])
ki[ab[i][1]].append(ab[i][0])
# print(ki)
kyori=[[0,0] for i in range(n+1)]
def tansaku(m, dis, hito):
if not ki[m]:
kyori[m][hito]=dis
return
elif kyori[m][hito]!=0:
return
else:
kyori[m][hito]=dis
for i in range(len(ki[m])):
tansaku(ki[m][i], dis+1, hito)
tansaku(1,1,0)
tansaku(n,1,1)
fe,su=0,0
for i in range(1,n+1):
if kyori[i][0]<=kyori[i][1]:
fe+=1
else:
su+=1
if fe>su:
print("Fennec")
else:
print("Snuke") | import sys
sys.setrecursionlimit(2000000)
def input():
return sys.stdin.readline()[:-1]
n=int(eval(input()))
ab=[list(map(int,input().split())) for i in range(n-1)]
ki=[[] for i in range(n+1)]
for i in range(n-1):
ki[ab[i][0]].append(ab[i][1])
ki[ab[i][1]].append(ab[i][0])
# print(ki)
kyori=[[float("INF"), float("INF")] for i in range(n+1)]
def tansaku(m, dis, hito):
q=[[m,dis]]
while q:
po=q.pop()
for i in ki[po[0]]:
if kyori[i][hito]>po[1]:
kyori[i][hito]=po[1]
q.append([i,po[1]+1])
tansaku(1,1,0)
tansaku(n,1,1)
fe,su=0,0
for i in range(1,n+1):
if kyori[i][0]<=kyori[i][1]:
fe+=1
else:
su+=1
if fe>su:
print("Fennec")
else:
print("Snuke") | p03660 |
import queue
inf = float('inf')
N = int(eval(input()))
paths = [{} for i in range(N+1)]
for i in range(N-1):
s,t = list(map(int, input().split()))
paths[s][t] = 1
paths[t][s] = 1
def dijkstra(start, nodes, N):
fixed = {}
cost = [inf] * (N + 1)
cost[start] = 0
q = queue.PriorityQueue()
q.put((0, start))
while q.empty() == False:
w, x = q.get()
if cost[x] < w: continue
for y in nodes[x]:
if cost[x] + paths[x][y] < cost[y]:
cost[y] = cost[x] + paths[x][y]
q.put((cost[y], y))
return cost
# それぞれの位置からの到達コストを調べている
score_f = dijkstra(1, paths, N)
score_s = dijkstra(N, paths, N)
score = 0
for i in range(1, N+1):
if score_f[i] > score_s[i]:
score -= 1
else:
score += 1
if score > 0:
print("Fennec")
else:
print("Snuke")
| #import queue
import heapq
inf = float('inf')
N = int(eval(input()))
paths = [{} for i in range(N+1)]
for i in range(N-1):
s,t = list(map(int, input().split()))
paths[s][t] = 1
paths[t][s] = 1
def dijkstra(start, nodes, N):
cost = [inf] * (N + 1)
cost[start] = 0
q = []
heapq.heappush(q, (0, start))
# q.put((0, start))
while q: #q.empty() == False:
w, x = heapq.heappop(q)
if cost[x] < w: continue
for y in nodes[x]:
if cost[x] + paths[x][y] < cost[y]:
cost[y] = cost[x] + paths[x][y]
# q.put((cost[y], y))
heapq.heappush(q, (cost[y], y))
return cost
# それぞれの位置からの到達コストを調べている
score_f = dijkstra(1, paths, N)
score_s = dijkstra(N, paths, N)
score = 0
for i in range(1, N+1):
if score_f[i] > score_s[i]:
score -= 1
else:
score += 1
if score > 0:
print("Fennec")
else:
print("Snuke")
| p03660 |
from collections import*
n,*L=list(map(int,open(0).read().split()))
G=[[]for _ in range(n)]
for a,b in zip(*[iter(L)]*2):
G[a-1]+=[b-1]
G[b-1]+=[a-1]
def F(m):
q=deque([m])
d=[-1]*n
while q:
cur=q.popleft()
for nxt in G[cur]:
if d[nxt]<0:
q.append(nxt)
d[nxt]=d[cur]+1
return d
print(("FSennunkeec"[sum(i>j or-1 for i,j in zip(F(0),F(n-1)))>=0::2])) | from collections import deque
def F(m):
q=deque([m])
d=[-1]*n
while q:
cur=q.popleft()
for nxt in G[cur]:
if d[nxt]<0:
q.append(nxt)
d[nxt]=d[cur]+1
return d
def solve():
global n,G
n,*L=list(map(int,open(0).read().split()))
G=[[]for _ in range(n)]
for a,b in zip(*[iter(L)]*2):
G[a-1]+=[b-1]
G[b-1]+=[a-1]
print(("FSennunkeec"[sum(i>j or-1 for i,j in zip(F(0),F(n-1)))>=0::2]))
if __name__=="__main__":solve() | p03660 |
import sys
sys.setrecursionlimit(1000000000)
n = int(eval(input()))
G = [[] for _ in range(n)]
for _ in range(n-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
dist = [(0,-1) for _ in range(n)]
def dfs(now,prev=-1):
for nxt in G[now]:
if nxt == prev: continue
dist[nxt] = (dist[now][0]+1,now)
dfs(nxt,now)
dfs(0)
color = ["?"]*n
cnt = 0
now = n-1
w = (dist[n-1][0]+1)//2
while now != -1:
if cnt < w: color[now] = -1
else: color[now] = 1
cnt += 1
now = dist[now][1]
def coloring(now,prev=-1):
for nxt in G[now]:
if nxt == prev: continue
if color[nxt] != "?" and color[now] != color[nxt]: continue
color[nxt] = color[now]
coloring(nxt,now)
coloring(0)
coloring(n-1)
print(("Fennec" if sum(color) > 0 else "Snuke")) | import sys
sys.setrecursionlimit(1000000000)
n = int(eval(input()))
G = [[] for _ in range(n)]
for _ in range(n-1):
a,b = list(map(int,input().split()))
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
dist1 = [-1]*n
dist1[0] = 0
dist2 = [-1]*n
dist2[n-1] = 0
def dfs(now,dist):
for nxt in G[now]:
if dist[nxt] != -1: continue
dist[nxt] = dist[now]+1
dfs(nxt,dist)
dfs(0,dist1)
dfs(n-1,dist2)
fennec = snuke = 0
for i in range(n):
if dist1[i] <= dist2[i]: fennec += 1
else: snuke += 1
print(("Fennec" if fennec > snuke else "Snuke")) | p03660 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
def main():
n = int(eval(input()))
F = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
F[a].append(b)
F[b].append(a)
seenB = [False]*n
seenW = [False]*n
distB = [0]*n
distW = [0]*n
def dfs(v, seen, dist):
seen[v] = True
for nv in F[v]:
if seen[nv]:
continue
dist[nv] = dist[v] + 1
dfs(nv, seen, dist)
dfs(0, seenB, distB)
dfs(n-1, seenW, distW)
b, w = 0, 0
for i in range(n):
if distB[i] <= distW[i]:
b += 1
else:
w += 1
if b > w:
print("Fennec")
else:
print("Snuke")
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
n = int(eval(input()))
T = [[] for _ in range(n)]
for _ in range(n-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
T[a].append(b)
T[b].append(a)
def dfs(v):
dist = [-1]*n
dist[v] = 0
stack = [v]
while stack:
nv = stack.pop()
for i in T[nv]:
if dist[i] == -1:
dist[i] = dist[nv] + 1
stack.append(i)
return dist
B = dfs(0)
W = dfs(n-1)
cnt_b, cnt_w = 0, 0
for i in range(n):
if B[i] <= W[i]:
cnt_b += 1
else:
cnt_w += 1
if cnt_b > cnt_w:
print("Fennec")
else:
print("Snuke") | p03660 |
import sys
from collections import defaultdict
from collections import deque
n=int(eval(input()))
edges=[tuple(map(int,input().split())) for _ in range(n-1)]
d=defaultdict(list)
for e in edges:
d[e[0]].append(e[1])
d[e[1]].append(e[0])
fnc=[-1]*(n+1)
snk=[-1]*(n+1)
fnc[1]=0
snk[n]=0
cv=deque([1])
nv=deque([1])
c=-1
while nv:
c+=1
cv.extend(nv)
nv.clear()
for e in cv:
fnc[e]=c
for x in d[e]:
if fnc[x]<0:
nv.append(x)
cv.clear()
cv.append(n)
nv=deque([1])
c=-1
while nv:
c+=1
cv.extend(nv)
nv.clear()
for e in cv:
snk[e]=c
for x in d[e]:
if snk[x]<0:
nv.append(x)
cv.clear()
j=sum([(fnc[i]<=snk[i])-(fnc[i]>snk[i]) for i in range(1,n+1)])
if j>0:
print('Fennec')
else:
print('Snuke') | from collections import deque, defaultdict
def main():
n=int(eval(input()))
edges=[tuple(map(int,input().split())) for _ in range(n-1)]
d=defaultdict(list)
for e in edges:
d[e[0]].append(e[1])
d[e[1]].append(e[0])
def dist(m):
c=-1
dl=[-1]*(n+1)
cv=deque([m])
nv=deque([1])
while nv:
c+=1
cv.extend(nv)
nv.clear()
for e in cv:
dl[e]=c
for x in d[e]:
if dl[x]<0:
nv.append(x)
cv.clear()
return dl[1:]
fnc=dist(1)
snk=dist(n)
j=sum([(fnc[i]<=snk[i])-(fnc[i]>snk[i]) for i in range(n)])
if j>0:
print('Fennec')
else:
print('Snuke')
if __name__=='__main__':
main()
| p03660 |
#
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [eval(input()) for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N = I()
edge = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = MI_()
edge[a].append(b)
edge[b].append(a)
set_A = set()
set_B = set()
a_stack = [0]
b_stack = [N - 1]
for _ in range(N - 1):
tmp_a = []
tmp_b = []
while a_stack:
from_ = a_stack.pop()
for to in edge[from_]:
if to not in set_B:
tmp_a.append(to)
set_A.add(to)
while b_stack:
from_ = b_stack.pop()
for to in edge[from_]:
if to not in set_A:
tmp_b.append(to)
set_B.add(to)
a_stack = tmp_a
b_stack = tmp_b
if len(set_A) > len(set_B):
print("Fennec")
else:
print("Snuke")
if __name__ == '__main__':
main() | #
# ⋀_⋀
# (･ω･)
# .／ Ｕ ∽ Ｕ＼
# │＊ 合 ＊│
# │＊ 格 ＊│
# │＊ 祈 ＊│
# │＊ 願 ＊│
# │＊ ＊│
# ￣
#
import sys
input=sys.stdin.readline
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float, input().split()))
def MI_(): return list(map(INT_,input().split()))
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [eval(input()) for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def I(): return int(eval(input()))
def F(): return float(eval(input()))
def ST(): return input().replace('\n', '')
def main():
N = I()
edge = [[] for _ in range(N)]
for _ in range(N - 1):
a, b = MI_()
edge[a].append(b)
edge[b].append(a)
set_A = set()
set_B = set()
a_stack = [0]
b_stack = [N - 1]
for _ in range(N - 1):
tmp_a = []
tmp_b = []
while a_stack:
from_ = a_stack.pop()
for to in edge[from_]:
if to not in set_A and to not in set_B:
tmp_a.append(to)
set_A.add(to)
while b_stack:
from_ = b_stack.pop()
for to in edge[from_]:
if to not in set_A and to not in set_B:
tmp_b.append(to)
set_B.add(to)
a_stack = tmp_a
b_stack = tmp_b
if len(set_A) > len(set_B):
print("Fennec")
else:
print("Snuke")
if __name__ == '__main__':
main() | p03660 |
#高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=deque([(0,point)])
while Q:
c,p = Q.popleft()
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
Q.append((c+1,np))
return cost
n=int(eval(input()))
d={}
for i in range(n-1):
a,b=list(map(int,input().split()))
if a in list(d.keys()):
d[a].append(b)
else:
d[a]=[b]
if b in list(d.keys()):
d[b].append(a)
else:
d[b]=[a]
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| #高速化heapqダイクストラ
from collections import *
from heapq import*
import sys
input=lambda:sys.stdin.readline()
def BFS(point,d):
cost=[1e7]*(n+1)
cost[point]=0
Q=deque([(0,point)])
while Q:
c,p = Q.popleft()
for np in d[p]:
if cost[np]==1e7:
cost[np]=c+1
Q.append((c+1,np))
return cost
n=int(eval(input()))
# d={}
d=[[] for _ in range(n+1)]
for i in range(n-1):
a,b=list(map(int,input().split()))
d[a].append(b)
d[b].append(a)
# if a in d.keys():
# d[a].append(b)
# else:
# d[a]=[b]
# if b in d.keys():
# d[b].append(a)
# else:
# d[b]=[a]
x=BFS(1,d)[1:]
y=BFS(n,d)[1:]
#print(x,y)
F=0
S=0
for s,t in zip(x,y):
if s<=t:
F+=1
else:
S+=1
if F<=S:
print("Snuke")
else:
print("Fennec")
| p03660 |
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
def killme(num,lis):
visited[num]=1
if num==N-1:
lis.append(num)
for index,item in enumerate(lis):
highway[item]=index
else:
for next_n in way[num]:
if visited[next_n]==0:
killme(next_n,lis+[num])
return
def dfs(num,root):
visited[num]=1
cluster[root].append(num)
for next_n in way[num]:
if visited[next_n]==0 and highway[next_n]==-1:
#print(next_n,root)
dfs(next_n,root)
return
N=int(eval(input()))
way=[[] for i in range(N)]
visited=[0]*N
highway=[-1]*N
for _ in range(N-1):
a,b=list(map(int,input().split()))
way[a-1].append(b-1)
way[b-1].append(a-1)
killme(0,[])
#print(way)
#print(visited)
#print(highway)
visited=[0]*N
cluster=[[] for i in range(highway[-1]+1)]
for index,item in enumerate(highway):
if item!=-1:
dfs(index,item)
F=0
S=0
for i in range(highway[-1]+1):
if i<=highway[-1]//2:
F+=len(cluster[i])
else:
S+=len(cluster[i])
if F>S:
print("Fennec")
else:
print("Snuke")
#print(F,S)
| # coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**6)
def killme(num,lis):
visited[num]=1
if num==N-1:
lis.append(num)
for index,item in enumerate(lis):
highway[item]=index
else:
for next_n in way[num]:
if visited[next_n]==0:
lis.append(num)
killme(next_n,lis)
lis.pop(-1)
return
def dfs(num,root):
visited[num]=1
cluster[root].append(num)
for next_n in way[num]:
if visited[next_n]==0 and highway[next_n]==-1:
#print(next_n,root)
dfs(next_n,root)
return
N=int(eval(input()))
way=[[] for i in range(N)]
visited=[0]*N
highway=[-1]*N
for _ in range(N-1):
a,b=list(map(int,input().split()))
way[a-1].append(b-1)
way[b-1].append(a-1)
killme(0,[])
#print(way)
#print(visited)
#print(highway)
visited=[0]*N
cluster=[[] for i in range(highway[-1]+1)]
for index,item in enumerate(highway):
if item!=-1:
dfs(index,item)
F=0
S=0
for i in range(highway[-1]+1):
if i<=highway[-1]//2:
F+=len(cluster[i])
else:
S+=len(cluster[i])
if F>S:
print("Fennec")
else:
print("Snuke")
#print(F,S)
| p03660 |
N=int(eval(input()))
import collections
import heapq
ab=[tuple(map(int,input().split())) for i in range(N-1)]
G=[set() for i in range(N)]
for a,b in ab:
a-=1
b-=1
G[a].add(b)
G[b].add(a)
q=collections.deque()
dis=[[-1]*N for i in range(2)]
dis[0][0]=0
q.append(0)
while(q):
x=q.popleft()
for y in G[x]:
if dis[0][y]==-1:
q.append(y)
dis[0][y]=dis[0][x]+1
dis[1][N-1]=0
q.append(N-1)
while(q):
x=q.popleft()
for y in G[x]:
if dis[1][y]==-1:
q.append(y)
dis[1][y]=dis[1][x]+1
hqF=[(0,0)]
hqS=[(0,N-1)]
colord=[False]*N
while(1):
if len(hqF)==0:
print("Snuke")
exit(0)
_,x = heapq.heappop(hqF)
while(colord[x]):
if hqF:
_,x = heapq.heappop(hqF)
else:
print("Snuke")
exit(0)
colord[x]=True
for y in G[x]:
if colord[y]==False:
heapq.heappush(hqF,(dis[1][y],y))
if len(hqS)==0:
print("Fennec")
exit(0)
_,x = heapq.heappop(hqS)
while(colord[x]):
if hqF:
_,x = heapq.heappop(hqS)
else:
print("Fennec")
exit(0)
colord[x]=True
for y in G[x]:
if colord[y]==False:
heapq.heappush(hqS,(dis[0][y],y))
| import collections
N = int(eval(input()))
G = [set() for i in range(N)]
for i in range(N-1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
G[a].add(b)
G[b].add(a)
F = [-1]*N
F[0] = 0
q = collections.deque()
q.append(0)
while(q):
x = q.popleft()
for y in G[x]:
if F[y] < 0:
F[y] = F[x] + 1
q.append(y)
S = [-1]*N
S[N-1] = 0
q.append(N-1)
while(q):
x = q.popleft()
for y in G[x]:
if S[y] < 0:
S[y] = S[x] + 1
q.append(y)
# print(F)
# print(S)
ans = 0
q = collections.deque()
r = [True]*N
for i in range(N):
if F[i] + S[i] == F[-1]:
if F[i] <= S[i]:
q.append(i)
r[i] = False
else:
r[i] = False
ans = len(q)
while(q):
x = q.popleft()
for y in G[x]:
if r[y]:
ans += 1
q.append(y)
r[y] = False
if ans > N - ans:
print("Fennec")
else:
print("Snuke")
| p03660 |
n = int(eval(input()))
p = [ [] for _ in range(n) ]
for i in range(n - 1):
a, b = list(map(int, input().split()))
p[a - 1].append(b - 1)
p[b - 1].append(a - 1)
f = [[0], []]
d = 1
f[1] = f[1] + p[0]
while 1:
if n - 1 in f[d]:
break
temp = []
for i in f[d]:
temp = [] + p[i]
temp = list(set(temp))
f.append([])
d += 1
f[d] = [] + temp
route = [n - 1]
t = n - 1
for i in range(d, 0, -1):
for j in f[i - 1]:
if t in p[j]:
t = j
route.append(t)
#print(f)
#print(route)
mid = route[ len(route) // 2 - 1 ]
#print(mid)
f = [[0], []]
d = 1
f[1] = f[1] + p[0]
check = 1
if mid in f[1]:
f[1].remove(mid)
if len(f[1]) == 0:
check = 0
while check:
temp = []
for i in f[d]:
temp = [] + p[i]
temp = list(set(temp))
if mid in temp:
temp.remove(mid)
for i in f[d - 1]:
if i in temp:
temp.remove(i)
if len(temp) == 0:
break
f.append([])
d += 1
f[d] = [] + temp
fe = sum(len(v) for v in f)
mid = route[ len(route) // 2 ]
f = [[n - 1], []]
d = 1
f[1] = f[1] + p[n - 1]
check = 1
if mid in f[1]:
f[1].remove(mid)
if len(f[1]) == 0:
check = 0
while check:
temp = []
for i in f[d]:
temp = [] + p[i]
temp = list(set(temp))
if mid in temp:
temp.remove(mid)
for i in f[d - 1]:
if i in temp:
temp.remove(i)
if len(temp) == 0:
break
f.append([])
d += 1
f[d] = [] + temp
sn = sum(len(v) for v in f)
if fe > sn:
print("Fennec")
else:
print("Snuke") | n = int(eval(input()))
p = [[] for _ in range(n)]
for i in range(n - 1):
x, y = list(map(int, input().split()))
p[x - 1].append(y - 1)
p[y - 1].append(x - 1)
f = [n for _ in range(n)]
s = [n for _ in range(n)]
f[0] = 0
after = [] + p[0]
before = set()
dist = 0
while 1:
dist += 1
check = 0
temp = []
for x in after:
if f[x] == n:
f[x] = dist
temp += p[x]
check = 1
if check == 0:
break
t2 = set(temp) - before
before = set(after)
after = list(t2)
s[n - 1] = 0
after = [] + p[n - 1]
before = set()
dist = 0
while 1:
dist += 1
check = 0
temp = []
for x in after:
if s[x] == n:
s[x] = dist
temp += p[x]
check = 1
if check == 0:
break
t2 = set(temp) - before
before = set(after)
after = list(t2)
score_f = 0
for i in range(n):
if f[i] <= s[i]:
score_f += 1
if score_f > n - score_f:
print('Fennec')
else:
print('Snuke')
| p03660 |
from collections import defaultdict,Counter
import queue
N=int(eval(input()))
ab=defaultdict(list)
for i in range(N-1):
a,b=list(map(int,input().split()))
ab[a].append(b)
ab[b].append(a)
q1=queue.Queue()
qN=queue.Queue()
dist=[None for i in range(N)]
dist[0]=1
dist[N-1]=-1
phase=1
F=0
S=0
for i in ab[1]:
q1.put((i,phase))
F+=1
for g in ab[N]:
qN.put((g,phase))
S+=1
while not (q1.empty() and qN.empty()):
while True:
if q1.empty():
break
next1,p=q1.queue[0]
if p==phase:
if dist[next1-1]==None:
F+=1
dist[next1-1]=1
next1,p=q1.get()
for i in ab[next1]:
if dist[i-1]==None:
q1.put((i,phase+1))
else:
break
while True:
if qN.empty():
break
nextN,p=qN.queue[0]
if p==phase:
if dist[nextN-1]==None:
S+=1
dist[nextN-1]=-1
nextN,p=qN.get()
for i in ab[nextN]:
if dist[i-1]==None:
qN.put((i,phase+1))
else:
break
phase+=1
c=Counter(dist)
if c[-1]<c[1]:
print("Fennec")
else:
print("Snuke") | from collections import defaultdict,Counter
import queue
N=int(eval(input()))
ab=defaultdict(list)
for i in range(N-1):
a,b=list(map(int,input().split()))
ab[a].append(b)
ab[b].append(a)
q1=queue.Queue()
qN=queue.Queue()
dist=[None for i in range(N)]
dist[0]=1
dist[N-1]=-1
phase=1
for i in ab[1]:
q1.put((i,phase))
for g in ab[N]:
qN.put((g,phase))
while not (q1.empty() and qN.empty()):
while True:
if q1.empty():
break
next1,p=q1.queue[0]
if p==phase:
if dist[next1-1]==None:
dist[next1-1]=1
next1,p=q1.get()
for i in ab[next1]:
if dist[i-1]==None:
q1.put((i,phase+1))
else:
break
while True:
if qN.empty():
break
nextN,p=qN.queue[0]
if p==phase:
if dist[nextN-1]==None:
dist[nextN-1]=-1
nextN,p=qN.get()
for i in ab[nextN]:
if dist[i-1]==None:
qN.put((i,phase+1))
else:
break
phase+=1
c=Counter(dist)
if c[-1]<c[1]:
print("Fennec")
else:
print("Snuke") | p03660 |
from collections import deque
N = int(eval(input()))
neighbor = [[0]*N for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
neighbor[a-1][b-1] = 1
neighbor[b-1][a-1] = 1
# 黒を0、白を1、未着色を-1で表す
black_white = [0] + [-1]*(N-2) + [1]
# 点iを与えると、点iからの最短距離のリストを返す
def shortest_distance(home_point):
shortest_distance_list = [-1]*N
shortest_distance_list[home_point] = 0
visited = [0]*N
visited[home_point] = 1
next_points = deque([home_point])
while len(next_points) > 0:
p = next_points.popleft()
visited[p] = 1
for idx in range(N):
if neighbor[p][idx] > 0 and visited[idx] == 0:
shortest_distance_list[idx] = shortest_distance_list[p]+1
if idx not in next_points:
next_points.append(idx)
return shortest_distance_list
shortest_distance_from_Fennec = shortest_distance(0)
shortest_distance_from_Snuke = shortest_distance(N-1)
for idx in range(1,N-1):
if shortest_distance_from_Fennec[idx] <= shortest_distance_from_Snuke[idx]:
black_white[idx] = 0
else:
black_white[idx] = 1
print(("Fennec" if black_white.count(0) > black_white.count(1) else "Snuke"))
| from collections import deque
N = int(eval(input()))
neighbor = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
neighbor[a-1].append(b-1)
neighbor[b-1].append(a-1)
# 黒を0、白を1、未着色を-1で表す
black_white = [0] + [-1]*(N-2) + [1]
# 点iを与えると、点iからの最短距離のリストを返す
def shortest_distance(home_point):
shortest_distance_list = [-1]*N
shortest_distance_list[home_point] = 0
visited = [0]*N
visited[home_point] = 1
next_points = deque([home_point])
while len(next_points) > 0:
p = next_points.popleft()
visited[p] = 1
for idx in neighbor[p]:
if visited[idx] == 0:
shortest_distance_list[idx] = shortest_distance_list[p]+1
if idx not in next_points:
next_points.append(idx)
return shortest_distance_list
shortest_distance_from_Fennec = shortest_distance(0)
shortest_distance_from_Snuke = shortest_distance(N-1)
for idx in range(1,N-1):
if shortest_distance_from_Fennec[idx] <= shortest_distance_from_Snuke[idx]:
black_white[idx] = 0
else:
black_white[idx] = 1
print(("Fennec" if black_white.count(0) > black_white.count(1) else "Snuke"))
| p03660 |
from collections import deque
N = int(eval(input()))
neighbor = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
neighbor[a-1].append(b-1)
neighbor[b-1].append(a-1)
# 黒を0、白を1、未着色を-1で表す
black_white = [0] + [-1]*(N-2) + [1]
# 点iを与えると、点iからの最短距離のリストを返す
def shortest_distance(home_point):
shortest_distance_list = [-1]*N
shortest_distance_list[home_point] = 0
visited = [0]*N
visited[home_point] = 1
next_points = deque([home_point])
while len(next_points) > 0:
p = next_points.popleft()
visited[p] = 1
for idx in neighbor[p]:
if visited[idx] == 0:
shortest_distance_list[idx] = shortest_distance_list[p]+1
if idx not in next_points:
next_points.append(idx)
return shortest_distance_list
shortest_distance_from_Fennec = shortest_distance(0)
shortest_distance_from_Snuke = shortest_distance(N-1)
for idx in range(1,N-1):
if shortest_distance_from_Fennec[idx] <= shortest_distance_from_Snuke[idx]:
black_white[idx] = 0
else:
black_white[idx] = 1
print(("Fennec" if black_white.count(0) > black_white.count(1) else "Snuke"))
| from collections import deque
N = int(eval(input()))
neighbor = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
neighbor[a-1].append(b-1)
neighbor[b-1].append(a-1)
# 黒を0、白を1、未着色を-1で表す
black_white = [0] + [-1]*(N-2) + [1]
# 点iを与えると、点iからの最短距離のリストを返す
def shortest_distance(home_point):
shortest_distance_list = [-1]*N
shortest_distance_list[home_point] = 0
next_points = deque([home_point])
while len(next_points) > 0:
p = next_points.popleft()
for idx in neighbor[p]:
if shortest_distance_list[idx] == -1:
shortest_distance_list[idx] = shortest_distance_list[p]+1
next_points.append(idx)
return shortest_distance_list
shortest_distance_from_Fennec = shortest_distance(0)
shortest_distance_from_Snuke = shortest_distance(N-1)
for idx in range(1,N-1):
if shortest_distance_from_Fennec[idx] <= shortest_distance_from_Snuke[idx]:
black_white[idx] = 0
else:
black_white[idx] = 1
print(("Fennec" if black_white.count(0) > black_white.count(1) else "Snuke"))
| p03660 |
N=int(eval(input()))
E=[[] for i in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
a,b=a-1,b-1
E[a].append(b)
E[b].append(a)
stack=[]
import copy
stack.append([0,[],-1])
Nhalf=None
while stack:
node=stack.pop()
v=node[0]
route=node[1]
parent=node[2]
if v==N-1:
route.append(v)
if len(route)%2==0:
Nhalf=route[len(route)//2-1]
NhalfNext=route[len(route)//2]
else:
Nhalf=route[len(route)//2]
NhalfNext=route[len(route)//2+1]
E[Nhalf].remove(NhalfNext)
E[NhalfNext].remove(Nhalf)
break
route.append(v)
childs=E[v]
for child in childs:
if child==parent:
continue
newroute=copy.copy(route)
stack.append([child,newroute,v])
del route
stack=[]
stack.append([0,-1])
count=0
while stack:
node=stack.pop()
v=node[0]
parent=node[1]
count+=1
childs=E[v]
if childs==None:
continue
for child in childs:
if child==parent:
continue
stack.append([child,v])
if count>N-count:
print("Fennec")
else:
print("Snuke") | N=int(eval(input()))
E=[[] for i in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
a,b=a-1,b-1
E[a].append(b)
E[b].append(a)
F=[0]*N
S=[0]*N
stack=[]
# 番号、距離、親
stack.append([0,0,-1])
while stack:
node=stack.pop()
v=node[0]
dist=node[1]
parent=node[2]
F[v]=dist
childs=E[v]
for child in childs:
if child==parent:
continue
stack.append([child,dist+1,v])
stack=[]
# 番号、距離、親
stack.append([N-1,0,-1])
while stack:
node=stack.pop()
v=node[0]
dist=node[1]
parent=node[2]
S[v]=dist
childs=E[v]
for child in childs:
if child==parent:
continue
stack.append([child,dist+1,v])
FenWin=0
SunWin=0
for i in range(N):
if F[i]<=S[i]:
FenWin+=1
else:
SunWin+=1
print((("Snuke","Fennec")[FenWin>SunWin])) | p03660 |
N=int(eval(input()))
E=[[] for i in range(N)]
for i in range(N-1):
a,b=list(map(int,input().split()))
a,b=a-1,b-1
E[a].append(b)
E[b].append(a)
F=[0]*N
S=[0]*N
stack=[]
# 番号、距離、親
stack.append([0,0,-1])
while stack:
node=stack.pop()
v=node[0]
dist=node[1]
parent=node[2]
F[v]=dist
childs=E[v]
for child in childs:
if child==parent:
continue
stack.append([child,dist+1,v])
stack=[]
# 番号、距離、親
stack.append([N-1,0,-1])
while stack:
node=stack.pop()
v=node[0]
dist=node[1]
parent=node[2]
S[v]=dist
childs=E[v]
for child in childs:
if child==parent:
continue
stack.append([child,dist+1,v])
FenWin=0
SunWin=0
for i in range(N):
if F[i]<=S[i]:
FenWin+=1
else:
SunWin+=1
print((("Snuke","Fennec")[FenWin>SunWin])) | # 全ての頂点について、フェネックからの距離とすぬけくんからの距離を求める
# フェネックからの距離 <= すぬけくんから距離 の頂点は黒 そうでなければ白
import sys
readline = sys.stdin.readline
N = int(readline())
G = [[] for i in range(N)]
for i in range(N - 1):
a,b = list(map(int,readline().split()))
G[a - 1].append(b - 1)
G[b - 1].append(a - 1)
dist_from_fen = [-1 for i in range(N)]
dist_from_snk = [-1 for i in range(N)]
stack = []
# 頂点、距離、親
stack.append([0,0,-1])
while stack:
v,dist,parent = stack.pop()
dist_from_fen[v] = dist
for child in G[v]:
if child == parent:
continue
stack.append([child,dist + 1,v])
stack = []
stack.append([N - 1,0,-1])
while stack:
v,dist,parent = stack.pop()
dist_from_snk[v] = dist
for child in G[v]:
if child == parent:
continue
stack.append([child,dist + 1,v])
black = 0
white = 0
for i in range(N):
if dist_from_fen[i] <= dist_from_snk[i]:
black += 1
else:
white += 1
print((("Snuke","Fennec")[black > white])) | p03660 |
n = int(eval(input()))
d = [[float("inf")]*n for i in range(n)]
ab = [tuple(map(int,input().split())) for i in range(n-1)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
INF = float('inf')
dist0 = [INF] * n
dist0[0] = 0
import heapq
hq = [(0,0)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to in es[v]:
if c+1 >= dist0[to]: continue
dist0[to] = c+1
heapq.heappush(hq,(c+1,to))
distn = [INF] * n
distn[n-1] = 0
hq = [(0,n-1)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to in es[v]:
if c+1 >= distn[to]: continue
distn[to] = c+1
heapq.heappush(hq,(c+1,to))
count_f = 0
for i in range(n):
if dist0[i] <= distn[i]:
count_f+=1
if count_f > n-count_f: print('Fennec')
else: print('Snuke')
| n = int(eval(input()))
d = [[float("inf")]*n for i in range(n)]
ab = [tuple(map(int,input().split())) for i in range(n-1)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
INF = float('inf')
dist0 = [INF] * n
dist0[0] = 0
visited0 = [0]*n
def dfs0(v, parent = -1):
if dist0[v] == INF:
dist0[v] = dist0[parent]+1
for next_v in es[v]:
if dist0[next_v] == INF:
dfs0(next_v,v)
dfs0(0)
distn = [INF] * n
distn[n-1] = 0
visitedn = [0]*n
def dfsn(v, parent = -1):
if distn[v] == INF:
distn[v] = distn[parent]+1
for next_v in es[v]:
if distn[next_v] == INF:
dfsn(next_v,v)
dfsn(n-1)
count_f = 0
for i in range(n):
if dist0[i] <= distn[i]:
count_f+=1
if count_f > n-count_f: print('Fennec')
else: print('Snuke')
| p03660 |
from functools import lru_cache
n = int(eval(input()))
d = [[float("inf")]*n for i in range(n)]
ab = [tuple(map(int,input().split())) for i in range(n-1)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
INF = float('inf')
dist0 = [INF] * n
dist0[0] = 0
visited0 = [0]*n
@lru_cache(None)
def dfs0(v, parent = -1):
if dist0[v] == INF:
dist0[v] = dist0[parent]+1
for next_v in es[v]:
if dist0[next_v] == INF:
dfs0(next_v,v)
dfs0(0)
distn = [INF] * n
distn[n-1] = 0
visitedn = [0]*n
@lru_cache(None)
def dfsn(v, parent = -1):
if distn[v] == INF:
distn[v] = distn[parent]+1
for next_v in es[v]:
if distn[next_v] == INF:
dfsn(next_v,v)
dfsn(n-1)
count_f = 0
for i in range(n):
if dist0[i] <= distn[i]:
count_f+=1
if count_f > n-count_f: print('Fennec')
else: print('Snuke')
| n = int(eval(input()))
ab = [tuple(map(int,input().split())) for i in range(n-1)]
es = [[] for i in range(n)]
for a,b in ab:
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
INF = float('inf')
dist0 = [INF] * n
dist0[0] = 0
import heapq
hq = [(0,0)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to in es[v]:
if c+1 >= dist0[to]: continue
dist0[to] = c+1
heapq.heappush(hq,(c+1,to))
distn = [INF] * n
distn[n-1] = 0
hq = [(0,n-1)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to in es[v]:
if c+1 >= distn[to]: continue
distn[to] = c+1
heapq.heappush(hq,(c+1,to))
count_f = 0
for i in range(n):
if dist0[i] <= distn[i]:
count_f+=1
if count_f > n-count_f: print('Fennec')
else: print('Snuke')
| p03660 |
s = input()
s_len = len(s)
while True:
s_len_old = s_len
s_list = list(s)
for i in range(len(s_list) - 1):
if s[i] == 'S' and s[i + 1] == 'T':
s_len -= 2
s_list[i] = ''
s_list[i + 1] = ''
for j in range(1, i + 1):
if s_list[i - j] == 'S' and s_list[i + j + 1] == 'T':
s_len -= 2
s_list[i - j] = ''
s_list[i + j + 1] = ''
else:
break
if s_len_old == s_len:
break
else:
s = ''.join(s_list)
print(s_len) | input_string = input()
s_num = 0
str_len = len(input_string)
for c in input_string:
if c == 'S':
s_num += 1
elif c == 'T':
if s_num > 0:
s_num -= 1
str_len -= 2
print(str_len) | p03986 |
import sys
from collections import deque
X = list(sys.stdin.readline().strip())
s = []
q = deque(X)
while q:
char = q.popleft()
if len(s) == 0:
s.append(char)
continue
if char == "T" and s[-1] == "S":
s.pop()
else:
s.append(char)
print((len(s))) | import sys
X = sys.stdin.readline().strip()
lx = len(X)
stack = []
pop_n = 0
for c in X:
if c == "S":
stack.append(c)
elif c == "T" and 0 < len(stack):
stack.pop()
pop_n += 1
print((lx - 2 * pop_n)) | p03986 |
# AGC005A - STring
def main():
X = input().rstrip()
ans, s, t = 0, 0, 0
for i in X:
if i == "S":
s += 1
else:
if t < s:
t += 1
else:
ans += 1
ans += s - t
print(ans)
if __name__ == "__main__":
main() | # AGC005A - STring
def main():
X = input().rstrip()
ans, p = 0, 0 # pair
for i in X:
if i == "S":
p += 1
else:
if p:
p -= 1
else:
ans += 1 # remaining T
ans += p # add remaining S
print(ans)
if __name__ == "__main__":
main() | p03986 |
#!/usr/bin/env python
s = input()
s1 = []
for x in s:
if not s1:
s1.append(x)
continue
if x == 'T' and s1[-1] == 'S':
s1 = s1[:-1]
else:
s1.append(x)
print(len(s1))
| ipt = input()
l = ""
for s in ipt:
if not l:
l += s
elif l[-1]+s == "ST":
l = l[:-1]
else:
l += s
print(len(l)) | p03986 |
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
X = input().strip()
while X.count("ST"):
a = X.find("ST")
X = X[:a] + X[a + 2:]
print((len(X)))
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
X = input().strip()
scount = 0
ans = 0
for s in X:
if s == "S":
scount += 1
elif s == "T":
if scount == 0:
continue
else:
scount -= 1
ans += 2
print((len(X) - ans))
if __name__ == '__main__':
main()
| p03986 |
s=input()
while True:
f=0
for i in range(len(s)-1):
if s[i]=="S" and s[i+1]=="T":
s=s[0:i]+s[i+2:len(s)]
f=1
break
if f==0:
break
print((len(s))) | s=input()
stack=[]
for i in range(len(s)):
if len(stack)==0 or s[i]=="S":
stack.append(s[i])
continue
if s[i]=="T":
if stack[-1]=="S":
stack.pop()
else:
stack.append(s[i])
print((len(stack))) | p03986 |
s=input()
stack=[]
for i in range(len(s)):
if len(stack)==0 or s[i]=="S":
stack.append(s[i])
continue
if s[i]=="T":
if stack[-1]=="S":
stack.pop()
else:
stack.append(s[i])
print((len(stack))) | x = input()
stack = []
ans = 0
for i in range(len(x)):
if x[i] == "S":
stack.append("S")
else:
if len(stack) == 0:
ans += 1
else:
stack.pop()
print(ans + len(stack))
| p03986 |
import sys
def main():
N = input().strip()
while True:
ngram_list=[]
#round 1
for i in range(len(N)-1):
ngram_list.append(N[i:i+2])
#round 2
if "ST" in ngram_list:
idx=ngram_list.index("ST")
if idx+2 > len(N):
N = N[:idx]
else:
N=N[:idx]+N[idx+2:]
else:
return print(len(N))
if __name__ == "__main__":
main()
| def main():
N = input().strip()
stack = []
for s in N:
if len(stack)==0:
stack.append(s)
elif stack[-1]=="S" and s=="T":
stack.pop()
else:
stack.append(s)
print((len(stack)))
if __name__ == "__main__":
main() | p03986 |
from sys import stdin
X = (stdin.readline().rstrip())
for i in range(10**6):
X = X.replace("ST","")
print((len(X))) | from sys import stdin
from collections import deque
X = (stdin.readline().rstrip())
stack = []
for i in X:
if i == "S":
stack.append(i)
elif (i == "T" and stack == []):
stack.append(i)
elif (i == "T" and stack[-1] == "S"):
stack.pop()
else:
stack.append(i)
print((len(stack))) | p03986 |
X = input().strip()
i = 0
while i<len(X):
if X[i:i+2]=="ST":
X = X[:i]+X[i+2:]
i -= 1
else:
i += 1
print((len(X))) | X = input().strip()
cnt = 0
cntmax = 0
for i in range(len(X)):
if X[i]=="T":
cnt += 1
cntmax = max(cntmax,cnt)
else:
cnt -= 1
print((cntmax*2)) | p03986 |
s = input()
while 1:
result = s.replace("ST", "")
if result == s:
s = result
break
else: s = result
print(len(s))
| s = input()
T = S = 0
for i in s:
if i == "T":
if S: S -= 1
else: T += 1
elif i == "S":
S += 1
print(T + S)
| p03986 |
s = input()
while s.find('ST') > -1:
s = ''.join(s.split('ST'))
print(len(s)) | s = input()
#while s.find('ST') > -1:
# s = ''.join(s.split('ST'))
#
#print len(s)
temp = []
for i in range(len(s)):
now = s[i]
if len(temp) == 0:
temp.append(now)
elif temp[-1] + now == 'ST':
temp.pop()
else:
temp.append(now)
print(len(temp)) | p03986 |
#AGC005A
x=input()
while x.count('ST')>0:
x=x.replace('ST','')
print(len(x))
| #AGC005A
s=input()
res=0
for c in s:
if c=='S':
res+=1
elif c=='T' and res>0:
res-=1
print(res*2)
| p03986 |
s = ''.join(input().split('ST'))
while 1:
i = s.find('ST')
if i > -1:
cnt = 0
for j in range(min(i, len(s)-2-i)):
if s[i-j-1] == 'S' and s[i+j+2] == 'T':
cnt += 1
else:
break
s = s[:i-cnt] + s[i+cnt+2:]
else:
break
print((len(s))) | s = ''.join(input().split('ST'))
cnts = 0
cnt = 0
for i in s:
if i == 'S' :
cnts += 1
elif cnts > 0:
cnts -= 1
cnt += 1
print((len(s)-cnt*2)) | p03986 |
s = ''.join(input().split('ST'))
cnts = 0
cnt = 0
for i in s:
if i == 'S' :
cnts += 1
elif cnts > 0:
cnts -= 1
cnt += 1
print((len(s)-cnt*2)) | def main():
s = input().replace('ST', '')
cnts = 0
cnt = 0
for i in s:
if i == 'S':
cnts += 1
elif cnts > 0:
cnts -= 1
cnt += 1
print((len(s)-cnt*2))
if __name__ == '__main__':
main() | p03986 |
from queue import Queue as q
from copy import deepcopy as cp
def l_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if j == 0 or field[i][j-1] == 1 or n == 0:
return(None)
field = cp(field)
field[i][j] = 0
while(j):
if field[i][j-1] == 0:
j -= 1
elif field[i][j-1] == 3:
flag = True
print((11-n))
return(None)
else:
field[i][j-1] = 0
field[i][j] = 2
n -= 1
return([field,n,i,j])
return(None)
def u_move(data):
global x
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if i == 0 or field[i-1][j] == 1 or n == 0:
return(None)
field = cp(field)
field[i][j] = 0
while(i):
if field[i-1][j] == 0:
i -= 1
elif field[i-1][j] == 3:
flag = True
print((11-n))
return(None)
else:
field[i-1][j] = 0
field[i][j] = 2
n -= 1
return([field,n,i,j])
return(None)
def r_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
global y
if j == y-1 or field[i][j+1] == 1 or n == 0:
return(None)
field = cp(field)
while(j < y-1):
if field[i][j+1] == 0:
j += 1
elif field[i][j+1] == 3:
flag = True
print((11-n))
return(None)
else:
field[i][j+1] = 0
field[i][j] = 2
n -= 1
return([field,n,i,j])
return(None)
def d_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
global x
if i == x-1 or field[i+1][j] == 1 or n == 0:
return(None)
field = cp(field)
while(i < x-1):
if field[i+1][j] == 0:
i += 1
elif field[i+1][j] == 3:
flag = True
print((11-n))
return(None)
else:
field[i+1][j] = 0
field[i][j] = 2
n -= 1
return([field,n,i,j])
return(None)
while(True):
flag = False
y,x = list(map(int,input().split()))
lis = q()
if x == 0:
break
field = []
for i in range(x):
field.append(list(map(int, input().split())))
for i in range(x):
for j in range(y):
if field[i][j] == 2:
start_x, start_y = i,j
data = [field,10,start_x,start_y]
lis.put(data)
while(lis.qsize()):
d = lis.get()
tmp = l_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = u_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = d_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = r_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
if not flag:
print((-1))
| from queue import Queue as q
from copy import deepcopy as cp
def l_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if j == 0 or field[i][j-1] == 1 or n == 0:
return(None)
while(j):
if field[i][j-1] == 0:
j -= 1
elif field[i][j-1] == 3:
flag = True
print((11-n))
return(None)
else:
nfield = field[:i] + [field[i][:j-1] + [0] + field[i][j:]] + field[i+1:]
n -= 1
return([nfield,n,i,j])
return(None)
def u_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if i == 0 or field[i-1][j] == 1 or n == 0:
return(None)
while(i):
if field[i-1][j] == 0:
i -= 1
elif field[i-1][j] == 3:
flag = True
print((11-n))
return(None)
else:
nfield = field[:i-1] + [field[i-1][:j] + [0] + field[i-1][j+1:]] + field[i:]
n -= 1
return([nfield,n,i,j])
return(None)
def r_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if j == y-1 or field[i][j+1] == 1 or n == 0:
return(None)
while(j < y-1):
if field[i][j+1] == 0:
j += 1
elif field[i][j+1] == 3:
flag = True
print((11-n))
return(None)
else:
nfield = field[:i] + [field[i][:j+1] + [0] + field[i][j+2:]] + field[i+1:]
n -= 1
return([nfield,n,i,j])
return(None)
def d_move(data):
global flag
field,n,i,j = data[0],data[1],data[2],data[3]
if i == x-1 or field[i+1][j] == 1 or n == 0:
return(None)
while(i < x-1):
if field[i+1][j] == 0:
i += 1
elif field[i+1][j] == 3:
flag = True
print((11-n))
return(None)
else:
nfield = field[:i+1] + [field[i+1][:j] + [0] + field[i+1][j+1:]] + field[i+2:]
n -= 1
return([nfield,n,i,j])
return(None)
while(True):
flag = False
y,x = list(map(int,input().split()))
lis = q()
if x == 0:
break
field = []
for i in range(x):
field.append(list(map(int, input().split())))
for i in range(x):
for j in range(y):
if field[i][j] == 2:
start_x, start_y = i,j
field[i][j] = 0
data = [field,10,start_x,start_y]
lis.put(data)
while(lis.qsize()):
d = lis.get()
tmp = l_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = u_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = d_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
tmp = r_move(d)
if flag:
break
if tmp != None:
lis.put(tmp)
if not flag:
print((-1))
| p00725 |
import collections
import copy
import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
drc = [(0, -1), (1, 0), (0, 1), (-1, 0)]
def in_board(r, c):
return 0 <= r < H and 0 <= c < W
while True:
W, H = list(map(int, input().split()))
if not (W | H):
break
origin_board = [[int(x) for x in input().split()] for _ in range(H)]
sr, sc, gr, gc = 0, 0, 0, 0
for r in range(H):
for c in range(W):
if origin_board[r][c] == 2:
sr, sc = r, c
origin_board[sr][sc] = 0
elif origin_board[r][c] == 3:
gr, gc = r, c
memo = dict()
que = collections.deque([(sr, sc, origin_board, 0)])
while que:
r, c, board, cnt = que.popleft()
if (r, c) == (gr, gc):
print(cnt)
break
for i, (dr, dc) in enumerate(drc):
nr, nc = r + dr, c + dc
if (r, c, i) in memo:
nr, nc = memo[r, c, i]
if in_board(nr, nc) and board[nr][nc] != 1:
next_board = copy.deepcopy(board)
while in_board(nr, nc) and board[nr][nc] == 0:
nr += dr
nc += dc
if in_board(nr, nc) and cnt < 10:
if next_board[nr][nc] == 1:
next_board[nr][nc] = 0
nr, nc = nr - dr, nc - dc
memo[r, c, i] = nr, nc
que.append((nr, nc, next_board, cnt + 1))
else:
print((-1)) | import collections
import copy
import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
drc = [(0, -1), (1, 0), (0, 1), (-1, 0)]
def in_board(r, c):
return 0 <= r < H and 0 <= c < W
while True:
W, H = list(map(int, input().split()))
if not (W | H):
break
origin_board = [[int(x) for x in input().split()] for _ in range(H)]
sr, sc, gr, gc = 0, 0, 0, 0
for r in range(H):
for c in range(W):
if origin_board[r][c] == 2:
sr, sc = r, c
origin_board[sr][sc] = 0
elif origin_board[r][c] == 3:
gr, gc = r, c
memo = dict()
que = collections.deque([(sr, sc, origin_board, 0)])
while que:
r, c, board, cnt = que.popleft()
if (r, c) == (gr, gc):
print(cnt)
break
if cnt == 10:
continue
for i, (dr, dc) in enumerate(drc):
nr, nc = r + dr, c + dc
if (r, c, i) in memo:
nr, nc = memo[r, c, i]
if in_board(nr, nc) and board[nr][nc] != 1:
next_board = copy.deepcopy(board)
while in_board(nr, nc) and board[nr][nc] == 0:
nr += dr
nc += dc
if in_board(nr, nc) and cnt < 10:
if next_board[nr][nc] == 1:
next_board[nr][nc] = 0
nr, nc = nr - dr, nc - dc
memo[r, c, i] = nr, nc
que.append((nr, nc, next_board, cnt + 1))
else:
print((-1)) | p00725 |
# -*- coding: utf-8 -*-
answer = 0
def up(board, pos, count):
global answer
# print 'UP:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
y = pos[0]
while y > 0:
y -= 1
if board[y][pos[1]] == 3:
if count < answer:
answer = count
return count
if board[y][pos[1]] == 1:
board[y][pos[1]] = 0
new_pos = [y+1, pos[1]]
dfs(board, new_pos, count+1)
board[y][pos[1]] = 1
return
def down(board, pos, count):
global answer
# print 'DOWN:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
y = pos[0]
while y < len(board) - 1:
y += 1
if board[y][pos[1]] == 3:
if count < answer:
answer = count
return
if board[y][pos[1]] == 1:
board[y][pos[1]] = 0
new_pos = [y-1, pos[1]]
dfs(board, new_pos, count+1)
board[y][pos[1]] = 1
return
def left(board, pos, count):
global answer
# print 'LEFT:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
x = pos[1]
while x > 0:
x -= 1
if board[pos[0]][x] == 3:
if count < answer:
answer = count
return
if board[pos[0]][x] == 1:
board[pos[0]][x] = 0
new_pos = [pos[0], x+1]
dfs(board, new_pos, count+1)
board[pos[0]][x] = 1
return
def right(board, pos, count):
global answer
# print 'RIGHT:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
x = pos[1]
while x < len(board[0]) - 1:
x += 1
if board[pos[0]][x] == 3:
if count < answer:
answer = count
return
if board[pos[0]][x] == 1:
board[pos[0]][x] = 0
new_pos = [pos[0], x-1]
dfs(board, new_pos, count+1)
board[pos[0]][x] = 1
return
def dfs(board, pos, count):
if count > 10:
return 11
# print 'DFS:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
h = len(board)
w = len(board[0])
if pos[0] - 1 >= 0 and board[pos[0]-1][pos[1]] != 1:
up(board, pos, count)
if pos[1] - 1 >= 0 and board[pos[0]][pos[1]-1] != 1:
left(board, pos, count)
if pos[0] + 1 < h and board[pos[0]+1][pos[1]] != 1:
down(board, pos, count)
if pos[1] + 1 < w and board[pos[0]][pos[1]+1] != 1:
right(board, pos, count)
return
def func():
'''
'''
global answer
while True:
w, h = list(map(int, input().split()))
if w == 0 and h == 0:
break
board = []
for i in range(h):
row = list(map(int, input().split()))
board.append(row)
s = [0, 0]
for i in range(h):
for j in range(w):
if board[i][j] == 2:
s[0] = i
s[1] = j
answer = 11
dfs(board, s, 1)
if answer == 11:
answer = -1
print(answer)
return None
if __name__ == '__main__':
func()
| # -*- coding: utf-8 -*-
answer = 0
def up(board, pos, count):
global answer
# print 'UP:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
y = pos[0]
while y > 0:
y -= 1
if board[y][pos[1]] == 3:
if count < answer:
answer = count
return count
if board[y][pos[1]] == 1:
board[y][pos[1]] = 0
new_pos = [y+1, pos[1]]
dfs(board, new_pos, count+1)
board[y][pos[1]] = 1
return
def down(board, pos, count):
global answer
# print 'DOWN:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
y = pos[0]
while y < len(board) - 1:
y += 1
if board[y][pos[1]] == 3:
if count < answer:
answer = count
return
if board[y][pos[1]] == 1:
board[y][pos[1]] = 0
new_pos = [y-1, pos[1]]
dfs(board, new_pos, count+1)
board[y][pos[1]] = 1
return
def left(board, pos, count):
global answer
# print 'LEFT:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
x = pos[1]
while x > 0:
x -= 1
if board[pos[0]][x] == 3:
if count < answer:
answer = count
return
if board[pos[0]][x] == 1:
board[pos[0]][x] = 0
new_pos = [pos[0], x+1]
dfs(board, new_pos, count+1)
board[pos[0]][x] = 1
return
def right(board, pos, count):
global answer
# print 'RIGHT:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
x = pos[1]
while x < len(board[0]) - 1:
x += 1
if board[pos[0]][x] == 3:
if count < answer:
answer = count
return
if board[pos[0]][x] == 1:
board[pos[0]][x] = 0
new_pos = [pos[0], x-1]
dfs(board, new_pos, count+1)
board[pos[0]][x] = 1
return
def dfs(board, pos, count):
global answer
if count > 10:
return 11
# print 'DFS:'
# print 'pos: ' + str(pos)
# print 'count: ' + str(count)
# for row in board:
# print row
# print
h = len(board)
w = len(board[0])
if count > answer:
return
if pos[0] - 1 >= 0 and board[pos[0]-1][pos[1]] != 1:
up(board, pos, count)
if pos[1] - 1 >= 0 and board[pos[0]][pos[1]-1] != 1:
left(board, pos, count)
if pos[0] + 1 < h and board[pos[0]+1][pos[1]] != 1:
down(board, pos, count)
if pos[1] + 1 < w and board[pos[0]][pos[1]+1] != 1:
right(board, pos, count)
return
def func():
'''
'''
global answer
while True:
w, h = list(map(int, input().split()))
if w == 0 and h == 0:
break
board = []
for i in range(h):
row = list(map(int, input().split()))
board.append(row)
s = [0, 0]
for i in range(h):
for j in range(w):
if board[i][j] == 2:
s[0] = i
s[1] = j
answer = 11
dfs(board, s, 1)
if answer == 11:
answer = -1
print(answer)
return None
if __name__ == '__main__':
func()
| p00725 |
import copy
while 1:
W,H = list(map(int,input().split()))
if W == 0: break
field = [list(map(int,input().split())) for _ in range(H)]
for y in range(H):
for x in range(W):
if field[y][x] == 2: sx,sy = x,y
que = [[sx,sy,10,field[:]]]
while que:
x,y,t,field = que.pop(0)
if t == -1: continue
if field[y][x] == 3:
print(10-t)
break
for dx,dy in zip([1,0,-1,0],[0,1,0,-1]):
_field = copy.deepcopy(field[:])
nx,ny = x+dx,y+dy
while 0 <= nx < W and 0 <= ny < H:
if _field[ny][nx] == 3:
que.append([nx,ny,t-1,_field[:]])
break
if _field[ny][nx] == 1:
_field[ny][nx] = 0
if abs(nx-x)+abs(ny-y) == 1: break
que.append([nx-dx,ny-dy,t-1,_field[:]])
break
nx += dx; ny += dy
else:
print(-1) | def rec(x,y,t):
global ans
if t >= ans: return
if field[y][x] == 3: ans = min(ans,t)
for dx,dy in zip([1,0,-1,0],[0,1,0,-1]):
nx,ny = x+dx,y+dy
while 0 <= nx < W and 0 <= ny < H:
if field[ny][nx] == 3:
rec(nx,ny,t+1)
if field[ny][nx] == 1:
if abs(nx-x)+abs(ny-y) == 1: break
field[ny][nx] = 0
rec(nx-dx,ny-dy,t+1)
field[ny][nx] = 1
break
nx += dx; ny += dy
while 1:
W,H = list(map(int,input().split()))
if W == 0: break
field = [list(map(int,input().split())) for _ in range(H)]
for y in range(H):
for x in range(W):
if field[y][x] == 2: sx,sy = x,y
ans = 11
rec(sx,sy,0)
print(ans if ans <= 10 else -1) | p00725 |
def rec(x,y,t):
global ans
if t >= ans: return
if field[y][x] == 3: ans = min(ans,t)
for dx,dy in zip([1,0,-1,0],[0,1,0,-1]):
nx,ny = x+dx,y+dy
while 0 <= nx < W and 0 <= ny < H:
if field[ny][nx] == 3:
rec(nx,ny,t+1)
if field[ny][nx] == 1:
if abs(nx-x)+abs(ny-y) == 1: break
field[ny][nx] = 0
rec(nx-dx,ny-dy,t+1)
field[ny][nx] = 1
break
nx += dx; ny += dy
while 1:
W,H = list(map(int,input().split()))
if W == 0: break
field = [list(map(int,input().split())) for _ in range(H)]
for y in range(H):
for x in range(W):
if field[y][x] == 2: sx,sy = x,y
ans = 11
rec(sx,sy,0)
print(ans if ans <= 10 else -1) | dxy = list(zip([1,0,-1,0],[0,1,0,-1]))
def rec(x,y,t):
global ans
if t >= ans: return
if field[y][x] == 3: ans = min(ans,t)
for dx,dy in dxy:
nx,ny = x+dx,y+dy
while 0 <= nx < W and 0 <= ny < H:
if field[ny][nx] == 3: ans = t
elif field[ny][nx] == 1:
if abs(nx-x)+abs(ny-y) == 1: break
field[ny][nx] = 0
rec(nx-dx,ny-dy,t+1)
field[ny][nx] = 1
break
nx += dx; ny += dy
while 1:
W,H = list(map(int,input().split()))
if W == 0: break
field = [list(map(int,input().split())) for _ in range(H)]
for y in range(H):
for x in range(W):
if field[y][x] == 2: sx,sy = x,y
ans = 11
rec(sx,sy,1)
print(ans if ans <= 10 else -1) | p00725 |
from copy import deepcopy as dcp
delta = ((1, 0), (0, 1), (-1, 0), (0, -1))
def ds(here, lb, ub, field, count):
result = 11
if count == 11:
return count
for dx, dy in delta:
next = (here[0]+dx,here[1]+dy)
if ( not (lb[0] <= next[0] <= ub[0] and lb[1] <= next[1] <= ub[1]) or
field[next[1]][next[0]] == 1) :
continue
tmp = slide(next, (dx,dy), lb, ub, dcp(field), count + 1)
if tmp < result:
result = tmp
return result
def slide(here, di, lb, ub, field, count):
while lb[0] <= here[0] <= ub[0] and lb[1] <= here[1] <= ub[1]:
if here == goal:
return count
if field[here[1]][here[0]] == 1:
field[here[1]][here[0]] = 0
return ds((here[0]-di[0],here[1]-di[1]), lb, ub, field, count)
here = (here[0]+di[0],here[1]+di[1])
else:
return 11
while 1:
w, h = list(map(int,input().split(" ")))
if w == h == 0: break
board = [[0 for _ in range(w)] for _ in range(h)]
for j in range(h):
inp = list(map(int,input().split(" ")))
for i in range(w):
tmp = inp[i]
if tmp == 0: continue
if tmp == 1: board[j][i] = 1
elif tmp == 2: start = (i,j)
else : goal = (i,j)
count = ds(start, (0,0), (w-1,h-1), board, 0)
print(count if count < 11 else -1) | delta = ((1, 0), (0, 1), (-1, 0), (0, -1))
def ds(here, lb, ub, field, count):
result = 11
if count == 11:
return count
for dx, dy in delta:
next = (here[0]+dx,here[1]+dy)
if ( not (lb[0] <= next[0] <= ub[0] and lb[1] <= next[1] <= ub[1]) or
field[next[1]][next[0]] == 1) :
continue
tmp = slide(next, (dx,dy), lb, ub, field, count + 1)
if tmp < result:
result = tmp
return result
def slide(here, di, lb, ub, field, count):
while lb[0] <= here[0] <= ub[0] and lb[1] <= here[1] <= ub[1]:
if here == goal:
result = count
break
if field[here[1]][here[0]] == 1:
field[here[1]][here[0]] = 0
result = ds((here[0]-di[0],here[1]-di[1]), lb, ub, field, count)
field[here[1]][here[0]] = 1
break
here = (here[0]+di[0],here[1]+di[1])
else:
result = 11
return result
while 1:
w, h = list(map(int,input().split(" ")))
if w == h == 0: break
board = [[0 for _ in range(w)] for _ in range(h)]
for j in range(h):
inp = list(map(int,input().split(" ")))
for i in range(w):
tmp = inp[i]
if tmp == 0: continue
if tmp == 1: board[j][i] = 1
elif tmp == 2: start = (i,j)
else : goal = (i,j)
count = ds(start, (0,0), (w-1,h-1), board, 0)
print(count if count < 11 else -1) | p00725 |
# -*- coding: utf-8 -*-
import sys
import math
debug = False
def log(text):
if debug:
print(text)
def parse_input(lines_as_string = None):
global debug
lines = []
if lines_as_string is None:
debug = False
# for line in sys.stdin:
# lines.append(line)
lines.append(input())
lines.append(input())
else:
debug = True
lines = [e for e in lines_as_string.split("\n")][1:-1]
n = int(lines[0])
p = [int(e) for e in lines[1].split(' ')]
return (n, p)
def solve(n, p):
result = []
current_min = 200000 + 1
for i in range(n):
if current_min < p[i]:
continue
current_min = min([current_min, p[i]])
done = False
for j in range(i+1):
if p[i] <= p[j]:
if j == i:
done = True
else:
break
if done:
result.append(i)
return len(result)
def main():
# 出力
result = solve(*parse_input())
if isinstance(result, list):
print("%d %d" % (result[0], result[1]))
else:
print("%s" % result, sep='')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
import math
debug = False
def log(text):
if debug:
print(text)
def parse_input(lines_as_string = None):
global debug
lines = []
if lines_as_string is None:
debug = False
# for line in sys.stdin:
# lines.append(line)
lines.append(input())
lines.append(input())
else:
debug = True
lines = [e for e in lines_as_string.split("\n")][1:-1]
n = int(lines[0])
p = [int(e) for e in lines[1].split(' ')]
return (n, p)
def solve(n, p):
result = []
current_min = 200000 + 1
current_min_index = None
for i in range(n):
if current_min < p[i]:
pass
else:
current_min = p[i]
current_min_index = i
done = False
for j in range(current_min_index, i+1):
if p[i] <= p[j]:
if j == i:
done = True
else:
break
if done:
result.append(i)
return len(result)
def main():
# 出力
result = solve(*parse_input())
if isinstance(result, list):
print("%d %d" % (result[0], result[1]))
else:
print("%s" % result, sep='')
if __name__ == '__main__':
main()
| p02791 |
N = int(eval(input()))
P = list(map(int, input().split()))
rui = [None] * (N)
rui[0] = P[0]
# print(rui)
for i in range(1, N):
a = rui[i-1]
b = P[i]
rui[i] = min(a, b)
c = 0
for i in range(N):
if P[i] <= rui[i]:
c += 1
print(c) | N = int(eval(input()))
P = list(map(int, input().split()))
mn = N+1
c = 0
for pi in P:
if pi <= mn:
c += 1
mn = pi
print(c) | p02791 |
N = int(eval(input()))
P = list(map(int, input().split()))
count = 0
isBigger = True
for i in range(len(P)):
for j in range(i):
isBigger = True
if not (P[i] <= P[j]):
isBigger = False
break
if isBigger:
count += 1
print(count) | N = int(eval(input()))
P = list(map(int, input().split()))
count = 0
min_value = 2e5+1
for p in P:
if p <= min_value:
min_value = p
count += 1
print(count) | p02791 |
n = int(eval(input()))
data = [int(x) for x in input().split()]
total = 0
for i in range(n):
if min(data[:(i+1)]) == data[i]:
total += 1
print(total) | n = int(eval(input()))
data = [int(x) for x in input().split()]
min_num = data[0]
ans = 0
for i in range(n):
if min_num >= data[i]:
ans += 1
min_num = data[i]
print(ans) | p02791 |
N = int(eval(input()))
a = input().rstrip().split()
ans = 0
p = [0]*N
for i in range(N):
p[i] = int(a[i])
for i in range(N):
if i == 0:
ans += 1
else:
Plus = True
for i2 in range(i):
if p[i2] <= p[i]:
Plus = False
if Plus == True:
ans += 1
print(ans)
| N = int(eval(input()))
a = input().rstrip().split()
P = [0] * N
for i in range(N):
P[i] = int(a[i])
minP = P[0]
ans = 1
for i in range(N - 1):
if minP >= P[i + 1]:
ans += 1
minP = P[i + 1]
print(ans) | p02791 |
N = int(eval(input()))
P = list(map(int,input().split()))
count=0
for i in range(N):
A=P[i]
if min(P[0:i+1])==A:
count += 1
else:
continue
print(count) | N = int(eval(input()))
P = list(map(int,input().split()))
count=0
mi=P[0] #minimum
for i in range(N):
A=P[i]
if A<=mi:
mi=A
count+=1
else:
continue
print(count) | p02791 |
n = int(eval(input()))
p = list(map(int,input().split()))
pp = list()
pp.append(p[0])
cnt=1
for i in range(1,n):
min_pp = min(pp)
if p[i] <= min_pp:
cnt +=1
pp.append(p[i])
print(cnt) | n = int(eval(input()))
p = list(map(int,input().split()))
min_p = p[0]
cnt=1
for i in range(1,n):
if p[i] <= min_p:
min_p = p[i]
cnt +=1
print(cnt) | p02791 |
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N):
if P[i] <= min(P[:(i+1)]):
ans += 1
print(ans) | N = int(eval(input()))
P = list(map(int, input().split()))
min = float('inf')
ans = 0
for i in range(N):
if P[i] <= min:
min = P[i]
ans += 1
# if P[i] <= min(P[:(i+1)]):
# ans += 1
print(ans) | p02791 |
n = int(eval(input()))
ps = list(map(int,input().split()))
count = 1
x = ps[0]
for i in range(1,len(ps)):
if x>ps[i]:
x = ps[i]
mi = min(ps[0:i])
if mi>ps[i]:
count += 1
print(count) | n = int(eval(input()))
ps = list(map(int,input().split()))
count = 1
mi = ps[0]
for i in range(1,len(ps)):
if mi>=ps[i]:
mi = ps[i]
count += 1
print(count) | p02791 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
n = int(eval(input()))
pn = list(map(int, input().split()))
def checkAllLess(tgt):
for id in range(tgt):
# print("id=" + str(id) + ", pn[]=" + str(pn[id]) + ", tgt=" + str(tgt))
if(pn[id] < pn[tgt]):
# print('False')
return False
# print('True')
return True
cnt = 1
min = pn[0]
for i in range(n):
if (min > pn[i] and checkAllLess(i)):
cnt += 1
if (min > pn[i]):
min = pn[i]
# print(str(i) + ":" + str(cnt))
print(cnt)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
n = int(eval(input()))
pn = list(map(int, input().split()))
cnt = 1
min = pn[0]
for i in range(1, n):
if min > pn[i]:
cnt += 1
min = pn[i]
print(cnt)
| p02791 |
n=int(eval(input()))
p=list(map(int,input().split()))
c=0
for i in range(n):
lFlag=True
for j in range(i):
if (p[i]>p[j]):
lFlag=False
break
if lFlag:
c=c+1
print(c)
| n=int(eval(input()))
p=list(map(int,input().split()))
c=0
min=2*10**5
for i in range(n):
if (p[i]<=min):
c=c+1
if p[i]<min:
min=p[i]
print(c)
| p02791 |
N = int(eval(input()))
Ps = list(map(int, input().split()))
answer = 0
for i in range(N):
if min(Ps[:i + 1]) >= Ps[i]:
answer = answer + 1
print(answer) | N = int(eval(input()))
Ps = list(map(int, input().split()))
answer = 0
min_num = 2 * 10 ** 5 + 1
for p in Ps:
min_num = min(p, min_num)
if min_num >= p:
answer = answer + 1
print(answer) | p02791 |
n=int(eval(input()))
p=list(map(int, input().split()))
count2=0
for i in range(n):
count1=0
for j in range(i+1):
if p[i] <= p[j]:
count1 += 1
if count1 == i+1:
count2 += 1
print(count2) | n=int(eval(input()))
p=list(map(int, input().split()))
min = p[0]
count=0
for i in range(n):
if p[i] <= min:
min = p[i]
count += 1
print(count)
| p02791 |
import sys
N = int(sys.stdin.readline())
P = list(map(int, sys.stdin.readline().split()))
count = 0
max = P[0]
for i in range(N):
if P[i] > max:
max = P[i]
else:
for j in range(i+1):
if P[i] > P[j]:
break
else:
count += 1
print(count) | import sys
N = int(sys.stdin.readline())
P = list(map(int, sys.stdin.readline().split()))
count = 0
min = P[0]
for i in range(N):
if P[i] <= min:
min = P[i]
count += 1
"""
else:
for j in range(i+1):
if P[i] > P[j]:
break
else:
count += 1
"""
print(count) | p02791 |
n = int(eval(input()))
ls = list(map(int, input().split()))
ans = 0
for i in range(n):
if(ls[i] == min(ls[:i+1])):
ans += 1
print(ans) | n = int(eval(input()))
p = list(map(int, input().split()))
# 初期化
cnt = 1
min = p[0]
# カウント処理
for i in range(1, n):
if(p[i] <= min):
cnt += 1
min = p[i]
print(cnt) | p02791 |
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 1
for i in range(1, N):
if P[i] == min(P[:i+1]):
cnt += 1
print(cnt) | N = int(eval(input()))
P = list(map(int, input().split()))
min_p = P[0]
cnt = 0
for p in P:
if p <= min_p:
min_p = p
cnt += 1
print(cnt) | p02791 |
#https://atcoder.jp/contests/abc152/tasks/abc152_c
# -*- coding: utf-8 -*-
N = int(eval(input()))
P = input().split()
T = []
L =0
T.insert(0,int(P[0]))
P[0] = int(P[0])
for i in range(1,len(P)):
P[i] = int(P[i])
if min(T)>=P[i]:
L =+ 1
T.append(P[i])
print((len(T))) | #https://atcoder.jp/contests/abc152/tasks/abc152_c
# -*- coding: utf-8 -*-
N = int(eval(input()))
P = input().split()
T = []
L =0
T.insert(0,int(P[0]))
P[0] = int(P[0])
for i in range(1,len(P)):
P[i] = int(P[i])
if T[-1]>=P[i]:
L =+ 1
if T[-1]>P[i]:
T.append(P[i])
print((len(T))) | p02791 |
def main():
n = int(eval(input()))
ps = list(map(int, input().split()))
li = []
ans = 0
for i in ps:
li.append(i)
if sorted(li)[0] >= i:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
ps = list(map(int, input().split()))
ans = 0
minp = float("inf")
for p in ps:
minp = min(minp, p)
if minp >= p:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| p02791 |
def main():
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in reversed(list(range(0, i))):
if P[j] < P[i]:
break
else:
ans += 1
print(ans)
if __name__ == '__main__':
main() | def main():
N = int(eval(input()))
P = list(map(int, input().split()))
ans = 1
m = P[0]
for i in range(1, N):
if P[i] > m:
continue
m = min(m, P[i])
ans += 1
print(ans)
if __name__ == '__main__':
main() | p02791 |
n = int(eval(input()))
ps = [int(elem) for elem in input().split()]
res = []
for i, p in enumerate(ps):
if ps[:i] == []:
res.append(p)
else:
if res[-1] > p:
res.append(p)
print((len(res))) | n = int(eval(input()))
ps = [int(elem) for elem in input().split()]
cnt = 0
for i, p in enumerate(ps):
if i == 0:
last = p
cnt += 1
else:
if last > p:
last = p
cnt += 1
print(cnt) | p02791 |
def main():
N=int(eval(input()))
P=list(map(int,input().split()))
sumCount=1
for i in range(1,N):
if(P[i]<=min(P[0:i+1])):
sumCount=sumCount+1
print(sumCount)
if __name__ == '__main__':
main() | n = int(eval(input()))
p = list(map(int, input().split()))
num = p[0]
ans = 1
for i in range(1, n):
if num >= p[i]:
ans += 1
num = p[i]
print(ans) | p02791 |
N=int(eval(input()))
a=list(map(int,input().split()))
b=1
for i in range(N-1):
if min(a[:i+2])==a[i+1]:
b+=1
print(b) | N=int(eval(input()))
a=list(map(int,input().split()))
b=1
c=a[0]
for i in range(N-1):
if c>a[i+1]:
b+=1
c=a[i+1]
print(b) | p02791 |
N, *P = list(map(int, open(0).read().split()))
min_v = 10 ** 6
max_v = 0
ans = 0
for i in range(N):
if P[i] < min_v:
ans += 1
min_v = P[i]
elif P[i] > max_v:
max_v = P[i]
print(ans)
|
N = int(eval(input()))
X = list(map(int, input().split()))
ans = 0
cur = 10 ** 6
for i in range(N):
if X[i] <= cur:
ans += 1
cur = min(cur, X[i])
print(ans)
| p02791 |
n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 1
for _ in range(1,n):
for j in range(_):
if p[_] <= p[j]:
if _ == j+1:
cnt += 1
else:
break
print(cnt) | n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 0
for _ in p: #p[i]よりも小さいものが出てきたらだめ
if _ <= n:
cnt += 1
n = _
print(cnt) | p02791 |
N = int(eval(input()))
p = list(map(int, input().split()))
cnt = 1
if len(p) >= 2 and p[0] >= p[1]:
cnt += 1
for i in range(2, N):
if min(p[:i+1]) == p[i]:
cnt += 1
else:
continue
print(cnt)
| N = int(eval(input()))
p = list(map(int, input().split()))
cnt = 1
mi = p[0]
for i in range(N):
if mi > p[i]:
mi = p[i]
cnt += 1
print(cnt) | p02791 |
n = int(eval(input()))
lis = list(map(int, input().split()))
count = 0
minn = lis[0]
flug = 0
for i in range(n):
if flug == 0:
newlis = lis[0:i+1]
if minn >= lis[i]:
count += 1
minn = lis[i]
if minn == 1:
count += lis[i+1:].count(1)
flug = 1
print(count) | n = int(eval(input()))
lis = list(map(int, input().split()))
count = 0
minn = lis[0]
minl = min(lis)
flug = 0
for i in range(n):
if flug == 0:
if minn >= lis[i]:
count += 1
minn = lis[i]
if minn == minl:
count += lis[i+1:].count(minl)
flug = 1
print(count) | p02791 |
N=int(eval(input()))
P=list(map(int, input().split()))
ans=0
for i in range(N):
flag=True
for j in range(i):
if P[i]>P[j]:
flag=False
break
if flag:
ans+=1
print(ans) | N=int(eval(input()))
P=list(map(int, input().split()))
ans=1
mi=P[0]
for i in range(1,N):
if P[i]<=mi:
ans+=1
mi=P[i]
print(ans) | p02791 |
N = int(eval(input()))
P = list(map(int, input().split()))
count = 0
for i in range(N):
if all(list([x >= P[i] for x in P[:i]])):
count += 1
print(count)
| N = int(eval(input()))
P = list(map(int, input().split()))
count = 0
m = P[0]
for i in range(N):
if (m >= P[i]):
count += 1
m = P[i]
print(count)
| p02791 |
n = int(eval(input()))
p = list(map(int,input().split()))
l = [2*10**5]
cnt=0
if n == 1:
print((1))
else:
for i in range(n-1):
l.append(p[i])
m = min(l)
if m > p[i+1]:
#print(p[i+1])
cnt+=1
print((cnt+1)) | n = int(eval(input()))
p = list(map(int,input().split()))
m = 2*10**5
cnt=0
if n == 1:
print((1))
else:
for i in range(n-1):
if m > p[i]:
m = p[i]
if m > p[i+1]:
#print(p[i+1])
cnt+=1
print((cnt+1)) | p02791 |
n = int(eval(input()))
p = list(map(int, input().split()))
count=0
for i in range(len(p)):
if min(p[:(1+i)])==p[i]:
count+=1
print(count) | n = int(eval(input()))
p = list(map(int, input().split()))
count=0
minmin=100000000
for i in range(len(p)):
if p[i]<minmin:
count+=1
minmin=p[i]
print(count) | p02791 |
n=int(eval(input()))
p=list(map(int,input().split()))
cnt=0
for i in range(1,n):
if min(p[0:i])<p[i]:
cnt+=1
print((n-cnt)) | n=int(eval(input()))
p=list(map(int,input().split()))
a=p[0]
cnt=1
for i in range(1,n):
if a>=p[i]:
cnt+=1
a=p[i]
print(cnt) | p02791 |
N=int(eval(input()))
P=list(map(int,input().split()))
count=0
flag=True
for i in range(N):
for k in range(1):
l=min(P[:i+1])
if P[i]>l:
flag=False
break
if flag:
count+=1
else:
flag=True
print(count) | N=int(eval(input()))
P=list(map(int,input().split()))
count=1
min=P[0]
for i in range(1,N):
if min>P[i]:
count+=1
min=P[i]
print(count)
| p02791 |
N = int(eval(input()))
nos = list(map(int, input().split()))
count = 1
for j in range(1,N):
if min(nos[0:j+1]) == nos[j]:
count += 1
print(count) | N = int(eval(input()))
nos = list(map(int, input().split()))
count = 1
min = nos[0]
for j in range(1,N):
if nos[j] <= min:
count += 1
min = nos[j]
print(count) | p02791 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = list(map(int, read().split()))
r = 0
for i1 in range(n):
r += min(a[:i1+1]) >= a[i1]
print(r)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = list(map(int, read().split()))
r = 0
minp = a[0]
for i1 in range(n):
if minp >= a[i1]:
r += 1
minp = a[i1]
print(r)
if __name__ == '__main__':
main()
| p02791 |
n=int(eval(input()))
p =list(map(int,input().split()))
c=0
for i in range(n):
s=p[0:i+1]
s.sort()
if s[0]==p[i]:
c=c+1
print(c) | n=int(eval(input()))
p =list(map(int,input().split()))
c=0
mini=p[0]
for i in range(n):
if mini>=p[i]:
c=c+1
mini=p[i]
print(c) | p02791 |
# C - Low Elements
def main():
N, *P = list(map(int, open(0).read().split()))
ans, cur_min = 0, P[0]
for i in P:
if i <= cur_min:
ans += 1
cur_min = min(cur_min, i)
print(ans)
if __name__ == "__main__":
main()
| # C - Low Elements
def main():
N, *P = list(map(int, open(0).read().split()))
ans, cur_min = 0, P[0]
for i in P:
if i <= cur_min:
ans += 1
cur_min = i
print(ans)
if __name__ == "__main__":
main()
| p02791 |
a = int(eval(input()))
array = list(map(int, input().strip().split()))
out = 0
for i in range(a):
minn = min(array[0:i+1])
out = out + 1 if array[i] == minn else out
print(out) | a = int(eval(input()))
array = list(map(int, input().strip().split()))
out = 0
min_num = array[0]
for i in array:
min_num = min(min_num, i)
out = out + 1 if i == min_num else out
print(out) | p02791 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.