input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
l, m = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(m)]
ll, rr = 1, l
for l, r in lr:
if ll <= l <= rr or l <= ll <= r:
ll, rr = max(ll, l), min(rr, r)
else:
print((0))
exit()
print((rr-ll+1)) | n, m = list(map(int, input().split()))
lr = [list(map(int, input().split())) for _ in range(m)]
INF = float('inf')
ans_l, ans_r = -INF, INF
for l, r in lr:
ans_l = max(ans_l, l)
ans_r = min(ans_r, r)
print((max(0, ans_r-ans_l+1))) | p03037 |
n,m = list(map(int,input().split()))
lst_l = []
lst_r = []
for _ in range(m):
l,r = list(map(int,input().split()))
lst_l.append(l)
lst_r.append(r)
count = 0
for i in range(n):
if max(lst_l) <= i+1 <= min(lst_r):
count += 1
print(count) | n,m = list(map(int,input().split()))
lst_l = []
lst_r = []
for _ in range(m):
l,r = list(map(int,input().split()))
lst_l.append(l)
lst_r.append(r)
max_l = max(lst_l)
min_r = min(lst_r)
count = 0
for i in range(n):
if max_l <= i+1 <= min_r:
count += 1
print(count) | p03037 |
n,m=list(map(int,input().split()))
gate=[]
l,r=list(map(int,input().split()))
for i in range(l,r+1):
gate.append(i)
for i in range(m-1):
l,r=list(map(int,input().split()))
g=[]
for i in gate:
if l<=i<=r:
g.append(i)
gate=g
print((len(gate))) | n,m=list(map(int,input().split()))
card=[]
L=1
R=n
for i in range(m):
card.append([int(i) for i in input().split()])
for j in card:
if j[0]<=R:
if L<=j[0]:
L=j[0]
else:
print((0))
quit()
if L<=j[1]:
if j[1]<=R:
R=j[1]
else:
print((0))
quit()
print((R-L+1)) | p03037 |
from collections import Counter
n, m = list(map(int, input().split()))
A = []
for i in range(m):
l, r = list(map(int, input().split()))
A.extend(list(range(l, r + 1)))
cnt = 0
for v in list(Counter(A).values()):
if v == m:
cnt += 1
print(cnt) | n, m = list(map(int, input().split()))
left = 0
right = float('inf')
for i in range(m):
l, r = list(map(int, input().split()))
left = max(left, l)
right = min(right, r)
print((max(0, right - left + 1))) | p03037 |
# -*- coding: utf-8 -*-
n, m = list(map(int,input().split()))
lr = []
for i in range(m):
lr.append([int(i) for i in input().split()])
if m == 1:
print((lr[0][1] - lr[0][0] + 1))
exit()
tmp1 = 0
tmp2 = pow(10, 6)
for i in range(m - 1):
tmp1 = max(lr[i][0], lr[i + 1][0], tmp1)
tmp2 = min(lr[i][1], lr[i + 1][1], tmp2)
#print(tmp1, tmp2)
ans = max(tmp2 - tmp1 + 1, 0)
print(ans)
| n, m = list(map(int,input().split()))
lr = []
for i in range(m):
lr.append([int(i) for i in input().split()])
tmp1 = 0
tmp2 = pow(10, 6)
for i in range(m):
tmp1 = max(lr[i][0], tmp1)
tmp2 = min(lr[i][1], tmp2)
print((max(0, tmp2 - tmp1 + 1)))
| p03037 |
N,M=list(map(int,input().split()))
LR=[]
for i in range(M):
LR.append(list(map(int,input().split())))
ans=[i+1 for i in range(N)]
for i in range(M):
for j in range(LR[i][0]):
if j in ans:
ans.remove(j)
for k in range(LR[i][1]+1,N+1):
if k in ans:
ans.remove(k)
print((len(ans))) | N,M=list(map(int,input().split()))
LR=[]
for i in range(M):
LR.append(list(map(int,input().split())))
l,r=LR[0][0],LR[0][1]
for i in range(M):
if LR[i][1]<=r:
r=LR[i][1]
if l<=LR[i][0]:
l=LR[i][0]
ans=r-l+1
if ans>0:
print(ans)
else:
print((0)) | p03037 |
N, M = list(map(int, input().split()))
l, r = list(map(int, input().split()))
lis = [i for i in range(l, r+1)]
for i in range(M-1):
l, r = list(map(int, input().split()))
tmp_lis = [i for i in range(l, r+1)]
lis = set(lis) & set(tmp_lis)
lis = [i for i in lis if i <= N]
print((len(lis)))
| N, M = list(map(int, input().split()))
min, max = list(map(int, input().split()))
for i in range(M-1):
l, r = list(map(int, input().split()))
if min < l:
min = l
if max > r:
max = r
lis = [i for i in range(min, max+1)]
print((len(lis)))
| p03037 |
#ABC-127-C
N, M = list(map(int, input().split()))
LR = []
for _ in range(M):
Li, Ri = list(map(int, input().split()))
LR.append((Li, Ri))
possible_card_list = [i for i in range(LR[0][0], LR[0][1]+1)]
for Li, Ri in LR:
for possible_card in possible_card_list[:]:
if Li <= possible_card and possible_card <= Ri:
#OK
pass
else:
possible_card_list.remove(possible_card)
print((len(possible_card_list)))
| #ABC-127-C
N, M = list(map(int, input().split()))
L_list = []
R_list = []
for _ in range(M):
Li, Ri = list(map(int, input().split()))
L_list.append(Li)
R_list.append(Ri)
max_L = max(L_list)
min_R = min(R_list)
if max_L > min_R:
print((0))
else:
print((min_R-max_L+1))
| p03037 |
n,m = list(map(int,input().split()))
l = []
r = []
while True:
try:
tl,tr = list(map(int,input().split()))
l.append(tl)
r.append(tr)
except:
break
l = sorted(l)
r = sorted(r)
cnt = 0
for i in range(1,n+1):
if i>=max(l) and i<=min(r):
cnt +=1
print(cnt)
| n,m = list(map(int,input().split()))
l = []
r = []
while True:
try:
tl,tr = list(map(int,input().split()))
l.append(tl)
r.append(tr)
except:
break
R = min(r)
L = max(l)
cnt = 0
for i in range(1,n+1):
if i>=L and i<=R:
cnt +=1
print(cnt)
| p03037 |
N, M = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(M)]
B = {x for x in range(A[0][0], A[0][1]+1)}
for i in range(1,M):
C = {x for x in range(A[i][0],A[i][1]+1)}
B = B & C
ans = len(B)
print(ans)
| N, M = list(map(int, input().split()))
A = [0]*M
B = [0]*M
for i in range(M):
A[i], B[i] = list(map(int, input().split()))
a = max(A)
b = min(B)
if a <= b:
print((b+1-a))
else:
print((0))
| p03037 |
def resolve():
N,M=list(map(int,input().split()))
l, r = list(map(int, input().split()))
s = {i for i in range(l, r + 1)}
for i in range(1,M):
l,r=list(map(int,input().split()))
s=s&{i for i in range(l,r+1)}
print((len(s)))
resolve() | # input = sys.stdin.readline
def resolve():
N,M=list(map(int,input().split()))
l, r = list(map(int, input().split()))
for i in range(1,M):
ll,rr=list(map(int,input().split()))
l=max(l,ll)
r=min(r,rr)
print((r-l+1 if r-l+1>=0 else 0))
resolve() | p03037 |
N,M = list(map(int,input().split()))
LR = [[] for i in range(M)]
for i in range(M):
L,R = list(map(int, input().split()))
for j in range(L,R + 1):
LR[i].append(j)
LR[i] = set(LR[i])
for i in range(M):
LR[i] = LR[i] & LR[i-1]
print((len(LR[M-1]))) | N,M = list(map(int,input().split()))
LR = [set([]) for i in range(M)]
for i in range(M):
L,R = list(map(int, input().split()))
for j in range(L,R + 1):
LR[i].add(j)
for i in range(M):
LR[i] = LR[i] & LR[i-1]
print((len(LR[M-1]))) | p03037 |
N,M = list(map(int,input().split()))
LR = [set([]) for i in range(M)]
for i in range(M):
L,R = list(map(int, input().split()))
for j in range(L,R + 1):
LR[i].add(j)
for i in range(M):
LR[i] = LR[i] & LR[i-1]
print((len(LR[M-1]))) | N,M = list(map(int,input().split()))
inf = []
sup = []
for i in range(0,M):
L,R = list(map(int,input().split()))
inf.append(L)
sup.append(R)
inf = max(inf)
sup = min(sup)
ran = sup - inf
if ran >= 0:
print((ran + 1))
else:print((0)) | p03037 |
N, M = list(map(int, input().split()))
id_list = [0] * N
for _ in range(M):
L, R = list(map(int, input().split()))
for i in range(L, R + 1):
id_list[i - 1] += 1
print((sorted(id_list, reverse=True).count(M)))
| N, M = list(map(int, input().split()))
L, R = 1, N
for _ in range(M):
Li, Ri = list(map(int, input().split()))
if L <= Li:
L = Li
if Ri <= R:
R = Ri
print((R - L + 1 if (R >= L) else 0))
| p03037 |
N,M=list(map(int,input().split()))
passable=set(range(1,N+1))
for m in range(M):
L,R=list(map(int,input().split()))
passable=passable&set(range(L,R+1))
print((len(passable))) | N,M=list(map(int,input().split()))
L=[]
R=[]
for m in range(M):
Lm,Rm=list(map(int,input().split()))
L.append(Lm)
R.append(Rm)
maxL=max(L)
minR=min(R)
print((max(minR-maxL+1,0))) | p03037 |
def island(f,x,y,m):
rf = f[:][:]
rf[y][x] = m
for i in [-1,1]:
if 0 <= x+i <= 11 and rf[y][x+i] == 1:
rf = island(rf,x+i,y,m)
if 0 <= y+i <= 11 and rf[y+i][x] == 1:
rf = island(rf,x,y+i,m)
return rf
while True:
f = []; m = 2
for i in range(12):
f.append(list(map(int, list(input()))))
for y in range(12):
for x in range(12):
if f[y][x] == 1:
f = island(f,x,y,m)
m += 1
ans = []
for i in range(12):
for j in range(12):
ans.append(f[i][j])
ans = list(set(ans))
print(len(ans) - 1*ans.count(0))
try:input()
except: break | W,H = 12,12
dxy = [[1,0],[0,1],[-1,0],[0,-1]]
def solve(field,w,h):
if 0 <= w < W and 0 <= h < H and field[h][w] == "1":
field[h][w] = "0"
for dx,dy in dxy:
solve(field,w+dx,h+dy)
while 1:
try:
field = [list(input()) for i in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if field[h][w] == "1":
solve(field,w,h)
ans += 1
print(ans)
input()
except:
break | p00067 |
import sys
A=list(range(12))
m=[[0 for i in A] for j in A]
def f(y,x,d):
P=[]
x+=d[0]
y+=d[1]
if 0<=x<12 and 0<=y<12 and m[y][x]==1:
m[y][x]=c
P=[[y,x]]
return P
def v1(buf):
global c
while buf!=[]:
y,x=buf.pop()
m[y][x]=c
for e in [(-1,0),(1,0),(0,-1),(0,1)]:buf+=f(y,x,e)
c+=1
return
def solve():
global c
c=2
for i in A:
while m[i].count(1)>0:v1([[i,m[i].index(1)]])
print(c-2)
return 0
y=0
for s in sys.stdin:
if y<12:
m[y]=list(map(int,list(s[:-1])))
y+=1
else:y=solve()
solve() | import sys
A=list(range(14))
m=[[0 for i in A] for j in A]
def f(y,x):
if m[y][x]==1:
m[y][x]=0
f(y,x+1)
f(y,x-1)
f(y+1,x)
f(y-1,x)
return
def solve():
c=2
for i in A:
while m[i].count(1)>0:
f(i,m[i].index(1))
c+=1
print(c-2)
return 0
y=0
for s in sys.stdin:
if y<12:
m[y+1]=[0]+list(map(int,list(s[:-1])))+[0]
y+=1
else:y=solve()
solve() | p00067 |
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N,M = list(map(int,input().split()))
L = []
for i in range(N):
tmp = list(map(int,input().split()))
L.append(tmp[1:])
dicL = {}
for i in range(N):
for l in L[i]:
if l not in dicL:
dicL[l] = [i]
else:
dicL[l].append(i)
#print(dicL)
E = [[] for _ in range(N)]
for k,v in list(dicL.items()):
if len(v) > 1:
for i in range(len(v)-1):
for j in range(i+1,len(v)):
E[v[i]].append(v[j])
E[v[j]].append(v[i])
#for i in range(N):
# E[i] = set(E[i])
#print(E)
Visited = [0 for _ in range(N)]
def dfs(v):
Visited[v] = 1
for u in E[v]:
if Visited[u] == 0:
dfs(u)
dfs(0)
print(('YES' if sum(Visited) == N else 'NO'))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
N,M = list(map(int,input().split()))
L = []
for i in range(N):
tmp = list(map(int,input().split()))
L.append(tmp[1:])
#print(L)
# 人(0~N-1)と言語(N~M-1)の間で二部グラフを作る
E = [set() for _ in range(N+M)]
for i in range(N):
for l in L[i]:
E[i].add(l+N-1)
E[l+N-1].add(i)
#print(E)
# 人のノードすべてに到達可能であればYES
Visited = [0 for _ in range(N+M)]
def dfs(v):
Visited[v] = 1
for u in E[v]:
if Visited[u] == 0:
dfs(u)
dfs(0)
print(('YES' if sum(Visited[:N]) == N else 'NO'))
| p03911 |
from collections import deque
N,M = list(map(int, input().split()))
es_lang = [[] for _ in range(M+1)] # 各言語の番号がidxで、それを話せる人が中身
es_p = [[] for _ in range(N+1)] # 各人の番号がidxで、その人の話せる言語が中身
for i in range(N):
KL = list(map(int, input().split()))
es_p[i+1].extend(KL[1:])
for j in KL[1:]:
es_lang[j].append(i+1)
checked_lang = [False] * (M+1)
checked_p = [False] * (N+1)
#人１からスタートする
stack_p = [1]
checked_p[1] = True
while len(stack_p) > 0:
for p in stack_p:
#p = stack_p.pop() # 調べる人を取り出す
checked_p[p] = True
stack_lang = []
for lang in es_p[p]: #人ｐが話せる言語について調べる
if checked_lang[lang] == False: # まだその言語を調査してないとき
stack_lang.append(lang)
checked_lang[lang] = True
# 人pの持つ言語をだれが話せるか調べる
new_stack_p = []
for lang in stack_lang:
for pp in es_lang[lang]:
if checked_p[pp] == False:
new_stack_p.append(pp)
checked_p[pp] = True
if all(checked_p[1:]):
print("YES")
exit()
if len(new_stack_p) > 0:
stack_p = new_stack_p
print("NO")
| from collections import deque
N,M = list(map(int, input().split()))
es_lang = [[] for _ in range(M+1)] # 各言語の番号がidxで、それを話せる人が中身
es_p = [[] for _ in range(N+1)] # 各人の番号がidxで、その人の話せる言語が中身
for i in range(N):
KL = list(map(int, input().split()))
es_p[i+1].extend(KL[1:])
for j in KL[1:]:
es_lang[j].append(i+1)
checked_lang = [False] * (M+1)
checked_p = [False] * (N+1)
#人１からスタートする
stack_p = [1]
checked_p[1] = True
while len(stack_p) > 0:
new_stack_p = [] # この次のループで調べる人の集合
for p in stack_p:
checked_p[p] = True
stack_lang = []
for lang in es_p[p]: #人ｐが話せる言語について調べる
if checked_lang[lang] == False: # まだその言語を調査してないとき
stack_lang.append(lang)
checked_lang[lang] = True
# 人pの持つ言語をだれが話せるか調べる
for lang in stack_lang:
for pp in es_lang[lang]: # 人ｐの話せる言語を話せる人について調べる
if checked_p[pp] == False: # まだその人を調べてないなら次のループで調べる人に入れる
new_stack_p.append(pp)
checked_p[pp] = True
if all(checked_p[1:]):
print("YES")
exit()
if len(new_stack_p) > 0:
stack_p = new_stack_p
else:
break
print("NO")
| p03911 |
N,M = list(map(int,input().split()))
K = []
L = []
for _ in range(N):
k,*l = list(map(int,input().split()))
K.append(k)
L.append(l)
graph = [[] for _ in range(N+M)]
for i in range(N):
for l in L[i]:
graph[i].append(N+l-1)
graph[N+l-1].append(i)
visited = [0 for _ in range(N+M)]
visited[0] = 1
stack = [0]
while stack:
node = stack.pop()
for adj in graph[node]:
if not visited[adj]:
visited[adj] = 1
stack.append(adj)
print(('YES' if all(visited[:N]) else 'NO')) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [i for i in range(n)]
self.size = [1 for _ in range(n)]
def find(self, x):
root = x
while self.parents[root] != root:
root = self.parents[root]
return root
def unite(self, x, y):
xroot = self.find(x)
yroot = self.find(y)
if xroot == yroot: return
if self.size[xroot] <= self.size[yroot]:
self.parents[xroot] = yroot
self.size[yroot] += self.size[xroot]
else:
self.parents[yroot] = xroot
self.size[xroot] += self.size[yroot]
N, M = list(map(int, input().split()))
uf = UnionFind(M)
L = []
for _ in range(N):
k, *l = list(map(int, input().split()))
for i in range(1, k):
uf.unite(l[0] - 1, l[i] - 1)
L.append(l[0] - 1)
if len(set([uf.find(L[i]) for i in range(N)])) == 1:
print('YES')
else:
print('NO') | p03911 |
# cf16-finalC - Interpretation
class UnionFind: # O(α(N))
def __init__(self, size): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(size + 1)]
self.rank = [0] * (size + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # in the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# Union-Find on spoken languages -> check all langs are in the same group?
N, M = list(map(int, input().split()))
A = [(list(map(int, input().split()))) for _ in range(N)]
uf, spoken = UnionFind(M), set()
for _, *langs in A:
spoken.update(langs)
primary = langs[0] # primary language for the person
for l in langs[1:]:
uf.unite(primary, l)
cur = uf.find(spoken.pop()) # group of one of spoken languages
flg = all(uf.find(lang) == cur for lang in spoken)
print(("YES" if flg else "NO"))
if __name__ == "__main__":
main() | # cf16-finalC - Interpretation
class UnionFind:
def __init__(self, size):
self.parent = [i for i in range(size + 1)]
self.rank = [0] * (size + 1)
def find(self, x):
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def unite(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
N, M = list(map(int, input().split()))
A = [(list(map(int, input().split()))) for _ in range(N)]
uf, spoken = UnionFind(M), set()
for _, *langs in A:
spoken.update(langs)
primary = langs[0]
for l in langs[1:]:
uf.unite(primary, l)
cur = uf.find(spoken.pop())
flg = all(uf.find(lang) == cur for lang in spoken)
print(("YES" if flg else "NO"))
if __name__ == "__main__":
main() | p03911 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
"""
n個の要素を0 ~ n - 1の番号で管理する。以下の属性およびメソッドを持つ。
parents
各要素の親要素の番号を格納するリスト
要素が根（ルート）の場合は-(そのグループの要素数)を格納する
find(x)
要素xが属するグループの根を返す
union(x, y)
要素xが属するグループと要素yが属するグループとを併合する
size(x)
要素xが属するグループのサイズ（要素数）を返す
same(x, y)
要素x, yが同じグループに属するかどうかを返す
members(x)
要素xが属するグループに属する要素をリストで返す
roots()
すべての根の要素をリストで返す
group_count()
グループの数を返す
all_group_members
{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
__str__()
print()での表示用
ルート要素: [そのグループに含まれる要素のリスト]を文字列で返す
"""
n, m = (int(x) for x in input().split())
L = [set() for _ in range(n)]
for i in range(n):
k, *arg = (int(x) for x in input().split())
L[i].update(set(arg))
ANS = L[0]
uf = UnionFind(n)
for _ in range(100):
for i in range(1, n):
if ANS & L[i]:
ANS |= L[i]
uf.union(0, i)
for i in reversed(list(range(1, n))):
if ANS & L[i]:
ANS |= L[i]
uf.union(0, i)
if uf.group_count() == 1:
print("YES")
else:
print("NO") | class UnionFind: # 0-index
def __init__(self, n):
self.n = n
self.parents = [-1] * n # 親の番号 要素が根の場合は-(そのグループの要素数)を格納
def find(self, x): # 要素xが属するグループの根を返す
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y): # 要素xが属するグループと要素yが属するグループとを併合する
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x): # 要素xが属するグループのサイズ（要素数）を返す
return -self.parents[self.find(x)]
def same(self, x, y): # 要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def members(self, x): # 要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self): # すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self): # グループの数を返す
return len(self.roots())
def all_group_members(self): # {根: [グループに含まれる要素のリスト], ...}の辞書を返す
return {root: self.members(root) for root in self.roots()}
# ---------------------- #
n, m = (int(x) for x in input().split())
L = [tuple(int(x) for x in input().split()) for _ in range(n)]
uf = UnionFind(n + m)
for i in range(n):
for l in L[i][1:]:
l -= 1
uf.union(i, n + l)
roots = uf.roots()
if len(roots) == 1 or roots[1] >= n:
print("YES")
else:
print("NO")
| p03911 |
import sys
import collections
sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()
def solve():
N, M = nm()
uf = UnionFind(M)
lang_spoken = set()
for i in range(N):
k, *lang = nm()
assert len(lang) == k
roots = {uf.find(l - 1) for l in lang}
lang_spoken |= roots
roots = list(roots)
x = roots[0]
for y in roots[1:]:
uf.union(x, y)
lang1 = next(iter(lang_spoken))
return uf.size(lang1) == len(lang_spoken)
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n
def find(self, x):
"""Returns x's root node id."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self._root_table) if x == i]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
print((["NO", "YES"][solve()]))
| import sys
import collections
sys.setrecursionlimit(10 ** 8)
ni = lambda: int(sys.stdin.readline())
nm = lambda: list(map(int, sys.stdin.readline().split()))
nl = lambda: list(nm())
ns = lambda: sys.stdin.readline().rstrip()
def solve():
N, M = nm()
uf = UnionFind(M)
lang_spoken = set()
for i in range(N):
k, *lang = nm()
assert len(lang) == k
roots = {uf.find(l - 1) for l in lang}
lang_spoken |= roots
rit = iter(roots)
x = next(rit)
for y in rit:
uf.union(x, y)
lang1 = next(iter(lang_spoken))
return uf.size(lang1) == len(lang_spoken)
class UnionFind:
def __init__(self, n):
# total number of nodes.
self.n = n
# node id -> root node id
self._root_table = list(range(n))
# root node id -> group size
self._size_table = [1] * n
def find(self, x):
"""Returns x's root node id."""
r = self._root_table[x]
if r != x:
# Update the cache on query.
r = self._root_table[x] = self.find(r)
return r
def union(self, x, y):
"""Merges two groups."""
x = self.find(x)
y = self.find(y)
if x == y:
return
# Ensure that x is the larger (or equal) group.
if self._size_table[x] < self._size_table[y]:
x, y = y, x
self._size_table[x] += self._size_table[y]
self._root_table[y] = x
def size(self, x):
return self._size_table[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self._root_table) if x == i]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
print((["NO", "YES"][solve()]))
| p03911 |
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N ]
E = [[[] for _ in [0]*N] , [[] for _ in [0]*M]]
for i,kl in enumerate(KL):
for l in kl[1:]:
E[0][i].append(l-1)
E[1][l-1].append(i)
Check = [[False]*N,[False]*M]
Check[0][0] = True
q = [[0,0]]
while q:
cl,i = q.pop()
for j in E[cl][i]:
if Check[1-cl][j]:continue
q.append([1-cl,j])
Check[1-cl][j] = True
if sum(Check[0]) == N:
print("YES")
else:
print("NO") | #二部グラフで連結判定
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N]
c = [False]*(N+M) #d[0] - d[N-1]:人, d[N] - D[N+M-1]:言語
E = [[] for _ in [0]*(N+M)]
for i,kl in enumerate(KL):
for l in kl[1:]:
E[i].append(N+l-1)
E[N+l-1].append(i)
start = 0
q = [start]
c[start] = True
while q:
i = q.pop()
for j in E[i]:
if c[j]:continue
c[j] = True
q.append(j)
ans = True
for b in c[:N]:
ans = ans and b
print(("YES" if ans else "NO")) | p03911 |
import heapq
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N]
E = [{} for _ in [0]*(N+M)]
for i,kl in enumerate(KL):
for l in kl[1:]:
E[i][N+l-1] = 1
E[N+l-1][i] = 1
def Dijkstra(N,E,start):
d = [-1]*N
q = [(0,start)]
while q:
ci,i = heapq.heappop(q)
if d[i]!= -1:continue
d[i] = ci
for j,cj in list(E[i].items()):
if d[j]!=-1:continue
heapq.heappush(q,(ci+cj,j))
return d
d = Dijkstra(N+M,E,0)
ans = d[:N].count(-1)==0
print(("YES" if ans else "NO")) | #二部グラフで連結判定
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N]
E = [[] for _ in [0]*(N+M)] #E[0] - E[N-1]:人, E[N] - E[N+M-1]:言語
for i,kl in enumerate(KL):
for l in kl[1:]:
E[i].append(N+l-1)
E[N+l-1].append(i)
def connect_bfs(N,E,start):
connect = {start}
q = [start]
while q:
i = q.pop()
for j in E[i]:
if j in connect:continue
connect.add(j)
q.append(j)
return connect
c = connect_bfs(N+M,E,0)
ans = len(c & set(range(N)))==N
print(("YES" if ans else "NO")) | p03911 |
#二部グラフで連結判定
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N]
E = [[] for _ in [0]*(N+M)] #E[0] - E[N-1]:人, E[N] - E[N+M-1]:言語
for i,kl in enumerate(KL):
for l in kl[1:]:
E[i].append(N+l-1)
E[N+l-1].append(i)
def connect_bfs(N,E,start):
connect = {start}
q = [start]
while q:
i = q.pop()
for j in E[i]:
if j in connect:continue
connect.add(j)
q.append(j)
return connect
c = connect_bfs(N+M,E,0)
ans = len(c & set(range(N)))==N
print(("YES" if ans else "NO")) | #二部グラフで連結判定
N,M = list(map(int,input().split()))
KL = [list(map(int,input().split())) for _ in [0]*N]
E = [[] for _ in [0]*(N+M)] #E[0] - E[N-1]:人, E[N] - E[N+M-1]:言語
for i,kl in enumerate(KL):
for l in kl[1:]:
E[i].append(N+l-1)
E[N+l-1].append(i)
def dist_bfs(N,E,start):
d = [-1]*N
d[start] = 0
q = [start]
while q:
qq = []
for i in q:
di = d[i]
for j in E[i]:
if d[j]!=-1:continue
d[j] = di+1
q.append(j)
q = qq
return d
d = dist_bfs(N+M,E,0)
ans = d[:N].count(-1)==0
print(("YES" if ans else "NO")) | p03911 |
n, m = list(map(int, input().split()))
tree = [[] for _i in range(m+1)]
k = []
for i in range(n):
x = list(map(int, input().split()))
for j in x[1:]:
tree[j].append(i)
k.append(x[1:])
visit = [0 for _ in range(n)]
from collections import deque
q = deque([0])
while q:
p = q.pop()
if visit[p]==1:
continue
visit[p] = 1
for i in k[p]:
for j in tree[i]:
if visit[j]==0:
q.appendleft(j)
if sum(visit)==n:
print("YES")
else:
print("NO") | n, m = list(map(int, input().split()))
tree = [[] for _i in range(m+n+1)]
for i in range(n):
x = list(map(int, input().split()))
tree[i].extend([i+n for i in x[1:]])
for j in x[1:]:
tree[j+n].append(i)
from collections import deque
q = deque([1])
visit = [0 for _i in range(m+n+2)]
visit[1] = 1
while q:
p = q.pop()
for j in tree[p]:
if visit[j]==0:
visit[j] = 1
q.appendleft(j)
if sum(visit[:n]) == n:
print("YES")
else:
print("NO") | p03911 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
class UnionFind(object):
def __init__(self,n):
self.__par=list(range(n))
self.__rank=[0]*n
self.__size=[1]*n
def root(self,k):
if(self.__par[k]==k): return k
self.__par[k]=self.root(self.__par[k])
return self.__par[k]
def unite(self,i,j):
i=self.root(i); j=self.root(j)
par=self.__par; rank=self.__rank; size=self.__size
if(i==j): return False
if(rank[i]>rank[j]):
par[j]=i
size[i]+=size[j]
else:
par[i]=j
size[j]+=size[i]
if(rank[i]==rank[j]): rank[j]+=1
return True
def is_same(self,i,j):
return self.root(i)==self.root(j)
def size(self,k):
return self.__size[self.root(k)]
def resolve():
n,m=list(map(int,input().split()))
uf=UnionFind(m)
S=set()
for _ in range(n):
L=list(map(int,input().split()))[::-1]
k=L.pop()
for i in range(k):
S.add(L[i]-1)
if(i+1<k):
uf.unite(L[i]-1,L[i+1]-1)
print(("YES" if(max(uf.size(i) for i in range(m))==len(S)) else "NO"))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,m=list(map(int,input().split()))
# n,m の bipartite graph
E=[[] for _ in range(n+m)]
for i in range(n):
L=list([int(x)-1 for x in input().split()])[::-1]
L.pop()
for l in L:
E[i].append(n+l)
E[n+l].append(i)
# 0,...,n-1 が連結かどうかを見る
used=[0]*(n+m)
used[0]=1
Q=[0]
while(Q):
v=Q.pop()
for nv in E[v]:
if(used[nv]): continue
used[nv]=1
Q.append(nv)
print(("YES" if(min(used[:n])==1) else "NO"))
resolve() | p03911 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
n, m = list(map(int, input().split()))
uf = UnionFind(n + m)
for i in range(n):
k, *L = list(map(int, input().split()))
for l in L:
uf.union(l - 1, m + i)
for i in range(n - 1):
if not uf.same(m + i, m + i + 1):
print("NO")
break
else:
print("YES")
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
def dfs(v):
for u in edge[v]:
if visited[u]:
continue
else:
visited[u] = True
dfs(u)
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n + m)]
for i in range(n):
_, *L = list(map(int, input().split()))
for l in L:
edge[i].append(n + l - 1)
edge[n + l - 1].append(i)
visited = [False] * (n + m)
dfs(0)
for i in range(n):
if not visited[i]:
print("NO")
break
else:
print("YES")
if __name__ == '__main__':
resolve()
| p03911 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
KL = [[int(i) for i in input().split()] for _ in range(N)]
lang = [[] for _ in range(M)]
for i in range(N) :
for j in KL[i][1:] :
lang[j-1].append(i)
visited = [False] * N
visited[0] = True
q = [0]
while q :
cur = q.pop()
for l in KL[cur][1:] :
for m in lang[l-1] :
if not visited[m] :
q.append(m)
visited[m] = True
if sum(visited) == N :
print('YES')
else :
print('NO') | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**5)
N, M = list(map(int, input().split()))
v = [[] for _ in range(N+M)]
for i in range(N) :
K, *L = list(map(int, input().split()))
for l in L :
v[N+l-1].append(i)
v[i].append(N+l-1)
visited = [False] * (N + M)
visited[0] = True
q = [0]
while q :
cur = q.pop()
for nex in v[cur] :
if not visited[nex] :
q.append(nex)
visited[nex] = True
if sum(visited[:N]) == N :
print('YES')
else :
print('NO') | p03911 |
class UnionFind:
def __init__(self, size):
self.data = [-1 for _ in range(size)]
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N + M + 1)
for i in range(1, N + 1):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(i, l + N)
if all(uf.same(i, N) for i in range(1, N)):
print("YES")
else:
print("NO")
| class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
N, M = list(map(int, input().split()))
uf = UnionFind(N + M + 1)
for i in range(1, N + 1):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(i, l + N)
if all(uf.same(i, N) for i in range(1, N)):
print("YES")
else:
print("NO") | p03911 |
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
N, M = list(map(int, input().split()))
uf = UnionFind(N + M + 1)
for i in range(1, N + 1):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(i, l + N)
if all(uf.same(i, N) for i in range(1, N)):
print("YES")
else:
print("NO") | class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N + M + 1)
used = [False] * (M + 1)
for i in range(1, N + 1):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(i, l + N)
used[l] = True
if uf.size(1) - sum(used) == N:
print("YES")
else:
print("NO")
| p03911 |
class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(N + M + 1)
used = set()
for i in range(1, N + 1):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(i, l + N)
used.add(l)
if uf.size(1) - len(used) == N:
print("YES")
else:
print("NO")
| class UnionFind:
def __init__(self, size):
self.data = [-1] * size
def find(self, x):
if self.data[x] < 0:
return x
else:
self.data[x] = self.find(self.data[x])
return self.data[x]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x != y:
if self.data[y] < self.data[x]:
x, y = y, x
self.data[x] += self.data[y]
self.data[y] = x
return (x != y)
def same(self, x, y):
return (self.find(x) == self.find(y))
def size(self, x):
return -self.data[self.find(x)]
N, M = list(map(int, input().split()))
uf = UnionFind(M + 1)
used = set()
for _ in range(N):
K, *L = list(map(int, input().split()))
for l in L:
uf.union(L[0], l)
used.update(L)
if uf.size(used.pop()) == 1 + len(used):
print("YES")
else:
print("NO")
| p03911 |
n,m=map(int,input().split())
class UnionFind:
#def -> foo=UnionFind(n,1) <- 1-based index, default is 0
#method -> foo.hoge(huga)
__slots__ = ["_size", "_first_idx", "_parents"]
def __init__(self, size: int, first_index: int = 0) -> None:
self._size = size
self._first_idx = first_index
self._parents = [-1] * (size + first_index)
def find(self, x: int) -> int:
if self._parents[x] < 0:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def unite(self, x: int, y: int) -> bool:
x, y = self.find(x), self.find(y)
if x == y:
return False
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
return True
def size(self, x: int) -> int:
return -self._parents[self.find(x)]
def group_count(self) ->int:
return sum(1 for i in self._parents if i<0)
lanper=[-1]*m
uf=UnionFind(n)
for i in range(n):
for j in list(map(int,input().split()))[1:]:
if lanper[j-1]==-1:lanper[j-1]=i
else:uf.unite(lanper[j-1],i)
print("YES") if uf.group_count()==1 else print("NO")
| n,m=map(int,input().split())
class UnionFind:
#def -> foo=UnionFind(n,1) <- 1-based index, default is 0
#method -> foo.hoge(huga)
__slots__ = ["_size", "_first_idx", "_parents"]
def __init__(self, size: int, first_index: int = 0) -> None:
self._size = size
self._first_idx = first_index
self._parents = [-1] * (size + first_index)
def find(self, x: int) -> int:
if self._parents[x] < 0:
return x
self._parents[x] = self.find(self._parents[x])
return self._parents[x]
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def unite(self, x: int, y: int) -> bool:
x, y = self.find(x), self.find(y)
if x == y:
return False
if self._parents[x] > self._parents[y]:
x, y = y, x
self._parents[x] += self._parents[y]
self._parents[y] = x
return True
def size(self, x: int) -> int:
return -self._parents[self.find(x)]
def group_count(self) ->int:
return sum(1 for i in self._parents if i<0)
lanper=[-1]*m
uf=UnionFind(n)
for i in range(n):
for j in list(map(int,input().split()))[1:]:
if lanper[j-1]==-1:lanper[j-1]=i
else:uf.unite(lanper[j-1],i)
print("YES") if uf.size(0)==n else print("NO")
| p03911 |
N,M = list(map(int,input().split()))
people = [None] * N
from collections import defaultdict
lang = defaultdict(set)
for i in range(N):
people[i] = list(map(int,input().split()))[1:]
for l in people[i]:
lang[l].add(i)
# 0番の人からたどって全員に行けるか
stack = [0]
seen = [False for i in range(N)]
while stack:
p = stack.pop()
if seen[p]:
continue
seen[p] = True
la = people[p] # その人が話せる言語リスト
for l in la:
lang[l].remove(p)
for pe in lang[l]:
stack.append(pe)
for s in seen:
if not s:
print("NO")
break
else:
print("YES")
| # 人も言語もグラフの頂点と見なす
# ある人がある言語を話せる場合連結となる
# 頂点のキーは[言語 or 人][番号(人番号 or 言語番号)]
# 0:言語 1:人
N,M = list(map(int,input().split()))
from collections import defaultdict
E = [[],[]]
E[0] = [[] for i in range(M)]
E[1] = [[] for i in range(N)]
for i in range(N):
langs = list(map(int,input().split()))[1:]
for lang in langs:
E[1][i].append((0,lang-1))
E[0][lang-1].append((1,i))
# 任意の頂点からBFSして、全ての人の頂点が往訪済みになればOK
from collections import deque
q = deque([])
# 人で、0番目からスタート
q.append((1,0))
seen = [[],[]]
seen[0] = [False for i in range(M)]
seen[1] = [False for i in range(N)]
while q:
kind,v = q.popleft()
if seen[kind][v]:
continue
seen[kind][v] = True
children = E[kind][v]
for child in children:
q.append([child[0],child[1]])
for s in seen[1]:
if not s:
print("NO")
break
else:
print("YES")
| p03911 |
import sys
input = sys.stdin.readline
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m= list(map(int, input().split()))
a= [list(map(int, input().split())) for i in range(n)]
uf=UnionFind(m)
x=[0]*m
for i in range(n):
if a[i][0]==1:
x[a[i][1]-1]+=1
else:
for j in range(1,len(a[i])-1):
uf.union(a[i][j]-1,a[i][j+1]-1)
y=uf.group_count()
if y==1:
print('YES')
exit()
else:
count=0
z=list(uf.all_group_members().values())
for i in range(y):
if len(z[i])>=2:
count+=1
if count>=2:
print('NO')
exit()
else:
if x[z[i][0]] == n:
print('YES')
exit()
elif x[z[i][0]]>0:
print('NO')
exit()
print('YES')
| import sys
input = sys.stdin.readline
# ユニオンファインド
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
n,m= list(map(int, input().split()))
a= [list(map(int, input().split())) for i in range(n)]
uf=UnionFind(m)
x=[0]*m
for i in range(n):
if a[i][0]==1:
x[a[i][1]-1]=1
else:
for j in range(1,len(a[i])-1):
uf.union(a[i][j]-1,a[i][j+1]-1)
if x[a[i][j]-1]==0:
x[a[i][j]-1]=1
if j==len(a[i])-2:
if x[a[i][j+1]-1]==0:
x[a[i][j+1]-1]=1
for i in range(m):
if x[i]==0:
if i==m-1:
uf.union(m-1,0)
else:
uf.union(i,i+1)
y=uf.group_count()
if y==1:
print('YES')
else:
print('NO')
| p03911 |
while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while p not in man:
if ball >0:ball,man[a%n] =ball-1, man[a%n]+1
elif ball == 0:ball,man[a%n] = man[a%n],ball
a+=1
print((man.index(max(man)))) | while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
if ball >0:ball,man[a%n] =ball-1, man[a%n]+1
elif ball == 0:ball,man[a%n] = man[a%n],ball
a+=1
if p in man:break
print((man.index(max(man)))) | p00740 |
while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
if ball >0:ball,man[a%n] =ball-1, man[a%n]+1
elif ball == 0:ball,man[a%n] = man[a%n],ball
a+=1
if p in man:break
print((man.index(max(man)))) | while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:ball,man[a] =ball-1, man[a]+1
elif ball == 0:ball,man[a] = man[a],ball
a+=1
if p in man:break
print((man.index(max(man))))
| p00740 |
while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:
ball-=1
man[a]+=1
elif ball == 0:ball,man[a] = man[a],ball
a+=1
if p in man:break
print((man.index(max(man)))) | while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:
ball-=1
man[a]+=1
elif ball == 0:ball,man[a] = man[a],ball
if man[a]==p:break
a+=1
print(a) | p00740 |
while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:
ball-=1
man[a]+=1
elif ball == 0:ball,man[a] = man[a],ball
if man[a]==p:break
a+=1
print(a) | while 1:
n,p = list(map(int,input().split()))
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:
ball-=1
man[a]+=1
elif ball == 0:ball,man[a] = man[a],ball
if man[a]==p:break
a+=1
print((man.index(max(man)))) | p00740 |
while 1:
n,p = list(map(int,input().split()))
if n == 0: break
have = [0]*n
stone = p
i = count = 0
while 1:
count += 1
if stone > 0:
have[i] += 1
stone -= 1
else:
stone += have[i]
have[i] = 0
if have[i] == p:
break
i = (i+1)%n
print(i) | while 1:
n,p = list(map(int,input().split()))
if n == 0: break
have = [0]*n
stone = p
i = 0
while 1:
if stone > 0:
have[i] += 1
stone -= 1
else:
stone += have[i]
have[i] = 0
if have[i] == p:
break
i = (i+1)%n
print(i) | p00740 |
while 1:
n,p = list(map(int,input().split()))
if n == 0: break
have = [0]*n
stone = p
i = 0
while 1:
if stone > 0:
have[i] += 1
stone -= 1
else:
stone += have[i]
have[i] = 0
if have[i] == p:
break
i = (i+1)%n
print(i) | while 1:
n,p = list(map(int,input().split()))
if n == 0: break
have = [0]*n
cup = p
i = 0
while 1:
if cup > 0:
have[i] += 1
cup -= 1
if have[i] == p:
break
else:
cup += have[i]
have[i] = 0
i = (i+1)%n
print(i) | p00740 |
while True:
n,p = list(map(int,input().split()))
if n==p==0: break
s,c = [0]*n,p
i = 0
while True:
if c:
c-=1
s[i%n]+=1
if s[i%n]==p: break
else:
c+=s[i%n]
s[i%n] = 0
i+=1
print((i%n)) | while True:
n,p = list(map(int,input().split()))
if n==p==0: break
l = [0]*n
i,k = 0,p
while True:
i %= n
if k==0: k,l[i] = l[i],0
else:
k-=1
l[i]+=1
if l[i]==p: break
i+=1
print(i) | p00740 |
while True:
n, p = list(map(int, input().split()))
pp = p
if n == p == 0:
break
stones = [0] * n
i = 0
while True:
er = i % n
if p == 1 and stones[er] == pp - 1:
print(er)
break
if p >= 1:
stones[er] += 1
p -= 1
else:
p += stones[er]
stones[er] = 0
i += 1 | while True:
n, p = list(map(int, input().split()))
pp = p
if n == p == 0:
break
stones = [0] * n
for i in range(1000000):
er = i % n
if p >= 1:
stones[er] += 1
p -= 1
if p == 0 and stones[er] == pp:
print(er)
break
else:
p = stones[er]
stones[er] = 0 | p00740 |
from sys import stdin, stdout, stderr
while 1:
n, p = list(map(int, stdin.readline().split()))
if n + p == 0:
break
a = [0] * n
wan = p
for i in range(10**6):
if wan > 0:
a[i % n] += 1
wan -= 1
else:
wan += a[i % n]
a[i % n] = 0
if a[i % n] == p:
print((i % n))
break | from sys import stdin, stdout, stderr
a = [0] * 50
while 1:
n, p = list(map(int, stdin.readline().split()))
if n + p == 0:
break
wan = p
i = 0
while a[i] < p:
if wan > 0:
a[i] += 1
wan -= 1
else:
wan += a[i]
a[i] = 0
i = (i + 1) % n
print(i)
a[i] = 0 | p00740 |
N, X = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(N)]
result = len(m)
X -= sum(m)
while X >= min(m):
result += 1
X -= min(m)
print(result) | N, X = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(N)]
print((len(m)+(X-sum(m))//min(m))) | p03370 |
n,x = list(map(int,input().split()))
y = 1000
for i in range(n):
z = int(eval(input()))
x -= z
y = min(y,z)
print((n+x//y))
| n,x=list(map(int,input().split()))
M=sorted([int(eval(input())) for i in range(n)])
print((len(M)+(x-sum(M))//M[0]))
| p03370 |
n,x = list(map(int,input().split()))
m_list = [int(eval(input())) for _ in range(n)]
remaining = x - sum(m_list)
print((len(m_list) + (remaining//min(m_list)))) | n,x = list(map(int,input().split()))
m_list = [int(eval(input())) for _ in range(n)]
remaining = x - sum(m_list)
print((n + (remaining//min(m_list)))) | p03370 |
N, X = list(map(int, input().split()))
m = []
for i in range(N):
m.append(int(eval(input())))
min_kona = 0
for val in m:
min_kona += val
min_donut = min(m)
cnt = (X - min_kona) // min_donut + len(m)
print(cnt) | N, X = list(map(int, input().split()))
m = []
for i in range(N):
m.append(int(eval(input())))
min_kona = sum(m)
min_donut = min(m)
cnt = (X - min_kona) // min_donut + len(m)
print(cnt) | p03370 |
N,X = list(map(int,input().split()))
m = [int(eval(input())) for i in range(N)]
m.sort()
ans = 0
for i in range(N):
X -= m[i]
if X < 0:
break
ans += 1
if X > 0:
ans += X // min(m)
print(ans) | N,X = list(map(int,input().split()))
m = [int(eval(input())) for i in range(N)]
ans = N + (X - sum(m)) // min(m)
print(ans) | p03370 |
n,x=list(map(int, input().split()))
m=[int(eval(input())) for _ in range(n)]
count=0
for i in range(len(m)):
if x>=m[i]:
x-=m[i]
count+=1
min_donut=min(m)
while(x>=min_donut):
x-=min_donut
count+=1
print(count) | n,x=list(map(int, input().split()))
m=[int(eval(input())) for _ in range(n)]
print(((x-sum(m))//min(m)+n)) | p03370 |
n,x = list(map(int,input().split()))
m = []
for i in range(n):
m.append(int(eval(input())))
print((n+int((x-sum(m))/min(m)))) | N,X = list(map(int,input().split()))
m = []
for _ in range(N):
m.append(int(eval(input())))
print(((X-sum(m))//min(m)+N))
| p03370 |
N,X = list(map(int,input().split()))
M = [int(eval(input())) for i in range(N)]
X -= sum(M)
M.sort()
ans = -1
while X >= 0:
X -= M[0]
ans += 1
print((ans+N))
| N, X = list(map(int,input().split()))
m = []
cnt = 0
for j in range(N):
m.append(int(eval(input())))
a = X - sum(m)
cnt = a // min(m) + N
print(cnt) | p03370 |
N,X = list(map(int, input().split()))
m = [int(eval(input())) for i in range(N)]
for x in m:
X -= x
m.sort()
n = int(X/m[0])
print((n + len(m))) | N,X = list(map(int,input().split()))
m = [int(eval(input())) for _ in range(N)]
ans = N
X -= sum(m)
m = min(m)
ans += X//m
print(ans) | p03370 |
n,x = list(map(int,input().split()))
m = [int(eval(input())) for i in range(n)]
x -= sum(m)
print((x//min(m)+n)) | n, x = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(n)]
x -= sum(m)
print((n + x // min(m))) | p03370 |
n, x, *m = list(map(int, open(0).read().split()))
ans = 0
for i in sorted(m):
if x>=i:
x -= i
ans+=1
mx = min(m)
print((ans + (x//mx))) | n, x, *m = list(map(int, open(0).read().split()))
ans = 0
for i in sorted(m):
if x>=i:
x -= i
ans+=1
print((ans+x//min(m))) | p03370 |
N, X = list(map(int, input().split()))
mn = [0]*N
for i in range(N):
mn[i] = int(eval(input()))
ans = N
x = X - sum(mn)
while(x >= min(mn)):
if x // min(mn) == 0:
mn[mn.index(min(mn))] = 1000000
else:
if x >= min(mn):
x -= min(mn)
ans += 1
print(ans) | N, X = list(map(int, input().split()))
mn = [0]*N
for i in range(N):
mn[i] = int(eval(input()))
ans = N
x = X - sum(mn)
while(x >= min(mn)):
if x // min(mn) == 0:
mn[mn.index(min(mn))] = 1000000
else:
x -= min(mn)
ans += 1
print(ans) | p03370 |
n, x = list(map(int, input().split()))
m = []
for i in range(n):
m.append(int(eval(input())))
count = 0
a = min(m)
s = sum(m)
x -= s
count += n
while x >= a:
x -= a
count += 1
print(count) | n, x = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(n)]
x -= sum(m)
count = n
mincost = 10**5
for i in range(n):
mincost = min(mincost, m[i])
count += x // mincost
print(count) | p03370 |
n, m = list(map(int, input().split()))
ls = [int(eval(input())) for _ in range(n)]
ls.sort()
m -= sum(ls)
cnt = n
while True:
if m >= ls[0]:
m -= ls[0]
cnt += 1
else:
break
print(cnt)
| n, m = list(map(int, input().split()))
ls = [int(eval(input())) for _ in range(n)]
print((n+((m-sum(ls))//min(ls)))) | p03370 |
N,X = list(map(int,input().split()))
M = [int(eval(input())) for _ in range(N)]
print((N + (X-sum(M))//min(M))) | # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,X = list(map(int,input().split()))
M = [int(eval(input())) for _ in range(N)]
r = X - sum(M)
print((N + r//min(M))) | p03370 |
n,x=list(map(int,input().split()))
ln=[int(eval(input())) for i in range(n)]
print((n+(x-sum(ln))//min(ln))) | n,x=list(map(int,input().split()))
ln=[int(eval(input())) for _ in range(n)]
print((n+(x-sum(ln))//min(ln))) | p03370 |
n,x = list(map(int,input().split()))
m = list(int(eval(input())) for i in range(n))
m.sort()
z = sum(m)
s = n
while x > z:
z += m[0]
if x >= z:
s += 1
print(s) | n,x = list(map(int,input().split()))
m = list(int(eval(input())) for i in range(n))
m.sort()
z = sum(m)
print((n+(x-z)//m[0])) | p03370 |
n,x=list(map(int, input().split()))
min_cost=float('inf')
cnt=0
for i in range(n):
mi = int(eval(input()))
x -= mi
cnt += 1
min_cost = min(min_cost,mi)
while x >= min_cost:
x -= min_cost
cnt += 1
print(cnt) | n,x = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
print((len(l)+(x-sum(l))//min(l))) | p03370 |
N, X = [int(x) for x in input().split()]
list01=[]
for i in range(N):
j = int(eval(input()))
list01.append(j)
j = 0
mass = sum(list01)
while mass <= X:
j += 1
mass = sum(list01) + min(list01) * j
print((N + j -1)) | N, X = [int(x) for x in input().split()]
list01 = []
for i in range(N):
i = int(eval(input()))
list01.append(i)
min_01 = 0
for i in range(len(list01)):
if min_01 == 0:
min_01 = list01[i]
elif list01[i] < min_01:
min_01 = list01[i]
for i in range(len(list01)):
X -= list01[i]
print((X // min_01 + N))
| p03370 |
N, X = list(map(int, input().split()))
M = [int(eval(input())) for _ in range(N)]
Ms = sorted(M)
print((len(Ms) + (X-sum(Ms))//Ms[0])) | N, X = list(map(int, input().split()))
M = [int(eval(input())) for _ in range(N)]
print((len(M) + (X-sum(M))//min(M))) | p03370 |
n,x = list(map(int,input().split()))
m = [int(eval(input())) for _ in range(n)]
ans = 0
minm = 1000
for i in range(n):
x -= m[i]
minm = min(minm,m[i])
ans += 1
while x >= minm:
x -= minm
ans += 1
print(ans) | n,x = list(map(int,input().split()))
m = [int(eval(input())) for _ in range(n)]
x -= sum(m)
ans = n + x//min(m)
print(ans) | p03370 |
from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
@lru_cache(maxsize=1000000)
def dp(rest,score):
ansbox=[]
scorebox=[]
for i in m_list:
if (rest-i)>0:
ansbox.append(dp(rest-i,score+1))
scorebox.append(dp(rest-i, score+1)[1])
if ansbox:
max_index=scorebox.index(max(scorebox))
return ansbox[max_index][0],ansbox[max_index][1]
else:
return rest,score
pass
N,X=list(map(int,input().split()))
m_list=[]
newX=X
sum=0
for i in range(N):
inp=int(eval(input()))
m_list.append(inp)
newX-=inp
score=dp(newX,N)
print((score[1]))
| N,X=list(map(int,input().split()))
M=[int(eval(input())) for _ in range(N)]
print((len(M)+(X-sum(M))//min(M)))
| p03370 |
n,x = list(map(int,input().split()))
l = []
s = 0
for i in range(n):
l.append(int(eval(input())))
s += l[i]
for j in range(0,100000):
if (x-s) == 0:
print(n)
break
elif ((x-s)/(min(l)*(j+1))) < 1:
print((n+j))
break | n,x = list(map(int,input().split()))
l = []
s = 0
for i in range(n):
l.append(int(eval(input())))
s += l[i]
print((int(n+(x-s)/min(l)))) | p03370 |
num, beaking = list(map(int, input().split()))
list_category = [int(eval(input())) for i in range(num)]
nokori = beaking - sum(list_category)
nokori_num = nokori // min(list_category)
total = num + nokori_num
print(total) | n, x = list(map(int, input().split()))
arr = [int(eval(input())) for i in range(n)]
x = x - sum(arr)
print(((x // min(arr)) + n)) | p03370 |
n,x = list(map(int,input().split()))
m = [int(eval(input())) for i in range(n)]
a = n
s = sum(m)
while s < x:
s+=min(m)
a += 1
print(([a,a-1][s>x]))
| n,x = list(map(int,input().split()))
m = list(int(eval(input())) for i in range(n))
x -= sum(m)
print((x//min(m)+n))
| p03370 |
n, x = list(map(int, input().split()))
M = []
for _ in range(n):
M.append(int(eval(input())))
M.sort()
cnt = 0
for m in M:
x -= m
cnt += 1
while x > 0:
x -= M[0]
if x >= 0:
cnt += 1
print(cnt)
| n,x=list(map(int, input().split()))
m = [int(eval(input())) for _ in range(n)]
ans = n
m.sort()
x -=sum(m)
while x > 0:
x -= m[0]
if x >= 0:
ans += 1
print(ans) | p03370 |
N, X = list(map(int, input().split()))
list = []
for i in range(N):
m = int(eval(input()))
list.append(m)
print((N + (X - sum(list)) // min(list))) | N, X = list(map(int, input().split()))
m = [int(eval(input())) for _ in range(N)]
print((N + (X - sum(m)) // min(m))) | p03370 |
n, x = list(map(int, input().split()))
cnt = 0
m = [int(eval(input())) for _ in range(n)]
M = sorted(m)
if sum(m) <= x:
cnt += (n +(x - sum(m)) // min(m))
else:
while x >= 0:
for i in range(n):
x -= M[i]
cnt += 1
print(cnt) | n, x = list(map(int, input().split()))
m = [int(eval(input())) for i in range(n)]
l = []
for i in range(n):
X = (x - sum(m)) // m[i]
l.append(X)
print((n + max(l))) | p03370 |
N, X = list(map(int, input().split()))
M = [int(eval(input())) for i in range(N)]
cnt = 0
for i in M:
X -= i
cnt += 1
while True:
X -= min(M)
if X < 0:
break
cnt += 1
print(cnt) | N, X = list(map(int, input().split()))
M = [int(eval(input())) for i in range(N)]
cnt = N
X -= sum(M)
cnt += X // min(M)
print(cnt)
| p03370 |
N,X = list(map(int,input().split()))
M = []
for i in range(N) :
m = int(eval(input()))
M.append(m)
ans = N
X -= sum(M)
while X >= min(M) :
ans += 1
X -= min(M)
print(ans)
| N,X = list(map(int,input().split()))
M = []
for i in range(N) :
M.append(int(eval(input())))
ans = ((X-sum(M))//min(M))+N
print(ans)
| p03370 |
N, X = list(map(int,input().split()))
M = [int(eval(input())) for _ in range(N)]
tmp = X - sum(M)
if(tmp == 0):
print(N)
else:
print((tmp//min(M) + N)) | N, X = list(map(int,input().split()))
M = [int(eval(input())) for _ in range(N)]
X = X - sum(M)
cnt = N
x = X
tmp = 0
for m in M:
tmp = max(tmp, x//m)
print((tmp+cnt)) | p03370 |
n, x = list(map(int, input().split()))
ls = [int(eval(input())) for _ in range(n)]
x -= sum(ls)
print((n + x // min(ls))) | n, x = list(map(int, input().split()))
ls = [int(eval(input())) for _ in range(n)]
print((n + (x - sum(ls)) // min(ls))) | p03370 |
n, x = list(map(int, input().split()))
m = [int(eval(input())) for i in range(n)]
sum = 0
min = 1000000
for i in range(n):
sum+=m[i]
if min > m[i]: min = m[i]
x-=sum
print((n+int(x/min))) | n, x = list(map(int, input().split()))
m = [int(eval(input())) for i in range(n)]
sum = 0
for i in range(n):
sum+=m[i]
x-=sum
print((n+int(x/min(m)))) | p03370 |
N,X = list(map(int,input().split()))
a = [int(eval(input())) for i in range(N)]
moto = X - sum(a)
ans = N
while moto >= min(a):
ans += 1
moto = moto - min(a)
print(ans) | N,X = list(map(int,input().split()))
a = [int(eval(input())) for i in range(N)]
ans = N + (X - sum(a)) // min(a)
print(ans) | p03370 |
n, x = input().split()
n = int(n)
x = int (x)
m = []
i_min = 0
result = 0
for i in range(n):
m.append(int(eval(input())))
for i in range(len(m)):
x = x - m[i]
result = result + 1
for i in range(len(m)):
if m[i_min] > m[i]:
i_min = i
for i in range(x):
if x >= m[i_min]:
result = result + 1
x = x - m[i_min]
else:
break
print(result) | #NとXの読み込み
n, x = input().split()
n = int(n)
x = int (x)
m = []
i_min = 0
result = 0
#m1からmnまでの読み込み
for i in range(n):
m.append(int(eval(input())))
#全種類ひとつずつ作る
for i in range(len(m)):
x = x - m[i]
result = result + 1
#リストの中の最小値を突き止める
for i in range(len(m)):
if m[i_min] > m[i]:
i_min = i
#i_minを作れるだけ作る
for i in range(x):
if x >= m[i_min]:
result = result + 1
x = x - m[i_min]
else:
break
#印刷
print(result)
| p03370 |
#NとXの読み込み
n, x = input().split()
n = int(n)
x = int (x)
m = []
i_min = 0
result = 0
#m1からmnまでの読み込み
for i in range(n):
m.append(int(eval(input())))
#全種類ひとつずつ作る
for i in range(len(m)):
x = x - m[i]
result = result + 1
#リストの中の最小値を突き止める
for i in range(len(m)):
if m[i_min] > m[i]:
i_min = i
#i_minを作れるだけ作る
for i in range(x):
if x >= m[i_min]:
result = result + 1
x = x - m[i_min]
else:
break
#印刷
print(result)
| #データの読み込み
n, x = input().split()
n = int(n)
x = int(x)
m = []
i_min = 0
gokei = 0
#n個の入力に対するループ
for i in range(n):
#問題からの入力をintに変換してリストへ格納
m.append(int(eval(input())))
#全部を1つずつ作った場合の粉量の合計
gokei = gokei + m[i]
#使う粉量が一番少ないドーナツを見つける
if m[i_min] > m[i]:
i_min = i
#全部を1つずつ作った後に残る粉量
x = x - gokei
print((int(x/m[i_min]) + n)) | p03370 |
a, b, c = list(map(int, input().split()))
n=0
while True:
if c%a == 0:
n += 1
a += 1
if a == b:
break
print(n)
| a, b, c = list(map(int, input().split()))
n=0
while True:
if c%a == 0:
n += 1
a += 1
if a > b:
break
print(n)
| p02398 |
a,b,c = [int(x) for x in input().split( )]
div = []
for x in range(1,c+1):
if c % x == 0:
div.append(x)
r = []
for x in range(a,b+1):
r.append(x)
answer = 0
for x in div:
for y in r:
if x == y:
answer += 1
print(answer)
| a,b,c = [int(x) for x in input().split( )]
count = 0
for number in range(a,b+1):
if c % number == 0:
count += 1
print(count)
| p02398 |
a,b,c=list(map(int,input().split(" ")))
count=0
while(1):
if c%a==0:
count+=1
a+=1
if a==b:
break
print(count)
| a,b,c=list(map(int,input().split(" ")))
count=0
while(a<=b):
if c%a==0:
count+=1
a+=1
print(count)
| p02398 |
from operator import add
from functools import reduce
def divisor_generator(a, b, c):
for i in range(a, b+1):
yield (1 if c%i == 0 else 0)
a, b, c = list(map(int, input().split(' ')))
print((reduce(add, divisor_generator(a, b, c)))) | a, b, c = list(map(int, input().split()))
cnt = 0
for n in range(a, b+1):
if c % n == 0:
cnt += 1
print(cnt)
| p02398 |
import sys
a, b, c = [ int( val ) for val in sys.stdin.readline().split( ' ' ) ]
cnt = 0
i = a
while i <= b:
if ( c % i ) == 0:
cnt += 1
i += 1
print(( "{}".format( cnt ) )) | import sys
a, b, c = [ int( val ) for val in sys.stdin.readline().split( ' ' ) ]
cnt = 0
for divisor in range( a, b+1 ):
if ( c % divisor ) == 0:
cnt += 1
print(( "{}".format( cnt ) )) | p02398 |
a, b, c = list(map(int, input().split()))
cnt = 0
for i in range(a, b+1):
if c % i == 0:
cnt += 1
print(cnt) | a, b, c = list(map(int, input().split()))
divisor = 0
for n in range(a, b+1):
if c % n == 0:
divisor += 1
print(divisor) | p02398 |
import math
a, b, c = list(map(int, input().split()))
l = []; d = int(math.sqrt(c)); e = 0
for i in range(1, d + 1):
if i * i == c: l += [i]
elif c % i == 0: l += [i, c // i]
for x in l:
if a <= x <= b: e += 1
print(e) | a, b, c = list(map(int, input().split()))
ans = 0
for i in range(a, b + 1):
if c % i == 0:
ans += 1
print(ans)
| p02398 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
from bisect import bisect_left
S = input().rstrip()
T = input().rstrip()
LS = len(S)
index = defaultdict(list) # alphabet to indices
for i,s in enumerate(S):
index[s].append(i)
index
x = -1 # 今見た場所。次はx+1以上からとる。
for t in T:
arr = index[t]
if len(arr) == 0:
x = -2
break
y = (x+1)%LS
i = bisect_left(arr,y)
if i < len(arr):
next_x = (x+1) + arr[i] - y
else:
next_x = (x+1) + arr[0] - y + LS
x = next_x
answer = x+1
print(answer) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from bisect import bisect_right
S = [ord(x)-ord('a') for x in readline().rstrip().decode('utf-8')]
T = [ord(x)-ord('a') for x in readline().rstrip().decode('utf-8')]
index = [[] for _ in range(26)]
for i,x in enumerate(S):
index[x].append(i)
LS = len(S)
for x in index:
if x:
x.append(x[0] + LS)
ptr = -1 # 最後に使った文字
complete = True
for t in T:
seq = index[t]
if not seq:
complete = False
break
i = ptr%LS
j = bisect_right(seq,i)
ptr += seq[j]-i
if complete:
answer = ptr + 1
else:
answer = -1
print(answer) | p02937 |
S = list([ord(x)-ord('a') for x in input().strip()])
T = list([ord(x)-ord('a') for x in input().strip()])
L = len(S)
occ = [[] for i in range(26)]
for i, c in enumerate(S):
occ[c].append(i)
for c in T:
if occ[c] == []:
print((-1))
quit()
total = 0
cur = -1
def getLowest(bound, lo, hi, lst):
# Return index of lowest element in list greater than bound
if lo >= hi:
if lst[lo] > bound:
return lo
else:
return 0
mid = lo + (hi - lo) // 2
if lst[mid] > bound:
return getLowest(bound, lo, mid, lst)
else:
return getLowest(bound, mid+1, hi, lst)
for i, char in enumerate(T):
newpos = occ[char][getLowest(cur, 0, len(occ[char])-1, occ[char])]
if cur == newpos:
total += L
elif newpos < cur:
total += L - cur + newpos
else:
total += newpos - cur
cur = newpos
print(total)
| S = list([ord(x)-ord('a') for x in input().strip()])
T = list([ord(x)-ord('a') for x in input().strip()])
L = len(S)
occ = [[] for i in range(26)]
for i, c in enumerate(S):
occ[c].append(i)
for c in T:
if occ[c] == []:
print((-1))
quit()
total = 0
cur = -1
def getLowest(bound, lo, hi, lst):
# Return lowest element in list greater than bound
while lo < hi:
mid = lo + (hi - lo) // 2
if lst[mid] > bound:
hi = mid
else:
lo = mid + 1
if lst[lo] > bound:
return lst[lo]
return lst[0]
for i, char in enumerate(T):
newpos = getLowest(cur, 0, len(occ[char])-1, occ[char])
if cur == newpos:
total += L
elif newpos < cur:
total += L - cur + newpos
else:
total += newpos - cur
cur = newpos
print(total)
| p02937 |
from bisect import bisect_right
from collections import defaultdict
import sys
read = sys.stdin.readline
s = read()[:-1]
t = read()[:-1]
# 即時終了
if set(t) - set(s):
print((-1))
exit()
# 前処理
# 0based indexにおいてi文字目以降に文字cが出てくるidxを取得する
# 前処理の前処理、0文字目から見たときにその文字が何文字目にあるかを記録しておく
mojiidx = defaultdict(lambda: [])
for i, ss in enumerate(s + s):
mojiidx[ss].append(i)
# i文字目において、次に文字cが出てくるのは何文字あと？
skiptable = []
for i in range(0, len(s)):
tmp = {}
for c, ls in list(mojiidx.items()):
tmp[c] = ls[bisect_right(ls, i)] - i
skiptable.append(tmp)
# print(skiptable)
# 本処理
# 最初にうまく飛べる点を探索
for i, ss in enumerate(s):
if ss == t[0]:
now = i
break
for tt in t[1:]:
idx = now % len(s)
now += skiptable[idx][tt]
print((now + 1)) |
from bisect import bisect_right
from collections import defaultdict
import sys
read = sys.stdin.readline
s = read()[:-1]
t = read()[:-1]
# 即時終了
if set(t) - set(s):
print((-1))
exit()
# 前処理
# 0文字目から見たときにその文字が何文字目にあるかを記録しておく
mojiidx = defaultdict(lambda: [])
for i, ss in enumerate(s + s):
mojiidx[ss].append(i)
# 本処理
# 最初にうまく飛べる点を探索
for i, ss in enumerate(s):
if ss == t[0]:
now = i
break
for tt in t[1:]:
idx = now % len(s)
# 前処理の列から文字ttが何文字あとに出現するかを探索する
ls = mojiidx[tt]
tmp = ls[bisect_right(ls, idx)] - idx
now += tmp
print((now + 1)) | p02937 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
import copy
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(S, T):
si = defaultdict(deque)
for i, s in enumerate(S):
si[s].append(i)
for k in si:
si[k].append(-1)
wsi = si
used = defaultdict(deque)
ans = 0
i = -1
# from pprint import pprint
# pprint(si)
for t in T:
if t not in wsi:
return -1
while wsi[t][0] != -1:
j = wsi[t].popleft()
used[t].append(j)
if j > i:
i = j
break
else:
ans += len(S)
for k, q in used.items():
while q:
wsi[k].appendleft(q.pop())
i = wsi[t].popleft()
used = defaultdict(deque)
used[t].append(i)
return ans + i + 1
def f(S, T):
ans = -1
ss = S * 1000
for t in T:
if t not in S:
return -1
for i in range(ans+1, len(ss)):
if t == ss[i]:
ans = i
break
return ans + 1
def main():
S = read_str()
T = read_str()
print(slv(S, T))
# S = ''.join(random.choices('ab', k=3))
# T = ''.join(random.choices('ab', k=10))
# print(S)
# print(T)
# print(slv(S, T))
# print(f(S, T))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(S, T):
if len(set(c for c in T) - set(c for c in S)) > 0:
return -1
from collections import defaultdict
si = defaultdict(list)
for i, c in enumerate(S):
si[c].append(i)
ans = 0
ci = 0
from bisect import bisect_left
for i, c in enumerate(T):
j = bisect_left(si[c], ci)
if j == len(si[c]):
j = 0
ans += 1
ci = si[c][j] + 1
return (ans)*len(S) + ci
def main():
S = read_str()
T = read_str()
print(slv(S, T))
if __name__ == '__main__':
main()
| p02937 |
#ABC138-E Strings of Impurity
"""
sの好きなだけのループに対する部分文字列tを求める
tにあってsにない文字がある時点でno
そうでないならば必ず達成可能で、
tに対してループを回し(i)、
sのj文字目に関して、それより後に初めて出てくるt[i+1]の場所をindexで返し,i+=1,j=そのindex
にする。
そのようなindexがないならば、j=0とし、またはじめから回す。
"""
import sys
import bisect
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
s = readline().rstrip().decode('utf-8')
t = readline().rstrip().decode('utf-8')
s_s = set(list(s))
t_s = set(list(t))
flag = 1 if s_s & t_s == t_s else 0
if not flag:
print((-1))
exit()
#2進数で、
lst1 = [[] for _ in range(26)]
kijun = ord("a")
for idx,i in enumerate(s):
lst1[ord(i)-kijun].append(idx)
i = 0
roop = 0
count = 0
while True:
if i >= len(t):
print((roop*len(s)+count)) #countは0-indexedの為
break
now = ord(t[i])-kijun
res = bisect.bisect_left(lst1[now],count)
if res == len(lst1[now]):
roop += 1
count = 0
res = bisect.bisect_left(lst1[now],count)
count = lst1[now][res]+1 #その次の文字から
else:
count = lst1[now][res]+1
i += 1
| #ABC138-E Strings of Impurity
"""
sの好きなだけのループに対する部分文字列tを求める
tにあってsにない文字がある時点でno
そうでないならば必ず達成可能で、
tに対してループを回し(i)、
sのj文字目に関して、それより後に初めて出てくるt[i+1]の場所をindexで返し,i+=1,j=そのindex
にする。
そのようなindexがないならば、j=0とし、またはじめから回す。
"""
import sys
import bisect
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
s = readline().rstrip().decode('utf-8')
t = readline().rstrip().decode('utf-8')
s_s = set(list(s))
t_s = set(list(t))
flag = 1 if s_s & t_s == t_s else 0
if not flag:
print((-1))
exit()
#lst1:各アルファベットごとに、何番目に出てくるか
lst1 = [[] for _ in range(26)]
kijun = ord("a")
for idx,i in enumerate(s):
lst1[ord(i)-kijun].append(idx)
i = 0
roop = 0
count = 0
while True:
if i >= len(t):
print((roop*len(s)+count))
break
now = ord(t[i])-kijun
res = bisect.bisect_left(lst1[now],count)
if res == len(lst1[now]):
roop += 1
count = 0
res = bisect.bisect_left(lst1[now],count)
count = lst1[now][res]+1 #その次の文字から
else:
count = lst1[now][res]+1
i += 1
| p02937 |
from collections import defaultdict
from bisect import bisect_left
S = input().rstrip()
T = input().rstrip()
LS = len(S)
index = defaultdict(list)
for i, s in enumerate(S):
index[s].append(i)
x = -1
for t in T:
arr = index[t]
if len(arr) == 0:
print((-1))
exit()
y = (x+1)%LS
i = bisect_left(arr, y)
if i < len(arr):
next_x = (x+1) + arr[i] - y
else:
next_x = (x+1) + arr[0] + LS - y
x = next_x
ans = x+1
print(ans) | from collections import defaultdict
from bisect import *
S = input().rstrip()
T = input().rstrip()
LS = len(S)
index = defaultdict(list)
for i, s in enumerate(S):
index[s].append(i)
x = -1
loop = 0
for t in T:
arr = index[t]
if len(arr) == 0:
print((-1))
exit()
i = bisect(arr, x)
if i == len(arr):
loop += 1
x = arr[0]
else:
x = arr[i]
print((loop*LS+x+1)) | p02937 |
import sys
from collections import defaultdict
import bisect
sys.setrecursionlimit(10 ** 7)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = sr()
len_S = len(S)
T = sr()
dict_S = defaultdict(list)
for i, s in enumerate(S):
dict_S[s].append(i)
answer = 0
cur = -1
for t in T:
turn = 0 # 1周した時 len_S - cur
if not dict_S[t]:
print((-1))
exit()
indexes = dict_S[t] + [len_S]
i = bisect.bisect_right(indexes, cur)
next = indexes[i]
if next == len_S:
turn = len_S - cur - 1
cur = -1
answer += indexes[0] - cur + turn
cur = indexes[0]
else:
answer += next - cur
cur = next
print(answer)
| import sys
from collections import defaultdict
import bisect
sys.setrecursionlimit(10 ** 7)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
S = sr()
T = sr()
len_S = len(S)
indexes_S = defaultdict(list)
for i, s in enumerate(S):
indexes_S[s].append(i)
x = -1 # 今いるところ、次はx+1から探索
for t in T:
if len(indexes_S[t]) == 0:
print((-1)); exit()
arr = indexes_S[t]
y = (x+1) % len_S
next_i = bisect.bisect_left(arr, y) # tの同じ文字がある次のindex
if next_i < len(arr):
x = (x+1) + arr[next_i] - y
else:
x = (x+1) + arr[0] + len_S - y # 1周して次のarr
print((x+1))
| p02937 |
import sys
# 10倍速いらしい
input = sys.stdin.readline
INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)
S = input().rstrip()
T = input().rstrip()
sn = len(S)
M = [dict() for _ in range(sn)]
for i, s in enumerate(S):
for j in range(sn):
M[(i - j + sn) % sn][s] = min(M[(i - j + sn) % sn].get(s, INF), j)
for j in range(sn):
if M[(i - j + sn) % sn][s] == 0:
M[(i - j + sn) % sn][s] = M[(i - j + sn + 1) % sn][s] + 1
ans = 0
idx = sn - 1
for t in T:
if M[idx].get(t, INF) == INF:
print((-1))
sys.exit()
ans += M[idx][t]
idx = (idx + M[idx][t]) % sn
print(ans)
| import sys
import bisect
# 10倍速いらしい
input = sys.stdin.readline
INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)
S = input().rstrip()
T = input().rstrip()
sn = len(S)
d = dict()
for i, s in enumerate(S):
d[s] = d.get(s, [])
d[s].append(i)
nowidx = -1
loop = 0
for t in T:
l = d.get(t, [])
if len(l) == 0:
print((-1))
sys.exit()
j = bisect.bisect_right(l, nowidx)
if len(l) <= j:
nowidx = l[0]
loop += 1
else:
nowidx = l[j]
# print(loop, nowidx)
print((loop * sn + nowidx + 1))
| p02937 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
from bisect import bisect_right
s = ns()
t = ns()
ok = True
sset = set(list(s))
for ti in t:
if ti not in sset:
ok = False
break
if not ok:
print((-1))
else:
n = len(s)
charidx = defaultdict(list)
for i, si in enumerate(s):
charidx[si].append(i)
for i, si in enumerate(s):
charidx[si].append(n+i)
ks = list(charidx.keys())
move = [{ki: -1 for ki in ks} for _ in range(n)]
for i, si in enumerate(s):
for ki in ks:
nexidx = bisect_right(charidx[ki], i)
move[i][ki] = (charidx[ki][nexidx] - i) % (n+1)
cur = s.index(t[:1])
ans = cur
for ti in t[1:]:
nex = move[cur][ti]
ans += nex
cur = (cur + nex) % n
print((ans+1))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
from bisect import bisect_right
s = ns()
t = ns()
ok = True
sset = set(list(s))
for ti in t:
if ti not in sset:
ok = False
break
if not ok:
print((-1))
else:
n = len(s)
charidx = defaultdict(list)
for i, si in enumerate(s):
charidx[si].append(i)
for i, si in enumerate(s):
charidx[si].append(n+i)
ks = list(charidx.keys())
move = [{ki: -1 for ki in ks} for _ in range(n)]
for i, si in enumerate(s):
for ki in ks:
idxlist = charidx[ki]
nexidx = bisect_right(idxlist, i)
move[i][ki] = (idxlist[nexidx] - i) % (n+1)
cur = s.index(t[:1])
ans = cur
for ti in t[1:]:
nex = move[cur][ti]
ans += nex
cur = (cur + nex) % n
print((ans+1))
| p02937 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
from bisect import bisect_right
s = ns()
t = ns()
ok = True
sset = set(list(s))
for ti in t:
if ti not in sset:
ok = False
break
if not ok:
print((-1))
else:
n = len(s)
charidx = defaultdict(list)
for i, si in enumerate(s):
charidx[si].append(i)
for i, si in enumerate(s):
charidx[si].append(n+i)
ks = list(charidx.keys())
move = [{ki: -1 for ki in ks} for _ in range(n)]
for i, si in enumerate(s):
for ki in ks:
idxlist = charidx[ki]
nexidx = bisect_right(idxlist, i)
move[i][ki] = (idxlist[nexidx] - i) % (n+1)
cur = s.index(t[:1])
ans = cur
for ti in t[1:]:
nex = move[cur][ti]
ans += nex
cur = (cur + nex) % n
print((ans+1))
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from bisect import bisect_right
s = ns()
t = ns()
# 判定
ok = True
sset = set(list(s))
tset = set(list(t))
for ti in tset:
if ti not in sset:
ok = False
if not ok:
print((-1))
else:
n = len(s)
nex = [[] for _ in range(26)]
sdouble = s + s
orda = ord("a")
for i, si in enumerate(sdouble):
nex[ord(si) - orda].append(i)
bef = t[:1]
cur = s.index(t[:1])
ans = cur
for ti in t[1:]:
chridx = ord(ti) - orda
dest = bisect_right(nex[chridx], cur)
ans += (nex[chridx][dest] - cur)
cur = ans % n
print((ans+1)) | p02937 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
s = SI()
t = SI()
d = [[] for _ in range(26)]
p = [0] * 26
for i,x in enumerate(s):
d[ord(x)-ord('a')].append(i+1)
rev = 0
a = 0
for x in t:
x = ord(x) - ord('a')
if len(d[x]) == 0:
print((-1))
return
c = p[x]
while d[x][c] <= a:
c += 1
if c >= len(d[x]):
rev += 1
p = [0] * 26
a = 0
c = 0
a = d[x][c]
print((rev*len(s) + a))
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
s = SI()
ds = s + s
t = SI()
z = [0] * 26
nt = [[] for _ in range(len(ds))]
for i in range(len(ds),0,-1):
z[ord(ds[i-1])-ord('a')] = i
nt[i-1] = copy.copy(z)
rev = 0
a = 0
for x in t:
x = ord(x) - ord('a')
a = nt[a][x]
if a == 0:
print((-1))
return
if a >= len(s):
a -= len(s)
rev += 1
print((rev*len(s)+a))
if __name__ == '__main__':
main() | p02937 |
def slove():
import sys
import collections
import bisect
input = sys.stdin.readline
s = str(input().rstrip('\n'))
t = str(input().rstrip('\n'))
d = collections.defaultdict(list)
for i in range(len(s)):
d[s[i]] += [i]
loop = 0
pos = 0
for i in range(len(t)):
if t[i] not in d:
print((-1))
exit()
else:
pos = bisect.bisect_left(d[t[i]], pos)
if len(d[t[i]]) == pos:
loop += 1
pos = 0
pos = d[t[i]][pos] + 1
print((loop * len(s) + pos))
if __name__ == '__main__':
slove()
| import sys
import bisect
import collections
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
d = collections.defaultdict(list)
for i in range(len(s)):
d[s[i]] += [i]
loop = 0
pos = 0
t = str(readline().rstrip().decode('utf-8'))
for i in range(len(t)):
if t[i] in d:
pos = bisect.bisect_left(d[t[i]], pos)
if pos == len(d[t[i]]):
loop += 1
pos = 0
pos = bisect.bisect_left(d[t[i]], pos)
pos = d[t[i]][pos] + 1
else:
print((-1))
exit()
print((loop * len(s) + pos))
if __name__ == '__main__':
solve()
| p02937 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.