input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
cs = list(map(int, input().split()))
ps = [p-1 for p in ps]
visited = [False] * n
from collections import deque
ds = []
sums = []
for i in range(n):
if visited[i]: continue
q = deque([])
q.append(i)
s = cs[i]
d = [i]
while len(q) > 0:
u = q.popleft()
visited[u] = True
nx = ps[u]
if visited[nx]: continue
d.append(nx)
q.append(nx)
s += cs[nx]
sums.append(s)
ds.append(d)
# print(ds,sums)
from itertools import accumulate
def calcmax(d,s,k,cs):
cnt = 0
l = len(d)
div, rest_ = divmod(k-1, l)
rest_ += 1
if s > 0:
cnt += div*s
d2 = d*2
c_ = [cs[j] for j in d2]
acc = list(accumulate(c_))
mx = - 1<<50
if s < 0:
for rest in range(1,l+1):
for i in range(rest,l*2):
c = acc[i] - acc[i-rest]
mx = max(mx,c)
return mx
for rest in range(1,rest_+1):
for i in range(rest,l*2):
c = acc[i] - acc[i-rest]
# print(i,rest,c,"debug")
mx = max(mx, c)
# print(d,cnt,mx)
return cnt + mx
ans = -1 << 50
for d,s in zip(ds,sums):
# print("aaa",d,s)
c = calcmax(d,s,k,cs)
ans = max(ans,c)
print(ans) | n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
cs = list(map(int, input().split()))
ps = [p-1 for p in ps]
# doubling使う
vers = [] # vers[b][i] 頂点iから2^b回移動した時にどの頂点にいるか
score = [] # score[b][i]頂点iから2^b回移動した時に何点もらえるか
vers.append(ps)
score.append(cs)
m = 31
# ダブリング
for b in range(1, m+1):
p_bth = [0] * n
c_bth = [0] * n
for i in range(n):
p_bth[i] = vers[b-1][vers[b-1][i]]
c_bth[i] = score[b-1][i] + score[b-1][vers[b-1][i]]
vers.append(p_bth)
score.append(c_bth)
# 桁DP
MIN = -(1 << 63)
prv = [[MIN, 0] for _ in range(n)]
nxt = [[MIN, MIN] for _ in range(n)]
for b in range(m, -1, -1):
for i in range(n):
if (k >> b) & 1:
nxt[vers[b][i]][0] = max(nxt[vers[b][i]][0], prv[i][0] + score[b][i])
nxt[vers[b][i]][1] = max(nxt[vers[b][i]][1], prv[i][1] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0], prv[i][1])
else:
nxt[vers[b][i]][0] = max(nxt[vers[b][i]][0], prv[i][0] + score[b][i])
nxt[i][0] = max(nxt[i][0], prv[i][0])
nxt[i][1] = max(nxt[i][1], prv[i][1])
prv, nxt = nxt, prv
ans = max(max(x) for x in prv)
if ans == 0:
ans = max(cs)
print(ans) | p02585 |
int1 = lambda x: int(x) - 1
N, K = list(map(int, input().split()))
P = tuple(map(int1, input().split()))
C = tuple(map(int, input().split()))
visited = set()
cycles = []
for i in range(N):
if i not in visited:
cur = P[i]
cycle = [i]
while cur != i:
visited.add(cur)
cycle.append(cur)
cur = P[cur]
cycles.append(cycle)
ans = -float('inf')
for cycle in cycles:
score = [0]
for x in cycle * 2:
score.append(score[-1] + C[x])
# i回進めるときのスコア最大値
lst = [0] * (min(K, len(cycle)) + 1)
lst[0] = -float('inf')
for i in range(1, min(K, len(cycle)) + 1):
tmp = -float('inf')
for j in range(len(cycle)):
tmp = max(tmp, score[j + i] - score[j])
lst[i] = tmp
lap = K // len(cycle)
if lap == 0:
ans = max(ans,
max(lst))
else:
around_score = lst[len(cycle)]
ans = max(ans,
max(lst),
around_score * (lap - 1) + max(lst),
around_score * lap + max(lst[:K % len(cycle) + 1]))
print(ans)
| int1 = lambda x: int(x) - 1
N, K = list(map(int, input().split()))
P = tuple(map(int1, input().split()))
C = tuple(map(int, input().split()))
visited = set()
cycles = []
for i in range(N):
if i not in visited:
cur = P[i]
cycle = [i]
while cur != i:
visited.add(cur)
cycle.append(cur)
cur = P[cur]
cycles.append(cycle)
ans = -float('inf')
for cycle in cycles:
l = len(cycle)
score = [0]
for x in cycle * 2:
score.append(score[-1] + C[x])
# i回進めるときのスコア最大値
lst = [0] * (min(K, l) + 1)
lst[0] = -float('inf')
for i in range(1, min(K, l) + 1):
tmp = -float('inf')
for j in range(l):
tmp = max(tmp, score[j + i] - score[j])
lst[i] = tmp
lap = K // l
if lap == 0:
ans = max(ans,
max(lst))
else:
around_score = lst[l]
ans = max(ans,
max(lst),
around_score * (lap - 1) + max(lst),
around_score * lap + max(lst[:K % l + 1]))
print(ans)
| p02585 |
n, k =list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
roop = []
seen = [0 for _ in range(n)]
count = 0
for i in range(n):
if seen[i]>0:
continue
else:
count+=1
seen[i] = count
roop.append([c[i]])
t = i
while i!=p[t]-1:
seen[p[t]-1]=count
roop[-1].append(c[p[t]-1])
t = p[t]-1
#print(seen)
#print(roop)
ans = max(c)
for i in roop:
ii = i+i
if len(i)>=k:
for j in range(1, k+1):
for l in range(len(i)):
temp = sum(ii[l:l+j])
#print(i, j, l, temp)
ans = max(ans, temp)
else:
for j in range(1, len(i)+1):
for l in range(len(i)):
if sum(i)>0:
temp = sum(ii[l:l+j])+(sum(i)*((k-j)//len(i)))
else:
temp = sum(ii[l:l+j])
#print(i, j, l, temp)
ans = max(ans, temp)
print(ans)
| n, k =list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
roop = []
seen = [0 for _ in range(n)]
count = 0
for i in range(n):
if seen[i]>0:
continue
else:
count+=1
seen[i] = count
roop.append([c[i]])
t = i
while i!=p[t]-1:
seen[p[t]-1]=count
roop[-1].append(c[p[t]-1])
t = p[t]-1
#print(seen)
#print(roop)
ans = max(c)
for i in roop:
#print(ans)
s = sum(i)
ii = i+i
#print(ii)
if len(i)>=k:
for j in range(1, k+1):
temp = sum(ii[:j])
for l in range(len(i)):
if l!=0:
temp+=ii[l+j-1]
temp-=ii[l-1]
#temp = sum(ii[l:l+j])
#print(i, j, l, temp)
ans = max(ans, temp)
else:
for j in range(1, len(i)+1):
temp= sum(ii[:j])
for l in range(len(i)):
if l != 0:
temp+=ii[l+j-1]
temp-=ii[l-1]
#print(temp)
if s>0:
temp1 = temp+s*((k-j)//len(i))
else:
temp1 = temp
#print(i, j, l, temp)
ans = max(ans, temp)
ans = max(ans, temp1)
print(ans)
| p02585 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
s = [[0] for _ in range(n)]
ans = -10**18
for i in range(n):
flag = 0
a = p[i]
s[i].append(c[a-1])
while flag == 0:
a = p[a-1]
if a == i + 1:
flag = 1
s[i].append(c[a-1]+ s[i][-1])
for i in range(n):
a = 0
mul = k//(len(s[i])-1)
m = mul*(s[i][-1] > 0)
re = k - m*(len(s[i])-1)
a += m*s[i][-1]
if len(s[i][1:min(re+1, len(s[i])-1)]):
a += max(s[i][1:min(re+1, len(s[i])-1)])
f = s[i].index(max(s[i][1:-1]))
al = mul*min(0, m-1) + s[i][f]
if al > a and m>0:
a = al
if a > ans:
ans = a
print(ans) | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
for i in range(N):
P[i] -= 1
C = list(map(int, input().split()))
ans = -(10 ** 18)
for si in range(N):
x = si
loop = []
total = 0
while 1:
x = P[x]
loop.append(C[x])
total += C[x]
if x == si:
break
T = len(loop) # 周期の大きさ
tmp = 0
for i in range(T):
tmp += loop[i]
if K < i + 1:
break
now = tmp
if total > 0: # loopの和が正ならloopを回した方がお得
loop_times = (K - (i + 1)) // T # 何周できるか
now += total * loop_times
ans = max(ans, now)
print(ans) | p02585 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
c=list(map(int,input().split()))
check=[0]*n
group=[]
for i in range(n):
tmp=i
if check[tmp]==0:
tmp_group=[]
while check[tmp]==0:
tmp_group.append(tmp)
check[tmp]=1
tmp=p[tmp]-1
group.append(tmp_group)
ans="start"
#startの最低とgoalの最高の和
for item in group:
#一周すると何になるか。これはどこスタートでも同じ
circle=0
cnt=k
if len(item)<k:
for v in item:
circle+=c[v]
cnt=k-len(item)
#一周した後のあまりで最強を探す
goal=(-1)*(10**18)
#startは各groupのindexが入ってる
for start in range(len(item)):
tmp=0
#print("start",item,start,cnt)
for i in range(start,start+cnt):
#print(">>",i)
tmp+=c[item[i%len(item)]]
#print(item[i%len(item)],c[item[i%len(item)]])
goal=max(goal,tmp)
#print(item,circle,goal)
if ans=="start":
ans=goal+max(0,circle)
else:
ans=max(ans,goal+max(0,circle))
print(ans)
| n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
score=list(map(int,input().split()))
group_score=[]
checked=[0]*n
for i in range(n):
if checked[i]==0:
tmp_group=[]
tmp=i
while checked[tmp]==0:
checked[tmp]=1
tmp_group.append(score[tmp])
tmp=p[tmp]-1
group_score.append(tmp_group)
#aryの中から連続するk個選択するときの最大
def calc(k):
if k==0:
return 0
global group
ans="INF"
for i in range(len(group)):
tmp=0
for j in range(k):
tmp+=group[(i+j)%len(group)]
if ans=="INF":
ans=tmp
else:
if ans<tmp:
ans=tmp
return ans
ans=score[0]
for group in group_score:
#一周以上する場合
if len(group)<k:
cycle=sum(group)
if cycle>0:
cycle_sum=cycle*(k//len(group))
tmp=calc(k%len(group))
ans=max(ans,cycle_sum+tmp)
if k//len(group)>=2:
cycle_sum=cycle*(k//len(group)-1)
tmp=calc(len(group))
ans=max(ans,cycle_sum+tmp)
tmp=calc(len(group))
ans=max(ans,tmp)
#一周しない場合k)
else:
tmp=calc(k)
ans=max(ans,tmp)
print(ans) | p02585 |
from copy import copy
n, k = list(map(int, input().split()))
p = list(map(int,input().split()))
c = list(map(int, input().split()))
di = {}
for i in range(n):
di[i+1] = False
l = 1
cc = 0
per = [] # ループの順番
while cc < n:
tmp = []
while True:
if di[l]:
break
else:
tmp.append(l)
di[l] = True
cc += 1
l = p[l-1]
per.append(tmp)
for i in range(n):
if not di[i+1]:
l = p[i]
#print(per)
dd = {} # 何個目のループに属するか
for i in range(n):
dd[i+1] = 0
for i in range(len(per)):
for j in per[i]:
dd[j] = i
#print(dd)
su = [] # ループ１週の和
for i in range(len(per)):
tmp = 0
for j in per[i]:
tmp += c[j-1]
su.append(tmp)
#print(su)
s2 = [] # ループ１週何個か
for i in range(len(per)):
s2.append(len(per[i]))
#print(s2)
ans = -1*(10**10)
#d2 = {} # per[dd]の中でなんばんめにあるか(0インデックス)
#for i in range(len(per)):
# for j in range(len(per[i])):
# d2[per[i][j]] = j
#print(d2)
aa = []
for i in range(n):
loop = dd[i+1]
w = i+1
kk = copy(k)
if k < s2[loop]:
tmp = 0
m = -10**9
for j in range(k):
w = p[w-1]
tmp += c[w-1]
aa.append(tmp)
else:
if su[loop] <= 0:
tmp = 0
m = -10**9
for j in range(k):
w = p[w-1]
tmp += c[w-1]
aa.append(tmp)
else:
m_loop = kk // (s2[loop])
m_loop -= 1
kk -= m_loop * s2[loop]
tmp = su[loop]*m_loop
m = -10**9
for j in range(kk):
w = p[w-1]
tmp += c[w-1]
if c[w-1] <= 0:
continue
aa.append(tmp)
print((max(aa)))
| from copy import copy
n, k = list(map(int, input().split()))
p = list(map(int,input().split()))
c = list(map(int, input().split()))
di = {}
for i in range(n):
di[i+1] = False
l = 1
cc = 0
per = [] # ループの順番
while cc < n:
tmp = []
while True:
if di[l]:
break
else:
tmp.append(l)
di[l] = True
cc += 1
l = p[l-1]
per.append(tmp)
for i in range(n):
if not di[i+1]:
l = p[i]
#print(per)
dd = {} # 何個目のループに属するか
for i in range(n):
dd[i+1] = 0
for i in range(len(per)):
for j in per[i]:
dd[j] = i
#print(dd)
su = [] # ループ１週の和
for i in range(len(per)):
tmp = 0
for j in per[i]:
tmp += c[j-1]
su.append(tmp)
#print(su)
s2 = [] # ループ１週何個か
for i in range(len(per)):
s2.append(len(per[i]))
#print(s2)
ans = -1*(10**10)
#d2 = {} # per[dd]の中でなんばんめにあるか(0インデックス)
#for i in range(len(per)):
# for j in range(len(per[i])):
# d2[per[i][j]] = j
#print(d2)
aa = []
for i in range(n):
loop = dd[i+1]
w = i+1
kk = copy(k)
if k < s2[loop]:
tmp = 0
m = -10**9
for j in range(k):
w = p[w-1]
tmp += c[w-1]
aa.append(tmp)
else:
if su[loop] <= 0:
tmp = 0
m = -10**9
for j in range(n):
w = p[w-1]
tmp += c[w-1]
aa.append(tmp)
else:
m_loop = kk // (s2[loop])
m_loop -= 1
kk -= m_loop * s2[loop]
tmp = su[loop]*m_loop
m = -10**9
for j in range(kk):
w = p[w-1]
tmp += c[w-1]
if c[w-1] <= 0:
continue
aa.append(tmp)
print((max(aa)))
| p02585 |
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
n, k = list(map(int, input().split()))
p = [int(x) - 1 for x in input().split()]
c = [int(x) for x in input().split()]
from collections import defaultdict
ans = -float('inf')
for i in range(n):
now = i
cnt = 0
score = []
c_sum = [0]
while cnt < k:
score.append(c[now])
c_sum.append(c_sum[-1] + c[now])
now = p[now]
cnt += 1
if k == cnt:
ans = max(ans, sum(score), max(c_sum[1:]))
else:
temp = sum(score)
q = k // cnt
temp *= q
q = k - q*cnt
temp += sum(score[:q])
ans = max(ans, temp, max(c_sum[1:]))
print(ans)
| import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
n, k = list(map(int, input().split()))
p = [int(x) - 1 for x in input().split()]
c = [int(x) for x in input().split()]
ans = -float('inf')
for i in range(n):
now = i
c_sum = [0]
s = set()
cnt = 0
while True:
s.add(now)
c_sum.append(c_sum[-1] + c[now])
cnt += 1
now = p[now]
if now in s:
break
c_sum = c_sum[1:]
if k < cnt:
ans = max(ans, max(c_sum[: k]))
else:
score = c_sum[-1]
count = k // cnt
k_ = k - count*cnt
score *= count
score_2 = score - c_sum[-1]
score_2 += max(c_sum)
if k_ > 0:
score += max(0, max(c_sum[:k_]))
ans = max(ans, score, max(c_sum), score_2)
print(ans)
| p02585 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
for k in range(N):
P[k] -= 1
scorelist = []
roop = []
now = 0
visited = [-1 for _ in range(N)]
for k in range(N):
now = k
if visited[now] == -1:
roop.append([])
scorelist.append([])
start = 0 + now
while visited[start] == -1:
roop[-1].append(start)
visited[start] = 1
start = P[start]
scorelist[-1].append(C[start])
scorelist[-1] = scorelist[-1] + scorelist[-1]
#print(roop)
#print(scorelist)
ans = - float('inf')
for l in range(len(roop)):
#print(scorelist[l][:len(roop[l])])
Q = K // len(roop[l])
R = K % len(roop[l])
if Q > 0 and R == 0:
Q -= 1
R = len(roop[l])
#print(Q, R)
if sum(scorelist[l][:len(roop[l])]) > 0:
basis = sum(scorelist[l][:len(roop[l])])*Q
else:
basis = 0
#print(basis)
adv = - float('inf')
for k in range(len(roop[l])):
for j in range(k, k + R):
adv = max(adv, sum(scorelist[l][k:j+1]))
ans = max(ans, basis + adv)
print(ans) | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
for k in range(N):
P[k] -= 1
scorelist = []
roop = []
now = 0
visited = [-1 for _ in range(N)]
for k in range(N):
now = k
if visited[now] == -1:
roop.append([])
scorelist.append([])
start = 0 + now
while visited[start] == -1:
roop[-1].append(start)
visited[start] = 1
start = P[start]
scorelist[-1].append(C[start])
scorelist[-1] = scorelist[-1] + scorelist[-1] + scorelist[-1]
#print(roop)
#print(scorelist)
ans = - float('inf')
for l in range(len(roop)):
#print(scorelist[l][:len(roop[l])])
Q = K // len(roop[l])
R = K % len(roop[l])
if Q > 0:
Q -= 1
R += len(roop[l])
#print(Q, R)
if sum(scorelist[l][:len(roop[l])]) > 0:
basis = sum(scorelist[l][:len(roop[l])])*Q
else:
basis = 0
#print(basis)
advlist = -float('inf')
for k in range(len(roop[l])):
adv = 0
for j in range(k, k + R):
adv += scorelist[l][j]
advlist = max(advlist, adv)
ans = max(ans, basis + advlist)
print(ans) | p02585 |
N, K = list(map(int, input().split()))
P = list([int(x) - 1 for x in input().split()])
C = list(map(int, input().split()))
ans = -10**9-1
for i in range(N):
seen = [-1]*N
cumsum = [0]*(N+1)
now = i
j = 0
while seen[now] == -1:
seen[now] = 1
now = P[now]
cumsum[j+1] = cumsum[j] + C[now]
j += 1
loop_size = j
if K <= loop_size:
ans = max([ans] + cumsum[1:K+1])
else:
if cumsum[loop_size] > 0:
loop_n = K//loop_size - 1
cumsum2 = cumsum[0:loop_size+1] + [x + cumsum[loop_size] for x in cumsum[1:loop_size+1]]
score = cumsum[loop_size]*loop_n + max(cumsum2[0:loop_size+K%loop_size+1])
ans = max(ans, score)
else:
ans = max([ans] + cumsum[1:loop_size+1])
print(ans) | from itertools import accumulate
N, K = list(map(int, input().split()))
P = list([int(x) - 1 for x in input().split()])
C = list(map(int, input().split()))
ans = -10**18-1
seen = [False]*N
for i in range(N):
if seen[i]:
continue
loop = []
now = i
while seen[now] == False:
seen[now] = True
loop.append(C[now])
now = P[now]
loop_size = len(loop)
loop_score = sum(loop)
cumsum = [0]+list(accumulate(loop+loop))
for j in range(1, min(K, loop_size)+1):
for l in range(loop_size+1):
r = l+j
subseq = cumsum[r] - cumsum[l]
ans = max(ans, subseq, subseq+loop_score*((K-j)//loop_size))
print(ans) | p02585 |
from itertools import accumulate
N, K = list(map(int, input().split()))
P = list([int(x) - 1 for x in input().split()])
C = list(map(int, input().split()))
ans = -10**18-1
seen = [False]*N
for i in range(N):
if seen[i]:
continue
loop = []
now = i
while seen[now] == False:
seen[now] = True
loop.append(C[now])
now = P[now]
loop_size = len(loop)
loop_score = sum(loop)
cumsum = [0]+list(accumulate(loop+loop))
for j in range(1, min(K, loop_size)+1):
for l in range(loop_size+1):
r = l+j
subseq = cumsum[r] - cumsum[l]
ans = max(ans, subseq, subseq+loop_score*((K-j)//loop_size))
print(ans) | from itertools import accumulate
N, K = list(map(int, input().split()))
P = list([int(x) - 1 for x in input().split()])
C = list(map(int, input().split()))
ans = -10**18-1
seen = [False]*N
for i in range(N):
if seen[i]:
continue
loop = []
now = i
while seen[now] == False:
seen[now] = True
loop.append(C[now])
now = P[now]
loop_size = len(loop)
loop_score = sum(loop)
cumsum = list(accumulate(loop+loop))
for j in range(1, min(K, loop_size)+1):
for l in range(loop_size):
r = l+j
subseq = cumsum[r] - cumsum[l]
ans = max(ans, subseq, subseq+loop_score*((K-j)//loop_size))
print(ans) | p02585 |
N, K = list(map(int, input().split()))
P = [int(p) - 1 for p in input().split()]
C = list(map(int, input().split()))
max_score = -10**9
for i in range(N):
memo = [P[i]]
score = C[P[i]]
move = 1
max_score = max(score, max_score)
while move < K and P[memo[-1]] not in memo:
memo.append(P[memo[-1]])
score += C[memo[-1]]
move += 1
max_score = max(score, max_score)
if move < K and score > 0:
score = (K // move) * score
move *= (K // move)
max_score = max(score, max_score)
cur = i
while move < K:
cur = P[cur]
score += C[cur]
move += 1
max_score = max(score, max_score)
print(max_score) | N, K = list(map(int, input().split()))
P = [int(p) - 1 for p in input().split()]
C = list(map(int, input().split()))
max_score = -10 ** 9
for i in range(N):
memo = set()
score = 0
cur = i
move = 0
while move < K and P[cur] not in memo:
cur = P[cur]
memo.add(cur)
score += C[cur]
move += 1
max_score = max(score, max_score)
if move < K and score > 0:
score = max(K // move - 1, 1) * score
move *= max(K // move - 1, 1)
max_score = max(score, max_score)
cur = i
while move < K:
cur = P[cur]
score += C[cur]
move += 1
max_score = max(score, max_score)
print(max_score) | p02585 |
n,k = list(map(int,input().split()))
p = [int(i)-1 for i in input().split()]
c = [int(i) for i in input().split()]
INF = float("INF")
ans = -INF
for i in range(n):
flag = [False]*n
now = i
cnt = 0
j = 0
mlst = [-INF]*n
m = -INF
while not flag[now]:
flag[now] = True
now = p[now]
cnt += c[now]
m = max(cnt,m)
mlst[j] = m
j += 1
# print(mlst)
q,r = divmod(k,j)
if q == 0: res = mlst[r-1]
elif cnt >= 0 and r == 0: res = cnt*(q-1)+mlst[j-1]
elif cnt >= 0: res = max(cnt*q+mlst[r-1],cnt*(q-1)+mlst[j-1])
else: res = mlst[j-1]
# print("res",res)
ans = max(ans,res)
print(ans) | n,k = list(map(int,input().split()))
p = [int(i)-1 for i in input().split()]
c = [int(i) for i in input().split()]
INF = float("INF")
ans = -INF
for si in range(n):
x = si
S = []
tot = 0
while True:
x = p[x]
S.append(c[x])
tot += c[x]
if x == si: break
l = len(S)
t = 0
for i in range(l):
if i+1 > k: break
t += S[i]
now = t
if tot > 0:
e = (k-(i+1))//l
now += tot*e
ans = max(ans, now)
print(ans) | p02585 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
point_start_with = [0 for i in range(n)]
roop_count = [1 for i in range(n)]
for i in range(n):
now = (i + 1)
now_score = 0
while p[now - 1] != (i + 1):
now = p[now - 1]
now_score += c[now - 1]
roop_count[i] += 1
point_start_with[i] = now_score
# 多分0でいい
ans = -(10**9 * 5000)
for i in range(n):
# iからスタートする場合
score = 0
remain_move = 0
cand_score = 0
if point_start_with[i] + c[i] > 0 and k > roop_count[i]:
# 一周以上する可能性がある場合
# n週して、残りの動ける回数
# print("Yes")
round_count = (k // roop_count[i]) - 1
remain_move = k - round_count * roop_count[i]
cand_score = round_count * ( point_start_with[i] + c[i] )
else:
remain_move = k
score = -(10**9 * 5000)
cand_score = 0
now = i
for j in range(remain_move):
now = p[now] - 1
cand_score += c[now]
score = max(score, cand_score)
# print("start : {} score : {}".format(i,score))
ans = max(score, ans)
print(ans)
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
point_start_with = [0 for i in range(n)]
roop_count = [1 for i in range(n)]
for i in range(n):
now = (i + 1)
now_score = 0
while p[now - 1] != (i + 1):
now = p[now - 1]
now_score += c[now - 1]
roop_count[i] += 1
point_start_with[i] = now_score
# 多分0でいい
ans = -(10**9 * 5000)
for i in range(n):
# iからスタートする場合
score = 0
remain_move = 0
cand_score = 0
if point_start_with[i] + c[i] > 0 and k > roop_count[i]:
# 一周以上する可能性がある場合
# n週して、残りの動ける回数
# print("Yes")
round_count = (k // roop_count[i]) - 1
remain_move = k - round_count * roop_count[i]
cand_score = round_count * ( point_start_with[i] + c[i] )
else:
remain_move = min(k,roop_count[i])
score = -(10**9 * 5000)
cand_score = 0
now = i
for j in range(remain_move):
now = p[now] - 1
cand_score += c[now]
score = max(score, cand_score)
# print("start : {} score : {}".format(i,score))
ans = max(score, ans)
print(ans)
| p02585 |
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
P = list([int(x)-1 for x in input().split()])
C = list(map(int, input().split()))
ans = -float("inf")
for st in range(N):
S = []
temp = P[st]
S.append(C[temp])
while temp != st:
temp = P[temp]
S.append(S[-1] + C[temp])
cnt = len(S)
loop, k = divmod(K, cnt)
point = 0
if S[-1] >= 0:
if k == 0:
loop -= 1
k += cnt
point += S[-1] * loop
else:
if loop >= 1:
k = cnt
ans = max(ans, point + max(S[:k]))
print(ans) | N, K = list(map(int, input().split()))
P = list([int(x)-1 for x in input().split()])
C = list(map(int, input().split()))
ans = -float("inf")
for st in range(N):
S = []
temp = P[st]
S.append(C[temp])
while temp != st:
temp = P[temp]
S.append(S[-1] + C[temp])
cnt = len(S)
loop, k = divmod(K, cnt)
point = 0
if S[-1] >= 0:
if k == 0:
loop -= 1
k += cnt
point += S[-1] * loop
else:
if loop >= 1:
k = cnt
ans = max(ans, point + max(S[:k]))
print(ans) | p02585 |
import sys
sys.setrecursionlimit(10**9)
N,K = list(map(int,input().split()))
P = [ i-1 for i in list(map(int,input().split())) ]
C = list(map(int,input().split()))
g = [ [] for _ in range(N) ]
for i in range(N):
g[i].append(P[i])
def dfs(i):
global cycle
nei = g[i][0]
if nei in cycle: return
cycle.append(nei)
dfs(nei)
cycles = []
for i in range(N):
cycle = []
dfs(i)
c = [ C[j] for j in cycle ]
cycles.append(c)
ans = -float('inf')
for i in range(N):
c = cycles[i]
cum = c[::]
for j in range(1,len(c)):
cum[j] = cum[j-1] + cum[j]
if cum[-1] < 0:
ans = max(ans, max(cum[0:K]))
else:
t = K//len(c)
r = K - t*len(c)
cum = [0]+cum[::]
ans = max(ans, cum[-1]*t+max(cum[:r+1]))
print(ans)
| import sys
sys.setrecursionlimit(10**9)
N,K = list(map(int,input().split()))
P = [ i-1 for i in list(map(int,input().split())) ]
C = list(map(int,input().split()))
ans = -float('inf')
for i in range(N):
cycle = []
tot = 0
nex = i
while True:
nex = P[nex]
cycle.append(C[nex])
tot += C[nex]
if nex == i: break
l = len(cycle)
t = 0
for j in range(l):
t += cycle[j]
if j+1 > K: break
now = t
if tot > 0:
now += tot*((K-(j+1))//l)
ans = max(ans, now)
print(ans)
| p02585 |
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
ans = -float('inf')
for i in range(N):
score = -float('inf')
cnt = 0
k = 0
while k < K:
ni = P[i] - 1
cnt += C[ni]
score = max(cnt, score)
i = ni
k += 1
ans = max(ans, score)
print(ans)
| N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
ans = -float('inf')
for i in range(N):
cnt = 0
k = 0
done = set()
S = []
while i not in done:
done.add(i)
ni = P[i] - 1
if len(S):
S.append(S[-1] + C[ni])
else:
S.append(C[ni])
i = ni
if K <= len(S):
score = max(S[:K])
elif S[-1] <= 0:
score = max(S)
else:
score1 = S[-1] * ((K // len(S)) - 1)
score1 += max(S)
score2 = S[-1] * (K // len(S))
r = K % len(S)
if r != 0:
score2 += max(0, max(S[:r]))
score = max(score1, score2)
ans = max(ans, score)
print(ans)
| p02585 |
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy
from typing import List
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
def solve(N: int, K: int, P: List[int], C: List[int]):
ans = max(C)
visited = [False] * N
for i in range(N):
if visited[i]:
continue
cycle = []
to = i
while not visited[to]:
visited[to] = True
cycle.append(C[to])
to = P[to] - 1
ans = max(ans, partial_solve(len(cycle), K, cycle))
return ans
def partial_solve(N: int, K: int, A: List[int]):
ret = max(A)
B = [0] * (3 * N + 1)
for i in range(1, 3 * N + 1):
B[i] = B[i - 1] + A[(i - 1) % N]
if N > K:
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
else:
if B[N] < 0:
K = N
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
else:
cnt = K // N - 1
K = K % N + N
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
ret += cnt * B[N]
return ret
print((solve(N, K, P, C)))
| from typing import List
N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
def solve(N: int, K: int, P: List[int], C: List[int]):
ans = max(C)
visited = [False] * N
for i in range(N):
if visited[i]:
continue
cycle = []
to = i
while not visited[to]:
visited[to] = True
cycle.append(C[to])
to = P[to] - 1
ans = max(ans, partial_solve(len(cycle), K, cycle))
return ans
def partial_solve(N: int, K: int, A: List[int]):
ret = max(A)
B = [0] * (3 * N + 1)
for i in range(1, 3 * N + 1):
B[i] = B[i - 1] + A[(i - 1) % N]
if N > K:
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
else:
if B[N] < 0:
K = N
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
else:
cnt = K // N - 1
K = K % N + N
for l in range(1, N + 1):
for r in range(l, l + K):
ret = max(ret, B[r] - B[l - 1])
ret += cnt * B[N]
return ret
print((solve(N, K, P, C)))
| p02585 |
(n,k),p,c=[[*list(map(int,t.split()))]for t in open(0)]
a=-9e9
for i in range(n):
s=f=0;x,j,*l=i,k
while~f:x=p[x]-1;s+=c[x];l+=s,;f-=x==i
for t in l[:k]:j-=1;a=max(a,t+j//len(l)*s*(s>0))
print(a) | (n,k),p,c=[[*list(map(int,t.split()))]for t in open(0)]
a=-9e9
while n:
n-=1;s,x,*l=0,n;f=j=k
while f:x=p[x]-1;s+=c[x];l+=s,;f=x!=n
for t in l[:k]:j-=1;a=max(a,t+j//len(l)*s*(s>0))
print(a) | p02585 |
(n,k),p,c,*a=[[*list(map(int,t.split()))]for t in open(0)]
while n:
n-=1;s,x,*l=0,n;f=j=k
while f:x=p[x]-1;s+=c[x];l+=s,;f=x!=n
for t in l[:k]:j-=1;a+=t+j//len(l)*s*(s>0),
print((max(a))) | (n,k),p,c,*a=[[*list(map(int,t.split()))]for t in open(0)]
while n:
n-=1;s,x,*l=0,n;f=j=k
while f:x=p[x]-1;s+=c[x];l+=s,;f=x!=n
for t in l[:k]:j-=1;a+=[t+j//len(l)*s*(s>0)]
print((max(a))) | p02585 |
n,k = list(map(int,input().split()))
p = [0] + list(map(int,input().split()))
c = [0] + list(map(int,input().split()))
ans = max(c[1:])
t = 0
for i in range(1,n+1):
# print(ans)
j = p[i]
temp = c[i]
cnt = 1
ans = max(ans,temp)
tempans = 0
while i!=j:
temp += c[j]
j = p[j]
cnt += 1
# if i==5:
# print(j,c[j],temp)
t = cnt
tt = ans
# if i==8:
# print(temp,t)
if t < k:
if temp > 0:
# print(k,t,i)
tempans += temp*(k//t - 1)
tt = tempans
j = p[i]
for l in range(k-(k//t - 1)*t):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
else:
j = p[i]
for l in range(k):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
else:
j = p[i]
for l in range(k):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
# if ans == 29779631210:
# print(i,ans,t,temp)
# exit()
print(ans)
| n,k = list(map(int,input().split()))
p = [0] + list(map(int,input().split()))
c = [0] + list(map(int,input().split()))
ans = max(c[1:])
t = 0
for i in range(1,n+1):
# print(ans)
j = p[i]
temp = c[i]
cnt = 1
ans = max(ans,temp)
tempans = 0
while i!=j:
temp += c[j]
j = p[j]
cnt += 1
# if i==5:
# print(j,c[j],temp)
t = cnt
tt = ans
# if i==8:
# print(temp,t)
if t < k:
if temp > 0:
# print(k,t,i)
tempans += temp*(k//t - 1)
tt = tempans
j = p[i]
for l in range(k-(k//t - 1)*t):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
else:
j = p[i]
for l in range(t):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
else:
j = p[i]
for l in range(k):
tempans += c[j]
j = p[j]
tt = max(tt,tempans)
ans = max(ans,tt)
# print(ans)
# if ans == 29779631210:
# print(i,ans,t,temp)
# exit()
print(ans)
| p02585 |
n, k = list(map(int, input().split()))
p = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
p_flag = [0 for _ in range(len(p))]
loop_max = []
loop_len = []
S = []
S_max = []
ans = []
for i in range(len(p)):
# if p_flag[i] == 1:
# continue
now = i
temp_len = 0
temp_s = 0
S_max = - (10**9 + 1)
temp_l = []
while True:
now = p[now] - 1
temp_len += 1
temp_s += c[now]
temp_l.append(temp_s)
p_flag[now] = 1
# 最初に戻ってきたら
if now == i:
break
loop_len.append(temp_len)
loop_max.append(temp_l)
S.append(temp_s)
for i in range(len(S)):
mod = k % loop_len[i] if k % loop_len[i] != 0 else loop_len[i]
if S[i] > 0:
if max(loop_max[i][:mod]) > 0:
ans.append(((k-1)//loop_len[i])*S[i] + max(loop_max[i][:mod]))
else:
ans.append(((k - 1) // loop_len[i]) * S[i])
else:
ans.append(max(loop_max[i]))
# print(loop_max)
# print(ans)
print((max(ans)))
| n, k = list(map(int, input().split()))
p = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
loop_max = []
loop_len = []
S = []
ans = []
for i in range(len(p)):
now = i
temp_len = 0
temp_s = 0
temp_l = []
while True:
now = p[now] - 1
temp_len += 1
temp_s += c[now]
temp_l.append(temp_s)
# 最初に戻ってきたら
if now == i:
break
loop_len.append(temp_len)
loop_max.append(temp_l)
S.append(temp_s)
for i in range(len(S)):
mod = k % loop_len[i] if k % loop_len[i] != 0 else loop_len[i]
if S[i] > 0:
if max(loop_max[i][:mod]) > 0:
ans.append(((k-1)//loop_len[i])*S[i] + max(loop_max[i][:mod]))
else:
ans.append(((k - 1) // loop_len[i]) * S[i])
else:
ans.append(max(loop_max[i]))
print((max(ans)))
| p02585 |
n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
r = -10**9
for i in range(n):
ans=c[i]
e =[ans]
f = i
a = 1
while a<k:
i = p[i]-1
if i == f:
break
a+=1
ans+=c[i]
e.append(ans)
if e[-1]>0 and a<k:
w = k%len(e)
if w!=0:
y = k//len(e)*e[-1]+max(e[:w])
else:
y =( k//len(e)-1)*e[-1]+max(e)
g=y
else:
g=max(e)
r = max(r,g)
print(r) | n,k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
g = []
for i in range(n):
ans=c[i]
e =[ans]
f = i
a = 1
while a<k:
i = p[i]-1
if i == f:
break
a+=1
ans+=c[i]
e.append(ans)
if e[-1]>0 and a<k:
w = k%len(e)
if w!=0:
y = k//len(e)*e[-1]+max(e[:w])
else:
y =( k//len(e)-1)*e[-1]+max(e)
g.append(y)
else:
g.append(max(e))
print((max(g)))
| p02585 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
ans = -float('inf')
for i in range(N):
s = 0
for k in range(K):
i = P[i]-1
s += C[i]
ans = max(ans, s)
print(ans) | N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
ans = -float('inf')
for i in range(N):
s = 0
j = i
for k in range(K):
j = P[j]-1
s += C[j]
ans = max(ans, s)
if j==i: break
d,m = divmod(K, k+1)
if m==0 and d>1:
m = k+1
d -= 1
s *= d
ans = max(ans, s)
for k in range(m):
j = P[j]-1
s += C[j]
ans = max(ans, s)
print(ans) | p02585 |
# どう考えてもK>5000でループが起きるので，
# dp[k][i]:= k回まで，移動したときの最大の値とすればよい
# -infで初期化
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
dp = [[-float('inf') for _ in range(N)] for __ in range(5000)]
for i,c in enumerate(C):
dp[0][i] = 0
max_val = -float('inf')
if K<(5000-1):
for i in range(K):
for j in range(N):
next_cell = P[j] - 1
dp[i + 1][next_cell] = max(dp[i][j] + C[next_cell], dp[i + 1][next_cell])
max_val = max(dp[i + 1][next_cell], max_val)
print(max_val)
exit()
for i in range(5000-1):
for j in range(N):
next_cell = P[j]-1
dp[i+1][next_cell] = max(dp[i+1][next_cell] + C[next_cell], dp[i+1][next_cell])
max_val = max(dp[i+1][next_cell],max_val)
print(max_val)
| N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
LC = [-1] * N
# Pが順列なので，結局それぞれのマスはループのどれかにいる事がわかる．あとは，ループの長さとループ1回分のコスト(a->a)を計算しておく
# ループ1回分のコストが正の場合はループをなるべく回す．負の場合は1回もループしないほうがいい．ただし最初のa->aは考慮する.
# 1回は最低でも動かないといけないから
max_score = -float('inf')
for i in range(N):
Loop_len = 0
Loop_cost =[]
Loop_cost_sum = 0
now = i
while True:
now = P[now] - 1
Loop_len += 1
Loop_cost_sum += C[now]
Loop_cost.append(Loop_cost_sum)
if now == i:
break
# それぞれのマスへのループによるコストのゲインと,最短でそこへいくまでの移動コストを計算してコストを決定する
for i,lc in enumerate(Loop_cost):
if K-(i+1)<0: # 行けないので
continue
possible_loop_num = (K-(i+1))//Loop_len
cost = lc + max(0,Loop_cost_sum) * possible_loop_num
max_score = max(cost,max_score)
print(max_score)
| p02585 |
from collections import defaultdict
n, k = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
P = [p - 1 for p in P]
SB = defaultdict(int)
sumC = sum(C)
# if sumC > 0:
# d, k = divmod(k, n)
# if d > 0:
# pscore = (d - 1) * sumC
# k += n
# else:
# pscore = 0
# else:
# k = min(k, n * 2)
pscore = 0
for p in P:
cnt = 0
score = 0
mv = - 10 ** 19
s = p
while cnt < k:
score += C[s]
s = P[s]
cnt += 1
mv = max(mv, score)
SB[p] = mv
ans = max(SB.values()) + pscore
print(ans) | from collections import defaultdict
n, k = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
P = [p - 1 for p in P]
# Pの要素の中で循環するモノ同士をまとめる
sep = []
visited = [0] * n
for i in range(n):
s = i
box = []
while visited[s] == 0:
box.append(s)
visited[s] = 1
s = P[s]
if box != []:
sep.append(box)
ans = - 10 ** 19
for sp in sep:
SB = defaultdict(int)
sumC = sum([C[i] for i in sp])
sn = len(sp)
if sumC > 0:
d, mk = divmod(k, sn)
if d > 0:
pscore = (d - 1) * sumC
mk += sn
else:
pscore = 0
else:
mk = min(k, sn * 2)
pscore = 0
for p in sp:
cnt = 0
score = 0
mv = - 10 ** 19
s = p
while cnt < mk:
score += C[s]
s = P[s]
cnt += 1
mv = max(mv, score)
SB[p] = mv
ans = max(ans, max(SB.values()) + pscore)
print(ans) | p02585 |
n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
c=list(map(int,input().split()))
ans=-10**9
for i in range(1,n+1):
m=i
co=0
an=0
for j in range(n):
m=p[m-1]
co+=1
if m==i:
break
m=i
x=[0 for j in range(co+1)]
for j in range(co):
m=p[m-1]
x[j+1]=x[j]+c[m-1]
if k<=co:
ans=max(ans,max(x[j] for j in range(1,k+1)))
else:
if x[-1]<=0:
ans=max(ans,max(x[j] for j in range(1,co+1)))
else:
f=max(0,k%co-1)
an+=x[-1]*f
s=k-f*co
m=i
for i in range(s):
m=p[m-1]
an+=c[m-1]
ans=max(ans,an)
print(ans)
| n,k=list(map(int,input().split()))
p=list(map(int,input().split()))
c=list(map(int,input().split()))
ans=-10**9
for i in range(1,n+1):
m=i
co=0
an=0
for j in range(n):
m=p[m-1]
co+=1
if m==i:
break
m=i
x=[0 for j in range(2*co)]
for j in range(2*co-1):
m=p[m-1]
x[j+1]=x[j]+c[m-1]
if k<=co:
ans=max(ans,max(x[j] for j in range(1,k+1)))
else:
if x[co]<=0:
ans=max(ans,max(x[j] for j in range(1,co+1)))
else:
f=max(0,(k//co)-1)
an+=x[co]*f
s=k-f*co
ans=max(ans,an+max(x[j] for j in range(1,s+1)))
print(ans)
| p02585 |
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
P_list = list(map(int, input().split()))
C_list = list(map(int, input().split()))
checked_list = [0 for _ in range(N)]
min_INF = -1 * 10 ** 10
max_score = min_INF
for i in range(N):
if checked_list[i] == 1:
continue
posit = i
loop_list = [posit]
score_list = []
for j in range(N):
posit = P_list[posit] - 1
if j == 0:
score_list.append(C_list[posit])
else:
score_list.append(score_list[-1] + C_list[posit])
if posit in loop_list:
break
loop_list.append(posit)
len_loop = len(loop_list)
for k in range(len_loop):
# print("loop", loop_list)
# print("score", score_list)
checked_list[loop_list[k]] = 1
temp_max_score = 0
rest_score = min_INF
if score_list[-1] > 0 and K // len_loop > 0:
temp_max_score += (K // len_loop - 1) * score_list[-1]
# 最後に1周すべきか
rest_score = max(max(score_list), max(score_list[:K % len_loop], default=min_INF) + score_list[-1])
# print(loop_list[k], temp_max_score, K, len_loop, K // len_loop)
rest_score = max(max(score_list[:min(K, len_loop)]), rest_score)
temp_max_score = temp_max_score + rest_score
# print(loop_list[k], temp_max_score, rest_score)
max_score = max(max_score, temp_max_score)
# ループ内でずらす
now_score = score_list.pop(0)
len_score = len(score_list)
score_list = [score_list[l] - now_score for l in range(len_score)]
score_list.append(score_list[-1] + now_score)
print(max_score) | # D not completed
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
P_list = list(map(int, input().split()))
C_list = list(map(int, input().split()))
checked_list = [0 for _ in range(N)]
min_INF = -1 * 10 ** 10
max_score = min_INF
for i in range(N):
if checked_list[i] == 1:
continue
posit = i
loop_list = [posit]
score_list = []
for j in range(N):
posit = P_list[posit] - 1
if j == 0:
score_list.append(C_list[posit])
else:
score_list.append(score_list[-1] + C_list[posit])
if posit in loop_list:
break
loop_list.append(posit)
len_loop = len(loop_list)
max_score_list = max(score_list)
around_score = score_list[-1]
temp_score_base = 0
if around_score > 0 and K // len_loop > 0:
temp_score_base += (K // len_loop - 1) * around_score
for k in range(len_loop):
# print("loop", loop_list)
# print("score", score_list)
checked_list[loop_list[k]] = 1
temp_max_score = temp_score_base
rest_score = min_INF
if around_score > 0 and K // len_loop > 0:
# 最後に1周すべきか
rest_score = max(max_score_list, max(score_list[:K % len_loop], default=min_INF) + around_score)
# print(loop_list[k], temp_max_score, K, len_loop, K // len_loop)
rest_score = max(max(score_list[:min(K, len_loop)]), rest_score)
temp_max_score = temp_max_score + rest_score
# print(loop_list[k], temp_max_score, rest_score)
max_score = max(max_score, temp_max_score)
# ループ内でずらす
now_score = score_list.pop(0)
len_score = len(score_list)
score_list = [score_list[l] - now_score for l in range(len_score)]
score_list.append(score_list[-1] + now_score)
print(max_score) | p02585 |
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
for i in range(len(p)):
p[i] -= 1
ans = float("-inf")
for i in range(N):
#iはスタートポジション
pos = i
#移動先のマスにかかれたポイント
point = []
total = 0
while True:
pos = p[pos]
point.append(c[pos])
# totalは周期の和がマイナスかプラスかで後々場合分けするために使う。(周期が負だったら一巡目で終わらせたい。周期が正だったらできる限り後の方で終わらせたい)
total += c[pos]
#スタートポジションに戻ってきた==サイクルを検知した
if pos == i: break
l = len(point)
t = 0
#total<0のときはif total>0以外の処理でまきとれる
for i in range(l):
t += point[i]
#Kがi+1より小さい時のハンドリング
if i+1 > K: break
now = t
if total > 0:
#K-i-1の-1はポイントの一個目を獲得する時に1個動くので-1。二こ目のポイントを取る時はi=1で、K-2になり計算が合う。それをlでわり周期が何個回れるかを計算する
#nowはtotalのセットが何個かあって、その先にpoint[i]がくっつくイメージ。[a,b,c] + [a,b,c] + [a,b,c] + ([a] or [a+b] + [a+b+c])
now += (total * ((K-i-1)//l))
ans = max(ans, now)
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
for i in range(len(p)):
p[i] -= 1
ans = float("-inf")
for i in range(N):
#iはスタートポジション
pos = i
#移動先のマスにかかれたポイント
point = []
total = 0
while True:
pos = p[pos]
point.append(c[pos])
# totalは周期の和がマイナスかプラスかで後々場合分けするために使う。(周期が負だったら一巡目で終わらせたい。周期が正だったらできる限り後の方で終わらせたい)
total += c[pos]
#スタートポジションに戻ってきた==サイクルを検知した
if pos == i: break
l = len(point)
t = 0
#total<0のときはif total>0以外の処理でまきとれる
for i in range(l):
t += point[i]
#Kがi+1より小さい時のハンドリング
if i+1 > K: break
now = t
if total > 0:
#K-i-1の-1はポイントの一個目を獲得する時に1個動くので-1。二こ目のポイントを取る時はi=1で、K-2になり計算が合う。それをlでわり周期が何個回れるかを計算する
#nowはtotalのセットが何個かあって、その先にpoint[i]がくっつくイメージ。[a,b,c] + [a,b,c] + [a,b,c] + ([a] or [a+b] + [a+b+c])
cnt = (K-i-1) // l
now += total * cnt
ans = max(ans, now)
print(ans)
| p02585 |
N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
for i in range(len(p)):
p[i] -= 1
ans = float("-inf")
for i in range(N):
#iはスタートポジション
pos = i
#移動先のマスにかかれたポイント
point = []
total = 0
while True:
pos = p[pos]
point.append(c[pos])
# totalは周期の和がマイナスかプラスかで後々場合分けするために使う。(周期が負だったら一巡目で終わらせたい。周期が正だったらできる限り後の方で終わらせたい)
total += c[pos]
#スタートポジションに戻ってきた==サイクルを検知した
if pos == i: break
l = len(point)
t = 0
#total<0のときはif total>0以外の処理でまきとれる
for i in range(l):
t += point[i]
#Kがi+1より小さい時のハンドリング
if i+1 > K: break
now = t
if total > 0:
#K-i-1の-1はポイントの一個目を獲得する時に1個動くので-1。二こ目のポイントを取る時はi=1で、K-2になり計算が合う。それをlでわり周期が何個回れるかを計算する
#nowはtotalのセットが何個かあって、その先にpoint[i]がくっつくイメージ。[a,b,c] + [a,b,c] + [a,b,c] + ([a] or [a+b] + [a+b+c])
#最初now += total * (K-i-1)//lとしていてWAしていたので書き方注意。これだとtotalと(K-i-1)をかけたものをlでわる、となってしまう。
cnt = (K-i-1) // l
now += total * cnt
ans = max(ans, now)
print(ans) | N, K = list(map(int, input().split()))
P = list(map(int, input().split()))
C = list(map(int, input().split()))
for i in range(len(P)):
P[i] -= 1
ans = float("-inf")
for i in range(N):
cycle = []
pos = i
total = 0
while True:
pos = P[pos]
cycle.append(C[pos])
total += C[pos]
if pos == i: break
l = len(cycle)
t = 0
for j in range(l):
t += cycle[j]
if j + 1 > K: break
now = t
if total > 0:
cnt = (K-j-1) // l
now += total * cnt
ans = max(ans, now)
print(ans) | p02585 |
import itertools
N, K = [int(_) for _ in input().split()]
P = [int(_) - 1 for _ in input().split()]
C = [int(_) for _ in input().split()]
class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_right(self, p, v): # apply operator from the right side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(dat[p], v)
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_left(self, p, v): # apply operator from the left side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(v, dat[p])
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
vl = vr = ti
l += n
r += n
while l < r:
if l & 1:
vl = f(vl, dat[l])
l += 1
if r & 1:
r -= 1
vr = f(dat[r], vr)
l >>= 1
r >>= 1
return f(vl, vr)
ans = -10**20
se = set()
for start in range(N):
if start in se:
continue
now = start
scores = []
while True:
if now in se:
break
se.add(now)
scores += [C[now]]
now = P[now]
cyclelen = len(scores)
cum = list(itertools.accumulate(scores * 2))
st = SegmentTree(cum, max, -10**20)
cycle, residue = divmod(K, cyclelen)
ans = max([ans] + [
st.query(start2 + 1, start2 + 1 + min(cyclelen, K)) - cum[start2]
for start2 in range(cyclelen)
])
if cum[-1] > 0 and cycle > 0:
v1 = cum[-1] * (cycle - 1) // 2 + max(
st.query(start2, start2 + cyclelen + 1) - cum[start2]
for start2 in range(cyclelen))
v2 = cum[-1] * cycle // 2 + max(
st.query(start2, start2 + residue + 1) - cum[start2]
for start2 in range(cyclelen))
ans = max([ans, v1, v2])
print(ans)
| import itertools
N, K = [int(_) for _ in input().split()]
P = [int(_) - 1 for _ in input().split()]
C = [int(_) for _ in input().split()]
class SegmentTree():
def __init__(self, array, f, ti):
"""
Parameters
----------
array : list
to construct segment tree from
f : func
binary operation of the monoid
ti :
identity element of the monoid
"""
self.f = f
self.ti = ti
self.n = n = 2**(len(array).bit_length())
self.dat = dat = [ti] * n + array + [ti] * (n - len(array))
for i in range(n - 1, 0, -1): # build
dat[i] = f(dat[i << 1], dat[i << 1 | 1])
def update(self, p, v): # set value at position p (0-indexed)
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = v
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_right(self, p, v): # apply operator from the right side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(dat[p], v)
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def operate_left(self, p, v): # apply operator from the left side
f, n, dat = self.f, self.n, self.dat
p += n
dat[p] = f(v, dat[p])
while p > 1:
p >>= 1
dat[p] = f(dat[p << 1], dat[p << 1 | 1])
def query(self, l, r): # result on interval [l, r) (0-indexed)
f, ti, n, dat = self.f, self.ti, self.n, self.dat
vl = vr = ti
l += n
r += n
while l < r:
if l & 1:
vl = f(vl, dat[l])
l += 1
if r & 1:
r -= 1
vr = f(dat[r], vr)
l >>= 1
r >>= 1
return f(vl, vr)
ans = -10**20
se = set()
for start in range(N):
if start in se:
continue
now = start
scores = []
while True:
if now in se:
break
se.add(now)
scores += [C[now]]
now = P[now]
cyclelen = len(scores)
cum = list(itertools.accumulate(scores * 3))
st = SegmentTree(cum, max, -10**20)
cycle, residue = divmod(K, cyclelen)
ans = max([ans] + [
st.query(start2 + 1, start2 + 1 + min(cyclelen, K)) - cum[start2]
for start2 in range(cyclelen)
])
if cum[-1] > 0 and cycle > 0:
v = cum[-1] * cycle // 3 + max(
st.query(0, start2 + residue + 1) - cum[start2]
for start2 in range(cyclelen, 2 * cyclelen))
ans = max(ans, v)
print(ans)
| p02585 |
import sys
import math
import collections
import bisect
import itertools
# import numpy as np
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])
# ===CODE===
# https://note.nkmk.me/python-union-find/
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n, k = ns()
p = na1()
c = na()
uf = UnionFind(n)
for i, pi in enumerate(p):
uf.union(i, pi)
cycledist = [[0, 0] for _ in range(n)]
for lis in list(uf.all_group_members().values()):
if cycledist[lis[0]][0] != 0:
continue
tmp = 0
l = len(lis)
for idx in lis:
tmp += c[idx]
cycledist[idx][1] = l
for idx in lis:
cycledist[idx][0] = tmp
ans = -INF
for i in range(n):
tmp_ans = cycledist[i][0] * (k // cycledist[i][1])
tmp = 0
idx = i
for _ in range(n):
tmp += c[p[idx]]
idx = p[idx]
if _ < k % cycledist[i][1]:
ans = max(ans, tmp, tmp + tmp_ans)
else:
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| import sys
import math
import collections
import bisect
import itertools
# import numpy as np
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list([int(x) - 1 for x in sys.stdin.readline().rstrip().split()])
# ===CODE===
# https://note.nkmk.me/python-union-find/
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
n, k = ns()
p = na1()
c = na()
uf = UnionFind(n)
for i, pi in enumerate(p):
uf.union(i, pi)
cycledist = [[-INF for _ in range(2)] for __ in range(n)]
for lis in list(uf.all_group_members().values()):
tmp = 0
l = len(lis)
for idx in lis:
tmp += c[idx]
cycledist[idx][1] = l
for idx in lis:
cycledist[idx][0] = tmp
ans = -INF
for i in range(n):
flg = k // cycledist[i][1] > 0
tmp_ans = cycledist[i][0] * ((k // cycledist[i][1]) - 1) if flg else 0
tmp = 0
idx = i
for j in range(cycledist[i][1] * flg + k % cycledist[i][1]):
tmp += c[p[idx]]
idx = p[idx]
ans = max(ans, tmp_ans + tmp)
tmp = 0
idx = i
for j in range(min(k, cycledist[i][1])):
tmp += c[p[idx]]
idx = p[idx]
ans = max(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| p02585 |
N, K = [int(i) for i in input().split()]
ps = [int(i) for i in input().split()]
cs = [int(i) for i in input().split()]
global_max = -10**10
past_score = [[]]*N
past_time = [[]]*N
for n in range(N):
score = 0
itta = set([])
iru = n
k = 0
while k < K:
score += cs[ps[iru]-1]
k += 1
if iru in itta:
# print('itta')
# print(f'iru is {iru}')
# print(f'score is {score}')
# print(f'past_score is {past_score}')
if score > past_score[iru]:
# print('plus loop')
T = k - past_time[iru] # 周期
# print(f'周期は {T}')
if K - k > (2 * T) + 1:
# print(f'繰り返しは{((K-k)//T - 1)}回')
# print('それによって', (((K-k)//T - 1)*(score - past_score[iru])))
score += (((K-k)//T - 1)*(score - past_score[iru]))
k += T * ((K-k)//T - 1)
# print(f'new score is {score}')
# print(f'new k is {k}')
else:
# print('break!')
break
itta.add(iru)
# print(iru)
# print(ps[iru]-1)
# print(f'score is {score}')
global_max = max(score, global_max)
past_score[iru] = score
past_time[iru] = k
iru = ps[iru]-1
print(global_max)
| N, K = [int(i) for i in input().split()]
ps = [int(i) for i in input().split()]
cs = [int(i) for i in input().split()]
global_max = -10**10
past_score = [[]]*N
past_time = [[]]*N
for n in range(N):
score = 0
itta = [0]*N
iru = n
k = 0
while k < K:
score += cs[ps[iru]-1]
k += 1
if itta[iru] == 1:
# print('itta')
# print(f'iru is {iru}')
# print(f'score is {score}')
# print(f'past_score is {past_score}')
if score > past_score[iru]:
# print('plus loop')
T = k - past_time[iru] # 周期
# print(f'周期は {T}')
if K - k > (2 * T) + 1:
# print(f'繰り返しは{((K-k)//T - 1)}回')
# print('それによって', (((K-k)//T - 1)*(score - past_score[iru])))
score += (((K-k)//T - 1)*(score - past_score[iru]))
k += T * ((K-k)//T - 1)
# print(f'new score is {score}')
# print(f'new k is {k}')
else:
# print('break!')
break
itta[iru] = 1
# print(iru)
# print(ps[iru]-1)
# print(f'score is {score}')
global_max = max(score, global_max)
past_score[iru] = score
past_time[iru] = k
iru = ps[iru]-1
print(global_max)
| p02585 |
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*n
self.rank=[-1]*n
def Find_Root(self,x):
if self.root[x]<0:return x
else:
self.root[x]=self.Find_Root(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.Find_Root(x)
y=self.Find_Root(y)
if x==y:return
elif self.rank[x]>self.rank[y]:
self.root[x] +=self.root[y]
self.root[y]=x
else:
self.root[y] +=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y] +=1
def isSameGroup(self,x,y):
return self.Find_Root(x)==self.Find_Root(y)
def size(self,x):
return -self.root[self.Find_Root(x)]
def members(self,x):
root=self.Find_Root(x)
return [i for i in range(self.n) if self.Find_Root(i)==root]
def roots(self):
return[i for i,j in enumerate(self.root) if j<0]
def group_members(self):
return {i:self.members(i) for i in self.roots()}
def group_count(self):
return len(self.roots())
N,K=list(map(int,input().split()))
P=list(map(int,input().split()))
C=list(map(int,input().split()))
UnionFind=UnionFind(N+1)
for i in range(N):
UnionFind.Unite(i+1,P[i])
D=UnionFind.group_members()
E=[]
for i in D:
A,length=D[i],len(D[i])
if A[0]==0:continue
index,F=A[0]-1,[]
while len(F)!=length:
index=P[index]-1
F.append(C[index])
E.append(F)
ans=-float("inf")
for A in E:
length=len(A)
if sum(A)<0:
A=A*2
for i in range(length):
point=0
for j in range(min(K,length)):
point +=A[i+j]
ans=max(ans,point)
else:
div,mod=divmod(K,length)
base=(div-1)*sum(A)
A=A*3
for i in range(length):
point=0
for j in range(mod+length):
point +=A[i+j]
ans=max(ans,base+point)
print(ans) | N,K=list(map(int,input().split()))
P=list(map(int,input().split()))
C=list(map(int,input().split()))
E=[]
color=["white" for _ in range(N)]
for i in range(N):
if color[i]=="white":
index,F=i,[]
while 1:
if color[index]=="white":
color[index]="black"
index=P[index]-1
F.append(C[index])
else:break
E.append(F)
ans=-float("inf")
for A in E:
length=len(A)
if sum(A)<0:
A=A*2
for i in range(length):
point=0
for j in range(min(K,length)):
point +=A[i+j]
ans=max(ans,point)
else:
div,mod=divmod(K,length)
base=(div-1)*sum(A)
A=A*3
for i in range(length):
point=0
for j in range(mod+length):
point +=A[i+j]
ans=max(ans,base+point)
print(ans) | p02585 |
n, k = list(map(int, input().split()))
Ps = list(map(int, input().split()))
Ps.insert(0,0)
Cs = list(map(int, input().split()))
Cs.insert(0,0)
Ls = [0] * (n + 1) # 周期
As = [] # 回答候補
# 周期を見つける
for i in range(1,n + 1):
count = 1
temp = Ps[i]
while temp != i:
temp = Ps[temp]
count += 1
Ls[i] = count
# それぞれの最大値を見つける
for i in range(1, n + 1):
ans = 0
p = [] #途中経過集
tempIndex = i
tempSum = 0
for j in range(Ls[i]):
tempIndex = Ps[tempIndex]
tempSum += Cs[tempIndex]
p.append(tempSum)
# print(f'p:{p}')
# ansを求める
if p[-1] <= 0:
ans = max(p[:min(k,Ls[i])])
else:
q, r = divmod(k, Ls[i])
# print(f'q,r,k,Ls[i]:{q}{r}{k}{Ls[i]}')
start = q * p[-1]
anss = [start]
tempIndex = i
tempSum = start
for z in range(r):
tempIndex = Ps[tempIndex]
tempSum += Cs[tempIndex]
anss.append(tempSum)
ans = max(anss)
As.append(ans)
print((max(As))) | n, k = list(map(int, input().split()))
Ps = list(map(int, input().split()))
Ps.insert(0,0)
Cs = list(map(int, input().split()))
Cs.insert(0,0)
Ls = [0] * (n + 1) # 周期
As = [0] * (n) # 回答候補
# 周期を見つける
for i in range(1,n + 1):
count = 1
temp = Ps[i]
while temp != i:
temp = Ps[temp]
count += 1
Ls[i] = count
# それぞれの最大値を見つける
for i in range(1, n + 1):
ans = 0
p = [0] * Ls[i] #途中経過集
tempIndex = i
tempSum = 0
for j in range(Ls[i]):
tempIndex = Ps[tempIndex]
tempSum += Cs[tempIndex]
p[j] = tempSum
# print(f'p:{p}')
# ansを求める
if p[-1] <= 0:
ans = max(p[:min(k,Ls[i])])
else:
q, r = divmod(k, Ls[i])
# print(f'q,r,k,Ls[i]:{q}{r}{k}{Ls[i]}')
start = (q - 1) * p[-1]
anss = [0] * (r + Ls[i])
anss.insert(0, start)
tempIndex = i
tempSum = start
for z in range(r + Ls[i]): #rは高々Ls[i]、つまりn、つまり5 * (10**3)
tempIndex = Ps[tempIndex]
tempSum += Cs[tempIndex]
anss[z + 1] = tempSum
ans = max(anss)
As[i-1] = ans
print((max(As))) | p02585 |
N,K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = -1*10**9
for si in range(N):
x = si
total = 0
l = 0
s = list()
while(1):
x = p[x]-1
s.append(c[x])
l += 1
total += c[x]
if x == si:
break
t = 0
for i in range(l):
now = 0
if (i+1) > K:
break
t += s[i]
now += t
if total > 0:
e = (K-(i+1)) // l
now += total * e
ans = max(ans, now)
print(ans) | N,K = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = -1* 10**9
for si in range(N):
s = list()
total = 0
l = 0
x = si
while(1):
x = p[x] - 1
s.append(c[x])
total += c[x]
l += 1
if x == si:
break
t = 0
for j in range(l):
t += s[j]
now = t
if j >= K:
break
if total > 0:
e = (K-j-1)//l
now += total * e
ans = max(ans, now)
print(ans) | p02585 |
n,k = list(map(int,input().split()))
score = [0 for i in range(n)]
P = list(map(int,input().split()))
C = list(map(int,input().split()))
ans = -float('inf')
for i in range(n):
start = i
cur = i
i_s_score = 0
i_s_score_max = C[P[cur]-1]
move_num = 0
for j in range(n):
cur = P[cur]-1
i_s_score += C[cur]
i_s_score_max = max(i_s_score, i_s_score_max)
move_num += 1
if cur == start:
break
if i_s_score <= 0:
ans = max(ans, i_s_score_max)
else:
temp = i_s_score*(k//move_num)
rest = k%move_num
ans = max(ans, temp)
i_s_score = temp
for j in range(rest):
cur = P[cur]-1
i_s_score += C[cur]
ans = max(ans, i_s_score)
print(ans)
| n,k = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
ans = -10**100
for i in range(n):
start = i
cur = i
i_s_score = 0
i_s_score_max = C[P[cur]-1]
move_num = 0
for j in range(n):
cur = P[cur]-1
i_s_score += C[cur]
i_s_score_max = max(i_s_score, i_s_score_max)
move_num += 1
if cur == start:
break
if i_s_score <= 0:
ans = max(ans, i_s_score_max)
else:
temp = i_s_score*(k//move_num)
if (k//move_num >= 1):
temp_dash = i_s_score*(k//move_num-1)+i_s_score_max
ans = max(ans, temp_dash)
rest = k%move_num
ans = max(ans, temp)
i_s_score = temp
for j in range(rest):
cur = P[cur]-1
i_s_score += C[cur]
ans = max(ans, i_s_score)
print(ans)
| p02585 |
N,K = list(map(int,input().split()))
P = list(map(int,input().split()))
C = list(map(int,input().split()))
##################################################################
max_point = -10000000000000
for i in range(N):
point = 0
now = i
for j in range(K):
next_place = P[now]-1
point += C[next_place]
max_point = max(point,max_point)
now = next_place
print(max_point) | n,k = list(map(int, input().split()))
p = list([int(z)-1 for z in input().split()])
c = list(map(int, input().split()))
data = [[0 for i in range(n+1)] for j in range(n)]
loop = [10**10 for i in range(n)]
for i in range(n):
j = i
for t in range(1,n+1):
j = p[j]
data[i][t] += data[i][t-1] + c[j]
if j == i:
loop[i] = min(loop[i],t)
ans = -10**10
#print(data)
#print([data[i][loop[i]] for i in range(n)])
for i in range(n):
for j in range(1,min(n,k)+1):
if j > loop[i]:break
if data[i][loop[i]] <= 0:
ans = max(ans,data[i][j])
else:
ans = max(ans,data[i][loop[i]]*((k-j)//loop[i])+data[i][j])
print(ans)
| p02585 |
N, K = [int(_) for _ in input().split()]
P = [int(_) - 1 for _ in input().split()]
C = [int(_) for _ in input().split()]
X = [False for _ in range(N)]
V = []
for i in range(N):
if X[i]:
continue
t = i
v = []
while X[t] is False:
X[t] = True
v.append(C[t])
t = P[t]
V.append(tuple(v))
def f(v, K):
if K == 0:
return 0
if max(v) < 0:
return max(v)
n = len(v)
X = [0]
for i in range(n):
X.append(X[-1] + v[i])
ans = -100000000000
for i in range(n + 1):
for j in range(i):
if i - j > K:
continue
ans = max(ans, X[i] - X[j])
return(ans)
ans = -100000000000
for v in V:
n = len(v)
if K > n:
s = sum(v)
if s > 0:
x = s * (K // n) + f(v * 2, K % n)
y = s * (K // n - 1) + f(v * 2, n)
a = max(x, y)
else:
a = f(v * 2, n)
else:
a = f(v * 2, K)
ans = max(a, ans)
print(ans)
| N, K = [int(_) for _ in input().split()]
P = [int(_) - 1 for _ in input().split()]
C = [int(_) for _ in input().split()]
def f(v, K):
if K == 0:
return 0
if max(v) < 0:
return max(v)
n = len(v)
X = [0]
for i in range(n):
X.append(X[-1] + v[i])
ans = -(10 ** 10)
for i in range(n + 1):
for j in range(i):
if i - j > K:
continue
ans = max(ans, X[i] - X[j])
return(ans)
X = [False for _ in range(N)]
ans = -(10 ** 10)
for i in range(N):
if X[i]:
continue
t = i
v = []
while X[t] is False:
X[t] = True
v.append(C[t])
t = P[t]
n = len(v)
if K > n:
s = sum(v)
x = f(v * 2, n)
if s > 0:
a = s * (K // n - 1) + max(s + f(v * 2, K % n), x)
else:
a = x
else:
a = f(v * 2, K)
ans = max(a, ans)
print(ans)
| p02585 |
n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
cs = list(map(int, input().split()))
graphs = []
vGraphs = []
flags = [False]*n
for i in range(len(ps)):
p = ps[i]
index = p - 1
if flags[index]:
continue
current = set()
values = set()
currentIndex = index
while True:
if flags[currentIndex]:
break
current.add(currentIndex)
values.add(cs[currentIndex])
flags[currentIndex] = True
nextIndex = ps[currentIndex] - 1
currentIndex = nextIndex
graphs.append(current)
vGraphs.append(values)
answer = -float('inf')
for i in range(n):
index = ps[i] - 1
value = cs[index]
searchI = 0
while True:
vg = vGraphs[searchI]
if value in vg:
currentGraph = vg
break
searchI += 1
total = sum(currentGraph)
currentSum = 0
count = 0
ci = i
while True:
count += 1
if count > k:
break
loop = (k - count) // len(currentGraph)
multi = max(0, total) * loop
ci = ps[ci] - 1
currentV = cs[ci]
currentSum += currentV
answer = max(answer, multi + currentSum)
if ci == i:
break
print(answer) | n, k = list(map(int, input().split()))
ps = list(map(int, input().split()))
cs = list(map(int, input().split()))
graphs = []
vGraphs = []
flags = [False]*n
sumDict = dict()
for i in range(len(ps)):
p = ps[i]
index = p - 1
if flags[index]:
continue
current = set()
values = set()
currentIndex = index
while True:
if flags[currentIndex]:
break
current.add(currentIndex)
values.add(cs[currentIndex])
flags[currentIndex] = True
nextIndex = ps[currentIndex] - 1
currentIndex = nextIndex
graphs.append(current)
vGraphs.append(values)
answer = -float('inf')
for i in range(n):
searchI = 0
loopSum = 0
nextIndex = i
loopCount = 0
while True:
nextIndex = ps[nextIndex] - 1
loopSum += cs[nextIndex]
loopCount += 1
if nextIndex == i:
break
total = loopSum
currentSum = 0
count = 0
ci = i
while True:
count += 1
if count > k:
break
loop = (k - count) // loopCount
multi = max(0, total) * loop
ci = ps[ci] - 1
currentV = cs[ci]
currentSum += currentV
answer = max(answer, multi + currentSum)
if ci == i:
break
print(answer) | p02585 |
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = -10**18
for i in range(n):
tmp_score = 0
pos = i
# cycle = 0
for l in range(k):
pos = p[pos]-1
tmp_score += c[pos]
ans = max(ans,tmp_score)
# cycle += 1
if pos == i: break
q,r = divmod(k,l+1)
if r == 0 and q > 1:
r = l+1
q -= 1
tmp_score *= q
ans = max(ans,tmp_score)
for _ in range(r):
pos = p[pos]-1
tmp_score += c[pos]
ans = max(ans,tmp_score)
print(ans)
| n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
c = list(map(int, input().split()))
ans = -10**18
for i in range(n):
tmp_score = 0
pos = i
cycle = 0
for l in range(k):
pos = p[pos]-1
tmp_score += c[pos]
ans = max(ans,tmp_score)
cycle += 1
if pos == i: break
q,r = divmod(k,cycle)
if r == 0 and q > 1:
r = cycle
q -= 1
tmp_score *= q
ans = max(ans,tmp_score)
for _ in range(r):
pos = p[pos]-1
tmp_score += c[pos]
ans = max(ans,tmp_score)
print(ans)
| p02585 |
N,K=list(map(int,input().split()))
P=list(map(int,input().split()))
C=list(map(int,input().split()))
a=[]
s=set()
for i in range(N):
idx=P[i]-1
z=set()
tl=[]
rl=[]
c=0
tc=0
while idx not in z and c<K:
tl.append(C[idx])
tc+=C[idx]
rl.append(tc)
s.add(tc)
z.add(idx)
idx=P[idx]-1
c+=1
if c<K:
d,m=divmod(K,c)
if m==0:
d-=1
m=c
tc=d*tc
tc+=max(rl[:m])
s.add(tc)
print((max(s))) | N,K=list(map(int,input().split()))
P=list(map(int,input().split()))
C=list(map(int,input().split()))
a=[]
ans=-10**10
for i in range(N):
idx=P[i]-1
z=set()
rl=[]
c=0
tc=0
while idx not in z and c<K:
tc+=C[idx]
rl.append(tc)
ans=max(ans,tc)
z.add(idx)
idx=P[idx]-1
c+=1
if c<K:
d,m=divmod(K,c)
if m==0:
d-=1
m=c
tc=d*tc
tc+=max(rl[:m])
ans=max(ans,tc)
print(ans) | p02585 |
cache = {0: 1, 1: 1, 2: 2}
combo_cache = {}
def prepare_cache():
val = 1
for i in range(1, 10000):
val *= i
cache[i] = val
def permutation(n):
if n in cache:
return cache[n]
ret = n
for i in range(n-1, 0, -1):
if i in cache:
ret *= cache[i]
cache[n] = ret
return ret
ret *= i
return ret
def combo(n, r):
key = str(n) + "-" + str(r)
if key in combo_cache:
return combo_cache[key]
x = permutation(n)
y = permutation(n-r)
z = permutation(r)
combo_cache[key] = int(x // (y * z))
return combo_cache[key]
count = int(eval(input()))
li = list(map(int, input().split()))
#
# data = open("input.txt", "r")
# l = data.read()
# li = list(map(int, l.split(" ")))
prepare_cache()
sli = sorted(li)
pair_a = 0
pair_b = 0
current_max = 0
i = sli[len(sli) - 1]
for j in range(0, len(sli) - 1):
val = combo(i, sli[j])
# print(str(sli[i]) + ", " + str(sli[j]) + ", " + str(val))
if val > current_max:
current_max = val
pair_a = i
pair_b = sli[j]
print((str(pair_a) + " " + str(pair_b)))
| count = int(eval(input()))
li = list(map(int, input().split()))
sli = sorted(li)
pair_a = sli[len(sli) - 1]
pair_b = 0
current_max = 0
i = sli[len(sli) - 1]
diff = 10**9
for j in range(0, len(sli) - 1):
h = pair_a / 2
if abs(h - sli[j]) < diff:
diff = abs(h - sli[j])
pair_b = sli[j]
print((str(pair_a) + " " + str(pair_b)))
| p03382 |
import math
def comb(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n = int(eval(input()))
a = [int(x) for x in input().split()]
x = max(a)
maxc = 0
maxy = 0
for y in sorted(a):
if x == y or y < x // 2:
continue
c = comb(x, y)
if maxc < c:
maxc = c
maxy = y
print((str(x) + ' ' + str(maxy)))
| import math
n = int(eval(input()))
a = [int(x) for x in input().split()]
a.sort()
x = max(a)
a.remove(x)
maxi = 0
mind = x
for i in range(len(a)):
d = abs((x+1) // 2 - a[i])
if d < mind:
maxi = i
mind = d
print((str(x) + ' ' + str(a[maxi])))
| p03382 |
s = input().strip()
t = input().strip()
for i in range(len(s)):
if s[i] != t[i]:
s = s.translate(str.maketrans({s[i]:t[i], t[i]:s[i]}))
if s == t:
print("Yes")
else:
print("No") | s = input().strip()
t = input().strip()
scount = []
tcount = []
for x in [chr(i) for i in range(97,97+26)]:
scount.append(s.count(x))
tcount.append(t.count(x))
if sorted(scount) == sorted(tcount):
print("Yes")
else:
print("No") | p03252 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
#s=input().rstrip()
s=input().rstrip()
t=input().rstrip()
u=Counter(s)
v=Counter(t)
for i in range(len(s)):
if u[s[i]]!=v[t[i]]:
print("No")
#print(i)
sys.exit()
print("Yes") | import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(eval(input())) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7
#s=input().rstrip()
alphasm=[chr(i) for i in range(97, 97+26)]
s=input().rstrip()
t=input().rstrip()
u=Counter(list(s))
v=Counter(list(t))
a,b=[],[]
for i in alphasm:
a.append(u[i])
b.append(v[i])
a.sort()
b.sort()
if a==b:
print("Yes")
else:
print("No") | p03252 |
S = input()
T = input()
CS = [S.count(s) for s in S]
TS = [T.count(t) for t in T]
if False in [CS[i] == TS[i] for i in range(len(CS))]:
print('No')
else:
print('Yes')
| S = input()
T = input()
CS = {}
for s in S:
if s not in CS:
CS[s] = 1
else:
CS[s] += 1
TS = {}
for t in T:
if t not in TS:
TS[t] = 1
else:
TS[t] += 1
if False in [CS[S[i]] == TS[T[i]] for i in range(len(T))]:
print('No')
else:
print('Yes')
| p03252 |
#!/usr/bin/env python3
S = input().strip()
T = input().strip()
for i in range(len(S)):
S = S.translate(str.maketrans({S[i]: T[i], T[i]: S[i]}))
print(('Yes' if S == T else 'No')) | #!/usr/bin/env python3
S = input().strip()
T = input().strip()
trans = dict()
ans = True
for s, t in zip(S, T):
if trans.get(s, t) != t:
ans = False
break
trans[s] = t
# print(trans)
print(('Yes' if ans and len(set(trans.values())) == len(trans) else 'No')) | p03252 |
import sys
import os
import math
import string
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
A = list(iss())
B = list(iss())
atob = {}
btoa = {}
for n in range(ord('a'), ord('z') + 1):
atob[chr(n)] = 0
btoa[chr(n)] = 0
for ab in zip(A, B):
a, b = ab
if atob[a] == 0 and btoa[b] == 0:
atob[a] = b
btoa[b] = a
elif atob[a] != b or btoa[b] != a:
print('No')
exit()
else:
print('Yes')
if __name__ == '__main__':
main()
| import sys
import os
import math
import string
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = list(iss())
T = list(iss())
StoT = {}
TtoS = {}
for n in range(ord('a'), ord('z') + 1):
StoT[chr(n)] = 0
TtoS[chr(n)] = 0
for st in zip(S, T):
s, t = st
if StoT[s] == 0 and TtoS[t] == 0:
StoT[s] = t
TtoS[t] = s
elif StoT[s] != t or TtoS[t] != s:
print('No')
exit()
else:
print('Yes')
if __name__ == '__main__':
main()
| p03252 |
import sys
import os
import math
import string
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = list(iss())
T = list(iss())
StoT = {}
TtoS = {}
for n in range(ord('a'), ord('z') + 1):
StoT[chr(n)] = 0
TtoS[chr(n)] = 0
for st in zip(S, T):
s, t = st
if StoT[s] == 0 and TtoS[t] == 0:
StoT[s] = t
TtoS[t] = s
elif StoT[s] != t or TtoS[t] != s:
print('No')
exit()
else:
print('Yes')
if __name__ == '__main__':
main()
| import sys
import os
import math
import bisect
import collections
import itertools
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: x * y / math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
S = collections.Counter(iss())
T = collections.Counter(iss())
if sorted(S.values()) == sorted(T.values()):
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| p03252 |
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i): is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
def prime_factor(n):
"""Return a list of prime factorization numbers of n"""
res = []
for i in range(2,int(n**0.5)+1):
while n%i==0: res.append(i); n //= i
if n != 1: res.append(n)
return res
## libs ##
from itertools import accumulate as acc, combinations as combi, product, combinations_with_replacement as combi_dup
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
import string
#======================================================#
def main():
s = IS()
t = IS()
tidx = {a: [] for a in string.ascii_lowercase}
sidx = {a: [] for a in string.ascii_lowercase}
for i, ti in enumerate(t):
tidx[ti].append(i)
for i, si in enumerate(s):
sidx[si].append(i)
for k, idx in list(tidx.items()):
tmp = set()
for i in idx:
tmp.add(s[i])
if len(tmp) > 1:
print('No')
return None
for k, idx in list(sidx.items()):
tmp = set()
for i in idx:
tmp.add(t[i])
if len(tmp) > 1:
print('No')
return None
print('Yes')
if __name__ == '__main__':
main() | import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list([x-1 for x in MII()])
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i): is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
def prime_factor(n):
"""Return a list of prime factorization numbers of n"""
res = []
for i in range(2,int(n**0.5)+1):
while n%i==0: res.append(i); n //= i
if n != 1: res.append(n)
return res
## libs ##
from itertools import accumulate as acc, combinations as combi, product, combinations_with_replacement as combi_dup
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
import string
#======================================================#
def check(t, sidx):
for idx in list(sidx.values()):
if idx:
tmp = set()
for i in idx:
tmp.add(t[i])
if len(tmp) > 1:
return False
return True
def main():
s = IS()
t = IS()
sidx = {a: [] for a in string.ascii_lowercase}
tidx = {a: [] for a in string.ascii_lowercase}
for i, si in enumerate(s): sidx[si].append(i)
for i, ti in enumerate(t): tidx[ti].append(i)
if check(s,tidx) and check(t,sidx):
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | p03252 |
A = {chr(i):0 for i in range(97,123)}
S = input().strip()
T = input().strip()
N = len(S)
G = {}
for i in range(N):
a = S[i]
if a not in G:
G[a]=[]
b = T[i]
if b not in G[a]:
G[a].append(b)
flag = 0
cnt = 0
for a in G:
cnt += 1
if len(G[a])>1:
flag = 1
break
if len(G[a])==0 and cnt==26:
break
b = G[a][0]
if a!=b:
cnt += 1
if A[b]==0:
A[b] += 1
else:
flag = 1
break
if flag==1:
print("No")
else:
print("Yes") | S = input().strip()
T = input().strip()
N = len(S)
C = {}
D = {}
flag = 0
for i in range(N):
if S[i] not in C:
C[S[i]] = T[i]
elif C[S[i]]!=T[i]:
flag = 1
break
if T[i] not in D:
D[T[i]] = S[i]
elif D[T[i]] != S[i]:
flag = 1
break
if flag==0:
print("Yes")
else:
print("No") | p03252 |
s,t=[sorted(x.count(i)for i in x) for x in open(0)]
print(('YNeos'[s!=t::2])) | s,t=[sorted(t.count(i)for i in set(t))for t in open(0)]
print(('YNeos'[s!=t::2])) | p03252 |
from collections import defaultdict
S, T = [x.strip() for x in open(0).read().split()]
ds, dt = defaultdict(str), defaultdict(str)
ans = 'Yes'
for s, t in zip(S, T):
if not ds[s] or ds[s] == t:
ds[s] = t
else:
ans = 'No'
break
if not dt[t] or dt[t] == s:
dt[t] = s
else:
ans = 'No'
break
print(ans) | S, T = input().strip(), input().strip()
ds, dt = {}, {}
for s, t in zip(S, T):
if s not in ds or ds[s] == t:
ds[s] = t
else:
print('No')
exit()
if t not in dt or dt[t] == s:
dt[t] = s
else:
print('No')
exit()
print('Yes') | p03252 |
sS = input().rstrip()
sT = input().rstrip()
def fConv2B(sA):
iL = len(sA)
dA = {}
for s in "abcdefghijklmnopqrstuvwxyz":
dA[s] = 0
iCounter = 1
for i in range(iL):
s = sA[i]
if s in dA:
if dA[sA[i]] == 0:
dA[sA[i]] = iCounter
iCounter += 1
if iCounter == 27 :
break
aR = [0]*iL
for i in range(iL):
aR[i] = dA[sA[i]]
# print(aR)
return aR
if fConv2B(sS) == fConv2B(sT) :
print("Yes")
else:
print("No")
| sS = input().rstrip()
sT = input().rstrip()
aS = [0] * 26
aT = [0] * 26
sABC = "abcdefghijklmnopqrstuvwxyz"
for i in range(26):
aS[i]=sS.count(sABC[i])
aT[i]=sT.count(sABC[i])
aS.sort()
aT.sort()
if aS == aT:
print ("Yes")
else:
print ("No")
| p03252 |
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def perm(n,mod=None):
ans = 1
for i in range(1,n+1):
ans *= i
if mod!=None:
ans %= mod
return ans
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
S,T=input(),input()
for i in range(len(S)):
if S[i]!=T[i]:
c=S[i]
S=S.replace(c,'-').replace(T[i],c).replace('-',T[i])
judge(S==T)
| import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def perm(n,mod=None):
ans = 1
for i in range(1,n+1):
ans *= i
if mod!=None:
ans %= mod
return ans
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
S,T=input(),input()
C=[-1]*26
D=set(list(range(26)))
ans=True
for i in range(len(S)):
s,t=ston(S[i]),ston(T[i])
if C[s]!=t:
if C[s]!=-1 or t not in D:
ans=False
break
D.remove(t)
C[s]=t
judge(ans)
| p03252 |
from math import ceil
N = int(eval(input()))
A, B = [], []
for _ in range(N):
ai, bi = list(map(int, input().split()))
A.append(ai)
B.append(bi)
# print(" ", A, B)
# 後ろから順番にすれば良い気がする (iのボタンは1からiまでしか作用しないので)
count = 0
for j in range(N - 1, -1, -1):
# j番目の足りない回数を決定
if A[j] % B[j] == 0:
continue
if A[j] < B[j]:
cj = B[j] - A[j]
else:
cj = ((A[j] + B[j] - 1) // B[j]) * B[j] - A[j]
count += cj
# cj回押した回数，数値を反映
for k in range(j, -1, -1):
A[k] += cj
# print(j, cj, A, B)
print(count) | from math import ceil
N = int(eval(input()))
A, B = [], []
for _ in range(N):
ai, bi = list(map(int, input().split()))
A.append(ai)
B.append(bi)
# 回数だけ確定する
# 後ろから順番にすれば良い気がする (iのボタンは1からiまでしか作用しないので)
count = 0
for j in range(N - 1, -1, -1):
if (count + A[j]) % B[j] == 0:
continue
else:
# 足りない分をカウントする
count += B[j] - (count + A[j]) % B[j]
print(count) | p03821 |
n=int(eval(input()))
a=[list(map(int, input().split())) for i in range(n)]
a=a[::-1]
count=0
for i in range(n):
b=a[i][0]+count
if b%a[i][1]!=0:
count+=a[i][1]-b%a[i][1]
print(count) | n=int(eval(input()))
a=[list(map(int, input().split())) for i in range(n)]
c=0
for i,j in a[::-1]:
if (c+i)%j!=0:
c+=j-(c+i)%j
print(c) | p03821 |
# AGC009A - Multiple Array
# greedy algorithm
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
A = tuple(tuple(map(int, input().split())) for _ in range(n))
ans = 0
for i, j in A[::-1]: # # decide from the last one
ans += -(i + ans) % j
print(ans)
if __name__ == "__main__":
main() | # AGC009A - Multiple Array
def main():
N, *AB = list(map(int, open(0).read().split()))
ans = 0
for i, j in zip(*[iter(AB[::-1])] * 2): # decide from the last one greedily
ans += -(j + ans) % i
print(ans)
if __name__ == "__main__":
main() | p03821 |
N = int(eval(input()))
A = [None] * N
B = [None] * N
for i in range(N):
A[i],B[i] = list(map(int, input().split()))
ans = 0
for i in range(N):
p = A[N-1-i] % B[N-1-i]
if p != 0:
for j in range(N-i):
A[j] += B[N-1-i] - p
ans += B[N-1-i] - p
print(ans) | N = int(eval(input()))
A = [None] * N
B = [None] * N
for i in range(N):
A[i],B[i] = list(map(int, input().split()))
ans = 0
for i in range(N):
p = (A[N-1-i] + ans) % B[N-1-i]
ans += (B[N-1-i] - p) % B[N-1-i]
print(ans) | p03821 |
n = int(eval(input()))
a_list = []
b_list = []
for _ in range(n):
a, b = list(map(int, input().split()))
a_list.append(a)
b_list.append(b)
a_list = list(reversed(a_list))
b_list = list(reversed(b_list))
ans = 0
for i in range(n):
a = a_list[i]
b = b_list[i]
a += ans
while (a % b != 0):
a += 1
ans += 1
print(ans) | n = int(eval(input()))
a_list = []
b_list = []
for _ in range(n):
a, b = list(map(int, input().split()))
a_list.append(a)
b_list.append(b)
a_list = list(reversed(a_list))
b_list = list(reversed(b_list))
ans = 0
for i in range(n):
a = a_list[i]
b = b_list[i]
a += ans
if (a % b) != 0:
ans += b - (a % b)
print(ans) | p03821 |
#!/usr/bin/env python3
(n, ), *s = [[*list(map(int, i.split()))] for i in open(0)]
a, b = list(zip(*s))
c = 0
for i in reversed(list(range(n))):
q = (a[i] + c) % b[i]
c += b[i] - q if q > 0 else 0
print(c)
| #!/usr/bin/env python3
(n, ), *s = [[*list(map(int, i.split()))] for i in open(0)]
c = 0
for a, b in reversed(s):
q = (a + c) % b
c += b * (q > 0) - q
print(c)
| p03821 |
list_ab = []
n = int(eval(input()))
for i in range(n):
list_ab.append(list(map(int, input().split())))
j = n - 1
count = 0
while j >= 0:
if list_ab[j][0] % list_ab[j][1] == 0:
j -= 1
else:
ad = list_ab[j][1] * (list_ab[j][0] // list_ab[j][1] + 1) - list_ab[j][0]
count += ad
for i in range(j+1):
list_ab[i][0] += ad
j -= 1
print(count)
| list_ab = []
n = int(eval(input()))
for i in range(n):
list_ab.append(list(map(int, input().split())))
j = n - 1
ad = 0
while j >= 0:
list_ab[j][0] += ad
if list_ab[j][0] % list_ab[j][1] == 0:
j -= 1
else:
ad += list_ab[j][1] * (list_ab[j][0] // list_ab[j][1] + 1) - list_ab[j][0]
j -= 1
print(ad)
| p03821 |
import math
n = int(eval(input()))
a = []
b = []
for i in range(n):
c, d= list(map(int, input().split()))
a.append(c)
b.append(d)
a.reverse()
b.reverse()
tot = 0
for i in range(n):
if (a[i]+tot)%b[i] == 0:
continue
x = b[i] - (a[i]+tot)%b[i]
tot += x
print (tot) | n = int(eval(input()))
a = []
b = []
for i in range(n):
c, d= list(map(int, input().split()))
a.append(c)
b.append(d)
a.reverse()
b.reverse()
tot = 0
for i in range(n):
if (a[i]+tot)%b[i] == 0: continue
x = b[i] - (a[i]+tot)%b[i]
tot += x
print (tot) | p03821 |
n = int(eval(input()))
a, b = [0]*n,[0]*n
count = 0
for i in range(n):
a[i],b[i] = list(map(int,input().split()))
while(n > 0):
if((a[n-1]+count)%b[n-1] == 0):
n -= 1
else:
count += 1
print(count) | n = int(eval(input()))
a, b = [0]*n,[0]*n
count = 0
for i in range(n):
a[i],b[i] = list(map(int,input().split()))
while(n > 0):
n -= 1
count += (b[n] if (a[n]+count)%b[n]!=0 else 0)-(a[n]+count)%b[n]
print(count) | p03821 |
N = int(eval(input()))
AB = []
for _ in range(N):
AB.append(tuple(map(int, input().split())))
cnt = 0
AB.reverse()
for el in AB:
A, B = el
A += cnt
while A % B != 0:
A += 1
cnt += 1
print(cnt) | N = int(eval(input()))
AB = []
for _ in range(N):
AB.append(tuple(map(int, input().split())))
cnt = 0
AB.reverse()
for el in AB:
A, B = el
A += cnt
if A % B != 0:
cnt += (B - A % B)
print(cnt) | p03821 |
import math
N=int(eval(input()))
A=[]
B=[]
for _ in range(N):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
A.reverse()
B.reverse()
#print("initial A B")
#print(A)
#print(B)
cnt=0
for i in range(N):
tmp=math.ceil(A[i]/B[i])*B[i]-A[i]
for j in range(i,N):
A[j]+=tmp
cnt+=tmp
#print("tmp,cnt,A",tmp,cnt,A)
print(cnt) | import math
N=int(eval(input()))
A=[]
B=[]
for _ in range(N):
a,b=list(map(int,input().split()))
A.append(a)
B.append(b)
A.reverse()
B.reverse()
cnt=0
for i in range(N):
A[i]+=cnt
tmp=math.ceil(A[i]/B[i])*B[i]-A[i]
cnt+=tmp
print(cnt) | p03821 |
n = int(eval(input()))
x = [0]*n
y = [0]*n
for i in range(n-1, -1, -1):
a,b = list(map(int, input().split()))
x[i] = a
y[i] = b
ans = 0
for i in range(n):
while (x[i]+ans) % y[i] != 0:
ans += 1
print(ans) | n = int(eval(input()))
x = [0]*n
y = [0]*n
for i in range(n-1, -1, -1):
a,b = list(map(int, input().split()))
x[i] = a
y[i] = b
ans = 0
for i in range(n):
if (x[i]+ans) % y[i] != 0:
ans += y[i]-(x[i]+ans)%y[i]
print(ans) | p03821 |
n = int(eval(input()))
a_li = []
b_li = []
for _ in range(n):
a,b = list(map(int, input().split()))
a_li.append(a)
b_li.append(b)
cnt = 0
for i in range(1,n+1):
if (a_li[-i]+cnt) % b_li[-i] != 0:
cnt += b_li[-i] - ((a_li[-i]+cnt) % b_li[-i])
print(cnt)
| n = int(eval(input()))
cnt = 0
ab_l = [list(map(int, input().split())) for _ in range(n)]
for ab in ab_l[::-1]:
a, b = ab[0], ab[1]
a += cnt
if a % b != 0:
cnt += b - a%b
print(cnt) | p03821 |
_, *AB = list(map(int, open(0).read().split()))
AB = iter(AB[::-1])
increment = 0
for b, a in zip(AB, AB):
a += increment
if a % b:
increment += b - a % b
print(increment) | def main():
_, *AB = list(map(int, open(0).read().split()))
AB = iter(AB[::-1])
increment = 0
for b, a in zip(AB, AB):
a += increment
if a % b:
increment += b - a % b
print(increment)
if __name__=="__main__":
main() | p03821 |
n=int(input())
ab=[list(map(int,input().split())) for _ in range(n)]
cnt=0
for i in range(n-1,-1,-1):
a,b=ab[i][0],ab[i][1]
if (a+cnt)%b==0:continue
cnt+=b-(a+cnt)%b
print(cnt) | n=int(input())
a=[]
b=[]
for i in range(n):
A,B=list(map(int,input().split()))
a.append(A)
b.append(B)
ans=0
for i in range(n-1,-1,-1):
if (a[i]+ans)%b[i]!=0:
ans+=b[i]-(a[i]+ans)%b[i]
print(ans) | p03821 |
# AGC009a
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
# map(int, input().split())
n = int(eval(input()))
a = list()
b = list()
for _ in range(n):
aa, bb = list(map(int, input().split()))
a.append(aa)
b.append(bb)
ans = 0
dif = 0
for i in range(n-1, -1, -1):
while True:
if (a[i]+dif) % b[i] == 0:
break
ans += 1
dif += 1
print(ans)
if __name__ == '__main__':
main()
| # AGC009a
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
# map(int, input().split())
n = int(eval(input()))
a = list()
b = list()
for _ in range(n):
aa, bb = list(map(int, input().split()))
a.append(aa)
b.append(bb)
ans = 0
dif = 0
for i in range(n-1, -1, -1):
osu = b[i]-(a[i]+dif) % b[i] if (a[i]+dif) % b[i] != 0 else 0
#print(a[i]+dif, b[i], osu, ans)
ans += osu
dif += osu
print(ans)
if __name__ == '__main__':
main()
| p03821 |
n = int(eval(input()))
a = []
b = []
for i in range(n):
x,y = list(map(int,input().split()))
a.append(x)
b.append(y)
res = 0
for i in range(n):
a[n-1-i] += res
c = a[n-1-i]%b[n-1-i]
if c != 0:
res += b[n-1-i]-c
print(res) | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = []
b = []
for i in range(n):
aa,bb = list(map(int,input().split()))
a.append(aa)
b.append(bb)
s = 0
res = 0
for i in range(n-1,-1,-1):
a[i] += res
if a[i]%b[i] == 0:
continue
res += b[i]-(a[i]%b[i])
print(res) | p03821 |
n = int(eval(input()))
list_a = []
list_b = []
su = 0
for i in range(n):
a,b = list(map(int,input().split()))
list_a.append(a)
list_b.append(b)
list_a = list_a[::-1]
list_b = list_b[::-1]
for i in range(n):
if list_a[i]%list_b[i]==0:
continue
else:
x = list_b[i]-(list_a[i]%list_b[i])
su += x
for j in range(i,n):
list_a[j] += x
# print(list_a)
print(su)
| n = int(eval(input()))
list_a = []
list_b = []
su = 0
for i in range(n):
a,b = list(map(int,input().split()))
list_a.append(a)
list_b.append(b)
list_a = list_a[::-1]
list_b = list_b[::-1]
for i in range(n):
list_a[i] += su
if list_a[i]%list_b[i]==0:
continue
else:
x = list_b[i]-(list_a[i]%list_b[i])
su += x
# print(list_a)
print(su)
| p03821 |
N = int(eval(input()))
A = [0 for _ in range(N)]
B = [0 for _ in range(N)]
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
A = A[::-1]
B = B[::-1]
R = [0 for _ in range(N)]
for i, (a, b) in enumerate(zip(A, B)):
r = a % b
if r > 0:
r = b - r
R[i] = r
ans = 0
for i in range(0, N):
r = R[i]
ans += r
for j in range(i + 1, N):
rj = R[j]
rj -= r
R[j] = rj % B[j]
print(ans)
| N = int(eval(input()))
A = [0 for _ in range(N)]
B = [0 for _ in range(N)]
for i in range(N):
a, b = list(map(int, input().split()))
A[i] = a
B[i] = b
A = A[::-1]
B = B[::-1]
R = [0 for _ in range(N)]
for i, (a, b) in enumerate(zip(A, B)):
r = a % b
if r > 0:
r = b - r
R[i] = r
ans = R[0]
for i in range(1, N):
r = R[i]
r = r - ans
r = r % B[i]
ans += r
print(ans)
| p03821 |
# coding: utf-8
# Your code here!
kai = int(eval(input()))
a = 0
b = 0
cou = 0
kaz = []
for i in range(kai):
a,b = list(map(int,input().split(" ")))
kaz.append(a)
kaz.append(b)
for j in range(kai):
while True:
if (kaz[(kai-j)*2 -2]+cou) % kaz [(kai-j)*2 -1] == 0:
break
else:
cou += 1
print(cou) | n = int(eval(input()))
p = []
for i in range(n):
a , b = list(map(int,input().split()))
p.append([a,b])
ans = 0
for i in reversed(list(range(n))):
if (p[i][0] + ans) % p[i][1] != 0:
ans += p[i][1] - ((p[i][0] + ans)%p[i][1])
print(ans) | p03821 |
N = int(eval(input()))
A = [list(map(int, input().split())) for _ in range(N)]
ans = 0
for i in range(N-1, -1, -1):
ans += (A[i][1] - (A[i][0]+ans) % A[i][1]) % A[i][1]
print(ans)
| ans = 0
for A, B in [list(map(int, input().split())) for _ in range(int(eval(input())))][::-1]:
ans += (B - A - ans) % B
print(ans)
| p03821 |
n,*a=list(map(int,open(0).read().split()))
#print(a)
sumcount=0
for s in range(n*2-1,-1,-2):
hidari=a[s-1]+sumcount
# print(hidari,a[s],sumcount)
if hidari%a[s]==0:
continue
elif hidari%a[s]!=0 and hidari//a[s]==0:
sumcount+=a[s]-hidari
elif hidari%a[s]!=0 and hidari//a[s]!=0:
sumcount+=(hidari//a[s]+1)*a[s]-hidari
print(sumcount) | n,*a=list(map(int,open(0).read().split()))
sumcount=0
for s in range(n*2-1,-1,-2):
hidari=a[s-1]+sumcount
if hidari%a[s]!=0 and hidari//a[s]==0:
sumcount+=a[s]-hidari
if hidari%a[s]!=0 and hidari//a[s]!=0:
sumcount+=(hidari//a[s]+1)*a[s]-hidari
print(sumcount) | p03821 |
#!/usr/bin/env python3
n, *d = list(map(int, open(0).read().split()))
a = d[::2]
b = d[1::2]
s = 0
for i in range(n):
t = a[-i-1] % b[-i-1]
if t: t = b[-i-1] - t
*a, = [x+t for x in a]
s += t
print(s) | #!/usr/bin/env python3
_, *s = open(0)
c = 0
for t in s[::-1]:
a, b = list(map(int, t.split()))
c += (-a-c) % b
print(c) | p03821 |
def floor(a, b):
return (-a)//b*(-1)
def inc_list(i, l):
for j in range(i):
l[j] += 1
return l
def inc_mult(i, n, l):
for _ in range(n):
l = inc_list(i, l)
return l
N = int(eval(input()))
A = []
B = []
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ans = 0
for i in reversed(list(range(N))):
a = A.pop(-1)
b = B.pop(-1)
inc = floor(a, b)*b - a
A = inc_mult(i, inc, A)
ans += inc
print(ans)
| def floor(a, b):
return (-a)//b*(-1)
N = int(eval(input()))
A = []
B = []
total_add = 0
for _ in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ans = 0
for i in reversed(list(range(N))):
a = A.pop(-1)
a += total_add
b = B.pop(-1)
inc = b*floor(a, b)-a
total_add += inc
print(total_add)
| p03821 |
n=int(eval(input()))
ab=[list(map(int, input().split())) for _ in range(n)]
cnt=0
for i in range(n):
a=ab[n-i-1][0]
b=ab[n-i-1][1]
a+=cnt
amari=a%b
shou=a//b
if amari!=0:
cnt+=b-amari
print(cnt) | n=int(eval(input()))
ab=[list(map(int, input().split())) for _ in range(n)]
cnt=0
for i in range(n):
a=ab[n-i-1][0]
b=ab[n-i-1][1]
a+=cnt
amari=a%b
if amari!=0:
cnt+=b-amari
print(cnt) | p03821 |
N = int(eval(input()))
A=[]
B=[]
for i in range(N):
a,b=[int(n) for n in input().split()]
A.append(a)
B.append(b)
cnt=0
# print(list(reversed(range(N))))
for i in reversed(list(range(N))):
if A[i]%B[i]==0:
r=0
else:
r=B[i]-A[i]%B[i]
cnt+=r
A=[A[n]+r if n<=i else A[n] for n in range(N)]
print(cnt)
| N = int(eval(input()))
A=[]
B=[]
for i in range(N):
a,b=[int(n) for n in input().split()]
A.append(a)
B.append(b)
cnt=0
# print(list(reversed(range(N))))
for i in reversed(list(range(N))):
if (A[i]+cnt)%B[i]==0:
d=0
else:
d=B[i]-(A[i]+cnt)%B[i]
cnt+=d
# A=[A[n]+r if n<=i else A[n] for n in range(N)]
print(cnt)
| p03821 |
N = int(eval(input()))
A = []
B = []
for i in range(N):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
A = A[::-1]
B = B[::-1]
ans = 0
for a, b in zip(A, B):
a += ans
if a % b != 0:
m = b - (a % b)
ans += m
print(ans) | N = int(eval(input()))
AB = reversed([[int(j) for j in input().split()] for i in range(N)])
ans = 0
for a, b in AB:
a += ans
if a % b != 0:
ans += b - (a % b)
print(ans) | p03821 |
N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N)][::-1]
plus=0
for j in range(N):
AB[j][0]+=plus
while AB[j][0]%AB[j][1]!=0:
AB[j][0]+=1
plus+=1
print(plus) | N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N)][::-1]
plus=0
for j in range(N):
AB[j][0]+=plus
if AB[j][0]%AB[j][1]!=0:
a=AB[j][1]-(AB[j][0]%AB[j][1])
AB[j][0]+=a
plus+=a
print(plus) | p03821 |
N = int(eval(input()))
A = []
B = []
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
k = 0
for i in range(N-1,-1,-1):
if A[i] % B[i] == 0 :
continue
else :
c = (B[i] - A[i] % B[i])
k += c
for j in range(i):
A[j] += c
print(k) | N = int(eval(input()))
A = []
B = []
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
k = 0
for i in range(N-1,-1,-1):
A[i] += k
if A[i] % B[i] == 0 :
pass
else :
c = (B[i] - A[i] % B[i])
k += c
print(k) | p03821 |
n=int(eval(input()))
A=[]
B=[]
for i in range(n):
a,b=input().split()
A.append(a)
B.append(b)
A.reverse()
B.reverse()
A.append(0)
B.append(0)
A=list(map(int,A))
B=list(map(int,B))
v=[0]
for i in range(0,n):
cnt=0
if A[i]%B[i]!=0:
cnt+=(B[i]-A[i]%B[i])
A[i]+=(B[i]-A[i]%B[i])
v.append(cnt)
A[i+1]+= sum(v)
print((sum(v)))
| n=int(eval(input()))
A=[]
B=[]
for i in range(n):
a,b=input().split()
A.append(a)
B.append(b)
A.reverse()
B.reverse()
A.append(0)
B.append(0)
A=list(map(int,A))
B=list(map(int,B))
x=0
for i in range(0,n):
cnt=0
if A[i]%B[i]!=0:
cnt+=(B[i]-A[i]%B[i])
A[i]+=(B[i]-A[i]%B[i])
x+=cnt
A[i+1]+= x
print(x) | p03821 |
n = int(eval(input()))
a_input = [0]*n
b_input = [0]*n
for i in range(n):
a_input[i],b_input[i]=list(map(int,input().split()))
ans=0
for i in range(n-1,-1,-1):
if a_input[i]%b_input[i]==0:
continue
tmp = b_input[i]-a_input[i]%b_input[i]
ans += tmp
for j in range(i+1):
a_input[j]+=tmp
print(ans)
| n = int(eval(input()))
a_input = [0]*n
b_input = [0]*n
for i in range(n):
a_input[i],b_input[i]=list(map(int,input().split()))
a_input=a_input[::-1]
b_input=b_input[::-1]
ans=0
for i in range(n):
a = a_input[i]+ans
b = b_input[i]
tmp = a%b
if tmp==0:
continue
ans+=(a//b+1)*b-a
print(ans)
| p03821 |
N = int(eval(input()))
A = []
B = []
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
count2 = 0
for i in range(N-1,-1,-1):
count = B[i]*((A[i]-1)//B[i] + 1) - A[i]
count2 += count
for j in range(i+1):
A[j] += count
print(count2)
| N = int(eval(input()))
A = []
B = []
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
count2 = 0
for i in range(N-1,-1,-1):
count = B[i]*((A[i]+count2-1)//B[i] + 1) - A[i]-count2
count2 += count
print(count2) | p03821 |
n = int(eval(input()))
l = []
for i in range(n):
i = list(map(int,input().split()))
l.append(i)
tmp = 0
for j in reversed(list(range(n))):
l[j][0] += tmp
while l[j][0]%l[j][1] != 0:
l[j][0] += 1
tmp += 1
print(tmp) | n = int(eval(input()))
l = []
for i in range(n):
i = list(map(int,input().split()))
l.append(i)
tmp = 0
for j in reversed(list(range(n))):
l[j][0] += tmp
if l[j][0]%l[j][1] != 0:
tmp += l[j][1] - l[j][0]%l[j][1]
print(tmp) | p03821 |
n = int(eval(input()))
a, b = [], []
for _ in range(n):
ta, tb = list(map(int, input().split()))
a.append(ta)
b.append(tb)
ans = 0
i = n - 1
while i >= 0:
r = a[i] % b[i]
if r != 0:
t = b[i] - r
ans += t
for j in range(i):
a[j] += t
i -= 1
print(ans) | n = int(eval(input()))
a, b = [], []
for _ in range(n):
ta, tb = list(map(int, input().split()))
a.append(ta)
b.append(tb)
ans = 0
i = n - 1
while i >= 0:
a[i] += ans
r = a[i] % b[i]
if r != 0:
ans += b[i] - r
i -= 1
print(ans) | p03821 |
n = int(eval(input()))
a, b = [], []
for _ in range(n):
ta, tb = list(map(int, input().split()))
a.append(ta)
b.append(tb)
ans = 0
i = n - 1
while i >= 0:
a[i] += ans
r = a[i] % b[i]
if r != 0:
ans += b[i] - r
i -= 1
print(ans) | N = int(eval(input()))
a, b = [], []
for _ in range(N):
aa, bb = list(map(int, input().split()))
a.append(aa)
b.append(bb)
ans = 0
add_v = 0
i = N - 1
while i >= 0:
r = (a[i] + add_v) % b[i]
if r != 0:
to_add = b[i] - r
add_v += to_add
ans += to_add
i -= 1
print(ans)
| p03821 |
N=int(eval(input()))
Z=[list(map(int,input().split())) for i in range(N)]
A,B=list(zip(*Z))
A=list(A[::-1])
B=list(B[::-1])
ans=0
for i in range(N):
A[i]+=ans
while A[i]%B[i]!=0:
ans+=1
A[i]+=1
print(ans) | N=int(eval(input()))
Z=[list(map(int,input().split())) for i in range(N)]
A,B=list(zip(*Z))
A=list(A[::-1])
B=list(B[::-1])
ans=0
for i in range(N):
A[i]+=ans
if A[i]%B[i]!=0:
a=B[i]-(A[i]%B[i])
ans+=a
print(ans) | p03821 |
n = int(eval(input()))
cnt = 0
a = [0] * n
b = [0] * n
for i in range(n):
a[i], b[i] = list(map(int, input().split()))
for i in range(n - 1, -1, -1):
if a[i] % b[i] != 0:
r = b[i] - a[i] % b[i]
cnt += r
for j in range(i + 1):
a[j] += r
print(cnt)
| n = int(eval(input()))
cnt = 0
a = [0] * n
b = [0] * n
for i in range(n):
a[i], b[i] = list(map(int, input().split()))
for i in range(n - 1, -1, -1):
r = b[i] - (a[i] + cnt) % b[i]
if r != b[i]:
cnt += r
print(cnt)
| p03821 |
N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N)][::-1]
count=0
for i in range(N):
AB[i][0]+=count
if AB[i][0]%AB[i][1]!=0:
count+=AB[i][1]-(AB[i][0]%AB[i][1])
print(count) | N=int(eval(input()))
AB=[list(map(int,input().split())) for i in range(N)]
count=0
for a,b in AB[::-1]:
a+=count
if a%b!=0:
count+=b-(a%b)
print(count) | p03821 |
"""
Nは10**5以下。O(N)なら通る
"""
N = int(eval(input()))
A = []
B = []
for i in range(N):
s = list(map(int, input().split()))
A.append(s[0])
B.append(s[1])
count = 0
for i in reversed(list(range(N))):
if A[i] % B[i] == 0:
continue
else:
s = B[i] - (A[i] % B[i])
A[:i+1] = [x + s for x in A[:i+1]]
count += s
print(count) | """
Nは10**5以下。O(N)なら通る
"""
N = int(eval(input()))
A = []
B = []
for i in range(N):
s = list(map(int, input().split()))
A.append(s[0])
B.append(s[1])
count = 0
for i in reversed(list(range(N))):
if (count + A[i]) % B[i] == 0:
continue
else:
s = B[i] - (count + A[i]) % B[i]
count += s
print(count) | p03821 |
N = int(eval(input()))
A = [None] * N
B = [None] * N
for i in range(1, N+1):
a, b = list(map(int, input().split()))
A[N-i] = a
B[N-i] = b
cnt = 0
for i in range(N):
A_add = A[i] + cnt
r = A_add % B[i]
if r == 0:
pass
else:
cnt += B[i] - r
print(cnt)
| import sys
N = int(eval(input()))
A = [None] * N
B = [None] * N
for i in range(1, N+1):
a, b = list(map(int, sys.stdin.readline().split()))
A[N-i] = a
B[N-i] = b
cnt = 0
for i in range(N):
A_add = A[i] + cnt
r = A_add % B[i]
if r == 0:
pass
else:
cnt += B[i] - r
print(cnt)
| p03821 |
N = int(eval(input()))
AB = [[int(i) for i in input().split()] for j in range(N)]
ans = 0
for i in reversed(list(range(N))):
Atemp = AB[i][0] + ans
ans += (0 if Atemp%AB[i][1] == 0 else AB[i][1]-Atemp%AB[i][1])
print(ans) | import sys
def solve():
input = sys.stdin.readline
N = int(eval(input()))
array = [[int(a) for a in input().split()] for _ in range(N)]
count = 0
for i in reversed(list(range(N))):
a, b = array[i]
if (a + count) % b == 0: continue
else: count += b - ((a + count) % b)
print(count)
return 0
if __name__ == "__main__":
solve() | p03821 |
N = int(eval(input()))
A = [list(map(int,input().split())) for k in range(N)]
ans = 0
for k in range(N):
A[N-1-k][0] += ans
while A[N-1-k][0]%A[N-1-k][1]!=0:
A[N-1-k][0] += 1
ans += 1
print(ans) | N = int(eval(input()))
A = [list(map(int,input().split())) for k in range(N)]
ans = 0
for k in range(N):
A[N-1-k][0] += ans
if A[N-1-k][0]%A[N-1-k][1]!=0:
d = A[N-1-k][1]*(1+A[N-1-k][0]//A[N-1-k][1])-A[N-1-k][0]
ans += d
A[N-1-k][0] += d
print(ans) | p03821 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
ab = []
for _ in range(n):
a,b = list(map(int, input().split()))
ab.append((a,b))
res = 0
for i in range(n-1,-1,-1):
a,b = ab[i]
a += res
if a%b==0:
pass
elif b>=a:
res += b-a
else:
res += b-a%b
print(res)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
ab = []
for _ in range(n):
a,b = list(map(int, input().split()))
ab.append((a,b))
res = 0
for i in range(n-1,-1,-1):
a,b = ab[i]
a += res
if b>=a>0:
res += b-a
elif a%b==0:
pass
else:
res += b-a%b
print(res)
| p03821 |
n=int(eval(input()))
a=[0]*n;b=a[:]
for i in range(n):
c,d=list(map(int,input().split()))
a[i]=c;b[i]=d
ans=0
for i in range(n)[::-1]:
a[i]+=ans
while a[i]%b[i]!=0:
a[i]+=1
ans+=1
print(ans)
| n=int(eval(input()))
a=[0]*n;b=a[:]
for i in range(n):
c,d=list(map(int,input().split()))
a[i]=c;b[i]=d
ans=0
for i in range(n)[::-1]:
a[i]+=ans
if a[i]%b[i]==0:continue
ans+=b[i]-(a[i]%b[i])
print(ans)
| p03821 |
n = int(eval(input()))
A = []
B = []
for i in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ans = 0
for i in range(n)[-1::-1]:
val = B[i] - A[i]%B[i]
if val == B[i]:
continue
ans += val
j = 0
while j != i:
A[j] += val
j += 1
print(ans) | n = int(eval(input()))
A = []
B = []
for i in range(n):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
ans = 0
for i in range(n)[-1::-1]:
val = B[i] - (A[i] + ans)%B[i]
if val == B[i]:
continue
ans += val
print(ans) | p03821 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.