input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
a = list(map(int, input().split()))
x = []
y = []
for i, elem in enumerate(a):
x.append(i+a[i])
y.append(i-a[i])
ans = 0
for i in x:
ans += y.count(i)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
x = []
y = {}
for i, elem in enumerate(a):
x.append(i+a[i])
y[i-a[i]] = y.get(i-a[i], 0) + 1
ans = 0
for i in x:
ans += y.get(i, 0)
print(ans)
| p02691 |
import itertools
N = int(eval(input()))
A = list(map(int, input().split()))
# total = N * (N-1) // 2
combi = list(itertools.combinations(list(range(N)), 2))
count = 0
for i, j in combi:
if A[i] + A[j] == abs(i-j):
count += 1
print(count) | N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for i in range(N):
for j in range(i+A[i], N):
if A[i] + A[j] == abs(i-j):
count += 1
print(count)
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for diff in range(1, N):
for i in range(N-diff):
# print(diff, i, i+diff)
if i+diff < N and A[i] + A[i+diff] == diff:
count += 1
print(count)
| N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
count = 0
for i in range(N):
l = i + A[i]
r = i - A[i]
if r in list(L.keys()):
count += L[r]
if l in list(L.keys()):
L[l] += 1
else:
L[l] = 1
print(count) | p02691 |
import sys
import re
import math
import collections
import decimal
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
sys.setrecursionlimit(10000001)
INF = sys.maxsize
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
a = na()
larger = [(i + 1) - a[i] for i in range(n)]
larger_cnt = collections.Counter(larger)
ans = 0
for j in range(n):
smaller = a[j] + (j + 1)
larger_cnt[(j + 1) - a[j]] -= 1
if smaller in list(larger_cnt.keys()):
if larger_cnt[smaller] != 0:
ans += larger_cnt[smaller]
print(ans)
if __name__ == '__main__':
main()
| import sys
import re
import math
import collections
import decimal
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
sys.setrecursionlimit(10000001)
INF = sys.maxsize
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
a = na()
larger = [i - a[i] for i in range(n)]
larger_cnt = collections.Counter(larger)
ans = 0
for j in range(n):
smaller = a[j] + j
larger_cnt[j - a[j]] -= 1
if smaller in list(larger_cnt.keys()):
if larger_cnt[smaller] != 0:
ans += larger_cnt[smaller]
print(ans)
if __name__ == '__main__':
main()
| p02691 |
n = int(eval(input()))
heights = list(map(int, input().split()))
diffMax = 2 * max(heights)
diffMin = 2 * min(heights)
cnt = 0
for i in range(diffMin, max([diffMax, n]) + 1):
for j in range(n - i):
if (heights[j] + heights[j + i]) == i:
cnt += 1
print(cnt) | n = int(eval(input()))
heights = list(map(int, input().split()))
diffMax = 2 * max(heights)
diffMin = 2 * min(heights)
cnt = 0
arrSize = min([max([i + heights[i] for i in range(len(heights))]),max([i - heights[i] for i in range(len(heights))])]) + 1
seppenPlus = [0] * arrSize
seppenMinus = [0] * arrSize
for i in range(len(heights)):
seppenPlusNum = i + heights[i]
seppenMinusNum = i - heights[i]
if seppenPlusNum < arrSize:
seppenPlus[seppenPlusNum] += 1
if seppenMinusNum >= 0:
seppenMinus[seppenMinusNum] += 1
for i in range(len(seppenPlus)):
cnt += seppenPlus[i] * seppenMinus[i]
print(cnt) | p02691 |
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
li1 = [i + e for i, e in enumerate(a, 1)]
li2 = [i - e for i, e in enumerate(a, 1)]
c1 = Counter(li1)
c2 = Counter(li2)
ans = 0
for k, v in list(c1.items()):
v2 = c2[k]
ans += v * v2
print(ans)
| from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for i, ai in enumerate(a, 1):
ans += d[i - ai]
d[i + ai] += 1
print(ans)
| p02691 |
from itertools import combinations
from collections import Counter
n = int(eval(input()))
A = list(map(int,input().split()))
c = Counter(A)
hs = []
for k,v in list(c.items()):
if v == 1:
hs.append(k)
elif v >= 2:
hs.append(k)
hs.append(k)
ts = []
for cmb in combinations(hs,2):
ts.append(sum(cmb))
ts = list(set(ts))
ans = 0
for h in ts:
for i in range(n-h):
if abs(A[i]+A[i+h]) == h:
ans += 1
print(ans) | n = int(eval(input()))
A = list(map(int,input().split()))
X = {}
ans = 0
for i in range(n):
L = i+A[i]
R = i-A[i]
if L not in X:
X[L] = 0
X[L]+=1
if R in X:
ans += X[R]
print(ans) | p02691 |
from bisect import bisect_left, bisect, insort
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
h_plus_i = [ai+i for i, ai in enumerate(a, 1)]
h_minus_i = [ai-i for i, ai in enumerate(a, 1)]
s_h_plus_i = list(sorted(h_plus_i))
s_h_minus_i = list(sorted(h_minus_i))
ans = 0
for hpi, hmi in zip(h_plus_i, h_minus_i):
i1 = bisect_left(s_h_minus_i, -hpi)
i2 = bisect_left(s_h_plus_i, -hmi)
if (i1 < n and s_h_minus_i[i1] == -hpi):
ans += bisect_left(s_h_minus_i, -hpi+1)-i1
if (i2 < n and s_h_plus_i[i2] == -hmi):
ans += bisect_left(s_h_plus_i, -hmi+1)-i2
print((ans//2))
if __name__ == "__main__":
main()
| def main():
n = int(eval(input()))
a = list(map(int, input().split()))
plus = [None]*n
minus = [None]*n
for i, ai in enumerate(a, 1):
plus[i-1] = i+ai
minus[i-1] = i-ai
plus.sort()
minus.sort()
ans = 0
j = 0
i = 0
while i < n:
pi = plus[i]
p_num = 1
m_num = 1
while j < n-1 and minus[j] < pi:
j += 1
mi = minus[j]
if mi == pi:
while j < n-1 and mi == minus[j+1]:
m_num += 1
j += 1
while i < n-1 and pi == plus[i+1]:
p_num += 1
i += 1
ans += p_num*m_num
i += 1
print(ans)
if __name__ == "__main__":
main() | p02691 |
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
a_list = [[j, i] for i, j in enumerate(a)]
#a_list.sort(reverse=True)
pairs = list(itertools.combinations(a_list, 2))
#print(pairs)
ans = 0
for pair in pairs:
if pair[0][0] + pair[1][0] >= n:
continue
elif pair[0][1] == pair[1][1]:
continue
elif abs(pair[0][1]-pair[1][1]) == (pair[0][0]+pair[1][0]):
ans += 1
"""
pairs = list(itertools.combinations(range(n), 2))
print(pairs)
ans = 0
for pair in pairs:
if abs(pair[0]-pair[1]) == (a[pair[0]]+a[pair[1]]):
ans += 1
"""
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
add_dic = {}
sub_dic = {}
for i in range(n):
add_tmp = i + a[i]
sub_tmp = i - a[i]
if not add_tmp in list(add_dic.keys()):
add_dic[add_tmp] = 1
else:
add_dic[add_tmp] += 1
if not sub_tmp in list(sub_dic.keys()):
sub_dic[sub_tmp] = 1
else:
sub_dic[sub_tmp] += 1
ans = 0
for k, v in list(add_dic.items()):
if k in list(sub_dic.keys()):
ans += v * sub_dic[k]
print(ans) | p02691 |
def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
from collections import defaultdict
n=n0()
a=[0]
a.extend(n1())
m1=[i+a[i] for i in range(n+1)]
m2=[j-a[j] for j in range(n+1)]
d1=defaultdict(list)
d2=defaultdict(list)
for i in range(1,n+1):
d1[m1[i]].append(i)
d2[m2[i]].append(i)
ans=0
for i in d1:
if len(d2[i])>0:
for k in d1[i]:
ans+=len([h for h in d2[i] if h>k])
print(ans) | def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]
from collections import defaultdict
n=n0()
a=[0]
a.extend(n1())
m1=[i+a[i] for i in range(n+1)]
m2=[j-a[j] for j in range(n+1)]
d1=defaultdict(list)
d2=defaultdict(list)
for i in range(1,n+1):
d1[m1[i]].append(i)
d2[m2[i]].append(i)
ans=0
for i in d1:
ans+=len(d1[i])*len(d2[i])
print(ans) | p02691 |
#j-i=Ai+Aj(j>i)
#j-Aj=Ai+i
#Lj=Ri=X
from bisect import bisect_left
def main():
N=int(eval(input()))
A=list(map(int,input().split()))
L={}
R={}
for i in range(N):
l=(i+1)-A[i]
r=A[i]+i+1
if (l in list(L.keys())):
L[l].append(i+1)
else:
L[l]=[i+1]
if (r in list(R.keys())):
R[r].append(i+1)
else:
R[r]=[i+1]
L_zip=list(zip(list(L.keys()),list(L.values())))
R_zip=list(zip(list(R.keys()),list(R.values())))
L_zip=sorted(L_zip)
R_zip=sorted(R_zip)
R_key,R_value=list(zip(*R_zip))
res=0
for l,l_index in L_zip:
if l>0:
ind=bisect_left(R_key ,l)
if R_key[ind]==l:
for l in l_index:
for r in R_value[ind]:
if l>r:
res+=1
if ind>=1:
R_key=R_key[ind-1:]
R_value=R_value[ind-1:]
print(res)
if __name__=="__main__":
main()
| #j-i=Ai+Aj(j>i)
#j-Aj=Ai+i
#Lj=Ri=X
from bisect import bisect_left
def main():
N=int(eval(input()))
A=list(map(int,input().split()))
L={}
R={}
res=0
for i in range(N):
l=(i+1)-A[i]
r=A[i]+i+1
if (l in list(R.keys())):
res+=len(R[l])
if (r in list(R.keys())):
R[r].append(i+1)
else:
R[r]=[i+1]
print(res)
if __name__=="__main__":
main()
| p02691 |
#j-i=Ai+Aj(j>i)
#j-Aj=Ai+i
#Lj=Ri=X
from bisect import bisect_left
def main():
N=int(eval(input()))
A=list(map(int,input().split()))
L={}
R={}
res=0
for i in range(N):
l=(i+1)-A[i]
r=A[i]+i+1
if (l in list(R.keys())):
res+=len(R[l])
if (r in list(R.keys())):
R[r].append(i+1)
else:
R[r]=[i+1]
print(res)
if __name__=="__main__":
main()
| def main():
N=int(eval(input()))
A=list(map(int,input().split()))
L={}
R={}
for i in range(N):
l=(i+1)+A[i]
r=(i+1)-A[i]
if (l in list(L.keys())):
L[l]+=1
else:
L[l]=1
if r in list(R.keys()):
R[r]+=1
else:
R[r]=1
res=0
for key in list(L.keys()):
if key in list(R.keys()):
res+=R[key]*L[key]
print(res)
if __name__=="__main__":
main()
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
later_max = [0]*(n+1)
a.insert(0, 0)
for i in range(1, n):
later_max[i] = i + a[i] + max(a[i+1:])
if later_max[i] > n:
later_max[i] = n
# print(a)
# print(later_max)
count = 0
for i in range(1, n):
j = i + a[i] + 1
# print(f"start:{i} {j}")
while j <= later_max[i]:
if a[i] + a[j] == j - i:
# print(i, j)
count += 1
j += 1
print(count)
| n = int(eval(input()))
a_array = list(map(int, input().split()))
a_array.insert(0, 0)
x_sum = {}
x_dis = {}
for i in range(1, n+1):
a_sum = i + a_array[i]
if a_sum in x_sum:
x_sum[a_sum].append(i)
else:
x_sum[a_sum] = [i]
if not(a_sum in x_dis):
x_dis[a_sum] = []
a_dis = i - a_array[i]
if a_dis > 0:
if a_dis in x_dis:
x_dis[a_dis].append(i)
else:
x_dis[a_dis] = [i]
if not(a_dis in x_sum):
x_sum[a_dis] = []
# print(x_sum)
# print(x_dis)
count = 0
for k in list(x_sum.keys()):
count += len(x_sum[k]) * len(x_dis[k])
print(count)
| p02691 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
# j-i=Ai+Aj
# Ai+i=j-Aj
a=[]
b=[]
for i in range(n):
x=l[i]
a.append(x+(i+1))
b.append((i+1)-x)
ans=0
for i,x in enumerate(a[i:]):
ans+=b.count(x)
for i,x in enumerate(b[i:]):
ans+=a.count(x)
return ans
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
# j-i=Ai+Aj
# Ai+i=j-Aj
a=[]
b={}
for i in range(n):
x=l[i]
a.append(x+i)
y=i-x
if y in b:
b[y]+=1
else:
b[y]=1
ans=0
for x in a:
if x in b:
ans+=b[x]
return ans
# main()
print((main()))
| p02691 |
N = int(eval(input()))
A = input().split()
pear = 0
for i in range(N-1, 0, -1):
for j in range(i):
if int(A[i]) >= (i - j):
break
if (i - j) == (int(A[i]) + int(A[j])):
pear += 1
print(pear) | N = int(eval(input()))
A = input().split()
pear = 0
i_result = {}
j_result = {}
for i in range(N):
result = str(i + int(A[i]))
if result in i_result:
i_result[result] += 1
else:
i_result[result] = 1
for j in range(N):
result = str(j - int(A[j]))
if result in j_result:
j_result[result] += 1
else:
j_result[result] = 1
for k in list(i_result.keys()):
if k in j_result:
pear += (i_result[k] * j_result[k])
print(pear) | p02691 |
N =int(eval(input()))
A = list(map(int,input().split()))
x=0
y=0
ans =0
while x <N:
y =x+A[x]
while y <N:
t = A[x]+A[y]
if t == y-x:
ans +=1
y+=1
x+=1
print(ans) | N =int(eval(input()))
A = list(map(int,input().split()))
d ={}
r ={}
ans =0
for x in range(N):
d[x] =0
r[x] =0
for x in range(N):
dt = A[x]+x
rt = x-A[x]
if dt<N:
d[dt] +=1
if rt >-1:
r[rt] +=1
for x in range(N):
if d[x] !=0 and r[x]!=0:
ans = ans + d[x]*r[x]
print(ans) | p02691 |
N=int(eval(input()))
A=list(map(int,input().split()))
NA=[]
for i in range(N):
NA.append(A[i]-i)
from collections import Counter
d=Counter(NA)
cnt=0
for i in range(N-1):
cnt+=d[-i-A[i]]
print(cnt)
| N=int(eval(input()))
A=list(map(int,input().split()))
NA=[]
cnt=0
d={}
for i in range(N):
if A[i]-i in d:
cnt+=d[A[i]-i]
if not -A[i]-i in d:
d[-A[i]-i]=1
else:
d[-A[i]-i]+=1
print(cnt)
| p02691 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n = int(eval(input()))
a = list( map(int, input().split()))
from collections import defaultdict
ar = defaultdict(list)
al = defaultdict(list)
for i in range(n):
al[i+a[i]].append(i)
ar[i-a[i]].append(i)
mi = 0-max(a)
ma = n+max(a)
ans = 0
for i in range(mi,ma):
ans += len(ar[i]) * len(al[i])
print(ans)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
n = int(eval(input()))
a = list( map(int, input().split()))
from collections import defaultdict
ar = defaultdict(list)
al = defaultdict(list)
for i in range(n):
al[i+a[i]].append(i)
ar[i-a[i]].append(i)
x = list(al.keys())
ans = 0
for i in x:
ans += len(ar[i]) * len(al[i])
print(ans)
| p02691 |
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n=ni()
a=nl()
ans=0
for i in range(n):
for j in range(i,n):
if abs(j-i) == a[i]+a[j]:
ans+=1
print(ans) | ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
n=ni()
a=nl()
ans=0
nums = dict()
for i in range(n):
num_i = i+a[i]
if num_i not in nums:
nums[num_i]=0
nums[num_i]+=1
for j in range(n):
num_j = j-a[j]
if num_j in nums:
ans+=nums[num_j]
print(ans) | p02691 |
# 32:35
n = int(eval(input()))
heights = list(map(int, input().split()))
values = dict()
for ii, h in enumerate(heights):
c1 = ii - h
if (c1) in values:
values[c1].append((ii, h))
else:
values[c1] = [(ii, h)]
count = dict()
for j, h in enumerate(heights):
if (j + h) in values:
for i, ai in values[j + h]:
if i > 0 and i > j and not (j, i) in count:
count[(j, i)] = True
print((len(count))) | # 32:35
n = int(eval(input()))
heights = list(map(int, input().split()))
values = dict()
for ii, h in enumerate(heights):
c1 = ii - h
if (c1) in values:
values[c1].append((ii, h))
else:
values[c1] = [(ii, h)]
count = 0
for j, h in enumerate(heights):
if (j + h) in values:
count += len(values[j + h])
# for i, ai in values[j + h]:
# if i > 0 and i > j and not (j, i) in count:
# count[(j, i)] = True
print(count) | p02691 |
import sys
input=lambda :sys.stdin.readline().rstrip()
from collections import defaultdict
n = int(eval(input()))
A = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for j in range(n):
Dif = j - A[j]
ans += d[Dif]
Sum = A[j] + j
d[Sum] += 1
print(ans) | def main():
## IMPORT MODULE
#import sys
#sys.setrecursionlimit(100000)
#input=lambda :sys.stdin.readline().rstrip()
from collections import defaultdict
#f_inf=float("inf")
#MOD=10**9+7
if 'get_ipython' in globals():
## SAMPLE INPUT
n = 6
A = [2, 3, 3, 1, 3, 1]
else:
##INPUT
n = int(eval(input()))
A = list(map(int, input().split()))
## SUBMITION CODES HERE
d = defaultdict(int)
ans = 0
for j in range(n):
Dif = j - A[j]
ans += d[Dif]
Sum = A[j] + j
d[Sum] += 1
print(ans)
main() | p02691 |
n=int(eval(input()))
a=list(map(int,input().split()))
from collections import Counter
ai,aj=[],[]
for i in range(n):
aj.append(i-a[i])
ai.append(i+a[i])
c1=Counter(ai)
c2=Counter(aj)
ans=0
for k in list(c1.keys()):
ans+=c1[k]*c2[k]
print(ans)
| n = int(eval(input()))
a = list(map(int,input().split()))
x = [ aa + i for i,aa in enumerate(a,start = 1)]
y = [ i - aa for i,aa in enumerate(a,start = 1)]
from collections import Counter
c = Counter(y)
ans = 0
for xx in x:
ans += c[xx]
print(ans)
| p02691 |
import collections
n = int(eval(input()))
participant = list(map(int, input().split()))
hashSet = collections.defaultdict(lambda:set())
for i,v in enumerate(participant):
hashSet[v].add(i)
ans = 0
for i,v in enumerate(participant):
for key, s in list(hashSet.items()):
if i+v+key in s:
ans += 1
print(ans) | import collections
eval(input())
p = list(map(int, input().split()))
map1 = collections.defaultdict(lambda:0)
map2 = collections.defaultdict(lambda:0)
for i, v in enumerate(p):
map1[i+v] += 1
map2[i-v] += 1
ans = 0
for i in map1:
if i in map2:
ans += map1[i] * map2[i]
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
i_list = [a + i + 1 for i, a in enumerate(A)]
ans = 0
for j in range(N):
ans += i_list[:j+1].count(j+1-A[j])
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
#i_list = [a + i + 1 for i, a in enumerate(A)]
ans = 0
mp = {}
for i in range(N):
i_kou = i + 1 + A[i]
if i_kou in mp:
mp[i_kou] += 1
else:
mp[i_kou] = 1
j_kou = i + 1 - A[i]
if j_kou in mp:
ans += mp[j_kou]
print(ans) | p02691 |
from sys import stdin
from sys import setrecursionlimit
from itertools import accumulate
setrecursionlimit(10 ** 7)
n = int(stdin.readline().rstrip())
a = list(map(int,stdin.readline().rstrip().split()))
point = 0
for i in range(2,n):
for j in range(n-i):
if a[j]+a[j+i] == i:
point += 1
print(point) | from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)
n = int(stdin.readline().rstrip())
a = list(map(int,stdin.readline().rstrip().split()))
dic = {}
point = 0
for i,j in enumerate(a):
if i+j in dic:
dic[i+j] += 1
else:
dic[i+j] = 1
for i,j in enumerate(a):
if i-j in dic:
point += dic[i-j]
print(point) | p02691 |
from operator import itemgetter
from collections import defaultdict
N = int(eval(input()))
A = [int(v) for v in input().split()]
cnt = 0
left_list = [i + a for i, a in enumerate(A, 1)]
right_list = [i - a for i, a in enumerate(A, 1)]
right_dict = defaultdict(set)
for i, right in enumerate(right_list, 1):
right_dict[right].add(i)
for i, left in enumerate(left_list, 1):
pair_num = len(right_dict[left] - set([i]))
cnt += pair_num
print(cnt) | from operator import itemgetter
from collections import defaultdict
N = int(eval(input()))
A = [int(v) for v in input().split()]
cnt = 0
left_list = [i + a for i, a in enumerate(A, 1)]
right_list = [i - a for i, a in enumerate(A, 1)]
right_dict = defaultdict(set)
for i, right in enumerate(right_list, 1):
right_dict[right].add(i)
for i, left in enumerate(left_list, 1):
pair_num = len(right_dict[left])
cnt += pair_num
print(cnt) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
l = [0]*n
ans = 0
for i in range(n):
l[i] = i + 1 + a[i]
ans += l[:i].count(i + 1 - a[i])
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
d = {}
ans = 0
for i in range(n):
l = i + a[i]
r = i - a[i]
if l not in d:
d[l] = 1
else:
d[l] += 1
if r in d:
ans += d[r]
print(ans) | p02691 |
alpha = 'abcdefghijklmnopqrstuvwxyz'
text = ''
while True:
try:
text += input().lower()
except:
break
for key in alpha:
print(('{} : {}'.format(key, text.count(key))))
| alpha = 'abcdefghijklmnopqrstuvwxyz'
text = ''
while True:
try:
text += input().lower()
except:
break
[print('{} : {}'.format(key, text.count(key))) for key in alpha]
| p02417 |
import sys
strs = sys.stdin.readlines()
for c in range(ord('a'), ord('z') + 1):
count = 0
for str in strs:
count += str.lower().count(chr(c))
print(('{0} : {1}'.format(chr(c), count))) | import sys
strs = sys.stdin.readlines()
for c in range(ord('a'), ord('z') + 1):
count = 0
for s in strs:
count += s.lower().count(chr(c))
print(('{0} : {1}'.format(chr(c), count))) | p02417 |
import sys
az =["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
sum_az = [0 for x in range(26)]
for x in sys.stdin.read().lower():
for i in range(26):
for j in range(len(x)):
if x[j] == az[i]:
sum_az[i] += 1
for i in range(26):
print(("%s : %d" % (az[i], sum_az[i])))
| import sys
az =["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
sum_az = [0 for x in range(26)]
for x in sys.stdin.read().lower():
for i in range(26):
if x == az[i]:
sum_az[i] += 1
for i in range(26):
print(("%s : %d" % (az[i], sum_az[i])))
| p02417 |
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def k_fix_way(com_n, com_r):
if (com_n, com_r) in kmemo:
return kmemo[(com_n, com_r)]
res = kmemo[(com_n, com_r)] = fac[com_n] * inv[com_n - com_r] * fac[com_n] * inv[com_r] * inv[
com_n - com_r] % md
return res
kmemo = {}
def centroid(u=0, pu=-1):
res = []
is_centroid = True
u_nodes = 1
for cu in to[u]:
if cu == pu: continue
res += centroid(cu, u)
cu_nodes = n_nodes[cu]
if cu_nodes > n / 2: is_centroid = False
u_nodes += cu_nodes
n_nodes[u] = u_nodes
if n - u_nodes > n / 2: is_centroid = False
if is_centroid: res.append(u)
return res
md = 10 ** 9 + 7
to = defaultdict(list)
n = int(input())
for _ in range(n - 1):
u, v = map(int, input().split())
u, v = u - 1, v - 1
to[u].append(v)
to[v].append(u)
# 部分木の頂点数を記録しながら重心を求める
n_nodes = [0] * n
cc = centroid()
# print(cc)
# 階乗の準備
n_max = n
fac = [1]
inv = [1] * (n_max + 1)
k_fac_inv = 1
for i in range(1, n_max + 1):
k_fac_inv = k_fac_inv * i % md
fac.append(k_fac_inv)
k_fac_inv = pow(k_fac_inv, md - 2, md)
for i in range(n_max, 1, -1):
inv[i] = k_fac_inv
k_fac_inv = k_fac_inv * i % md
# 重心が2つの（グラフを二等分できる）場合
if len(cc) == 2:
print(pow(fac[n // 2], 2, md))
exit()
# 重心が1つの場合
# サブツリーの頂点数のリストsubtree_node_n作成
subtree_node_n = []
c = cc[0]
for u in to[c]:
u_nodes = n_nodes[u]
if u_nodes > n / 2: continue
subtree_node_n.append(u_nodes)
if c != 0: subtree_node_n.append(n - n_nodes[c])
# print(subtree_node_n)
# dp[i][j]をi番目のサブツリーまでみて、j個の頂点を固定したときの決め方として求める
sn = len(subtree_node_n)
dp = [[0] * n for _ in range(sn + 1)]
dp[0][0] = 1
for i, node_n in enumerate(subtree_node_n):
for j in range(n):
pre = dp[i][j]
if pre == 0: continue
for k in range(node_n + 1):
dp[i + 1][j + k] = (dp[i + 1][j + k] + pre * k_fix_way(node_n, k)) % md
# p2D(dp)
# 包除原理
ans = 0
coff = 1
for j in range(n):
ans = (ans + coff * dp[sn][j] * fac[n - j]) % md
coff *= -1
print(ans)
main()
| from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def k_fix_way(com_n, com_r):
if (com_n, com_r) in kmemo:
return kmemo[(com_n, com_r)]
res = kmemo[(com_n, com_r)] = fac[com_n] * inv[com_n - com_r] * fac[com_n] * inv[com_r] * inv[
com_n - com_r] % md
return res
kmemo = {}
def centroid(u=0, pu=-1):
res = []
is_centroid = True
u_nodes = 1
for cu in to[u]:
if cu == pu: continue
res += centroid(cu, u)
cu_nodes = n_nodes[cu]
if cu_nodes > n / 2: is_centroid = False
u_nodes += cu_nodes
n_nodes[u] = u_nodes
if n - u_nodes > n / 2: is_centroid = False
if is_centroid: res.append(u)
return res
md = 10 ** 9 + 7
to = defaultdict(list)
n = int(input())
for _ in range(n - 1):
u, v = map(int, input().split())
u, v = u - 1, v - 1
to[u].append(v)
to[v].append(u)
# 部分木の頂点数を記録しながら重心を求める
n_nodes = [0] * n
cc = centroid()
# print(cc)
# 階乗の準備
n_max = n
fac = [1]
inv = [1] * (n_max + 1)
k_fac_inv = 1
for i in range(1, n_max + 1):
k_fac_inv = k_fac_inv * i % md
fac.append(k_fac_inv)
k_fac_inv = pow(k_fac_inv, md - 2, md)
for i in range(n_max, 1, -1):
inv[i] = k_fac_inv
k_fac_inv = k_fac_inv * i % md
# 重心が2つの（グラフを二等分できる）場合
if len(cc) == 2:
print(pow(fac[n // 2], 2, md))
exit()
# 重心が1つの場合
# サブツリーの頂点数のリストsubtree_node_n作成
subtree_node_n = []
c = cc[0]
for u in to[c]:
u_nodes = n_nodes[u]
if u_nodes > n / 2: continue
subtree_node_n.append(u_nodes)
if c != 0: subtree_node_n.append(n - n_nodes[c])
# print(subtree_node_n)
# dp[i][j]をi番目のサブツリーまでみて、j個の頂点を固定したときの決め方として求める
sn = len(subtree_node_n)
dp = [0] * n
dp[0] = 1
for i, node_n in enumerate(subtree_node_n):
dp1 = [0] * n
for j in range(n):
pre = dp[j]
if pre == 0: continue
for k in range(node_n + 1):
dp1[j + k] = (dp1[j + k] + pre * k_fix_way(node_n, k)) % md
dp = dp1
# p2D(dp)
# 包除原理
ans = 0
coff = 1
for j in range(n):
ans = (ans + coff * dp[j] * fac[n - j]) % md
coff *= -1
print(ans)
main()
| p03492 |
# #バブルソート
# def BubbleSort(C,N):
# for i in range (0,N,1):
# for j in range(N-1,i-1,-1):
# if int(C[j][1:2]) < int(C[j-1][1:2]):
# tmp = C[j]
# C[j] = C[j-1]
# C[j-1] = tmp
# print(' '.join(C))
#バブルソート
def BubbleSort(C,N):
flag = 1
while flag:
flag = 0
for j in range(N-1,0,-1):
if int(C[j][1:2]) < int(C[j-1][1:2]):
tmp = C[j]
C[j] = C[j-1]
C[j-1] = tmp
flag = 1
print((' '.join(C)))
#選択ソート
def SelectionSort(C,N):
for i in range(0,N,1):
minj = i
for j in range(i,N,1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((' '.join(C)))
#安定かどうかの判定
def isStable(inp, out,N):
for i in range(0,N):
for j in range(i+1,N):
for a in range(0,N):
for b in range(a+1,N):
# print("inp(i,j):",inp[i],inp[j],"out(b,a):",out[b],out[a]+"\n")
if int(inp[i][1]) == int(inp[j][1]) and inp[i] == out[b] and inp[j] == out[a]:
print('Not stable')
return
print('Stable')
#愚直に調べるパターン
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A,N)
isStable(A,Bubble_A,N)
SelectionSort(Selection_A,N)
isStable(A,Selection_A,N)
| #バブルソート
def BubbleSort(C,N):
for i in range (0,N,1):
for j in range(N-1,i,-1):
if int(C[j][1:2]) < int(C[j-1][1:2]):
tmp = C[j]
C[j] = C[j-1]
C[j-1] = tmp
print((' '.join(C)))
#選択ソート
def SelectionSort(C,N):
for i in range(0,N,1):
minj = i
for j in range(i,N,1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((' '.join(C)))
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A,N)
print("Stable")
SelectionSort(Selection_A,N)
flag = True
for Bubble,Selection in zip(Bubble_A,Selection_A):
if Bubble != Selection:
flag = False
if flag :
print("Stable")
else:
print("Not stable")
| p02261 |
class Card():
def __init__(self, card):
self.card = card
self.mark = card[0]
self.number = card[1]
def __lt__(self, other):
if not isinstance(other, Card):
return NotImplemented
return self.number < other.number
def __eq__(self, other):
if not isinstance(other, Card):
return NotImplemented
return self.mark == other.mark and self.number == other.number
def __repr__(self):
return '{}{}'.format(self.mark, self.number)
def BubbleSort(target):
ls = target.copy()
flag = 1
while flag:
flag = 0
for i in range(len(ls)-1, 0, -1):
if ls[i] < ls[i-1]:
ls[i], ls[i-1] = ls[i-1], ls[i]
flag = 1
print((' '.join(map(str, ls))))
return sorted(ls)
def SelectSort(target):
ls = target.copy()
for i in range(len(ls)):
minj = i
for j in range(i+1, len(ls)):
if ls[j] < ls[minj]:
minj = j
if ls[i] != ls[minj]:
ls[i], ls[minj] = ls[minj], ls[i]
print((' '.join(map(str, ls))))
return sorted(ls)
def judge(original, sorted_list):
if original == sorted_list:
print('Stable')
else:
print('Not stable')
_ = int(eval(input()))
l2 = [Card(i) for i in input().split()]
l2_sort = sorted(l2)
bubble = BubbleSort(l2)
judge(l2_sort, bubble)
select = SelectSort(l2)
judge(l2_sort, select)
| class Card():
def __init__(self, card):
self.card = card
self.mark = card[0]
self.number = card[1]
def __lt__(self, other):
if not isinstance(other, Card):
return NotImplemented
return self.number < other.number
def __repr__(self):
return '{}{}'.format(self.mark, self.number)
def BubbleSort(target):
ls = target.copy()
flag = 1
while flag:
flag = 0
for i in range(len(ls)-1, 0, -1):
if ls[i] < ls[i-1]:
ls[i], ls[i-1] = ls[i-1], ls[i]
flag = 1
print((' '.join(map(str, ls))))
return sorted(ls)
def SelectSort(target):
ls = target.copy()
for i in range(len(ls)):
minj = i
for j in range(i+1, len(ls)):
if ls[j] < ls[minj]:
minj = j
if ls[i] != ls[minj]:
ls[i], ls[minj] = ls[minj], ls[i]
print((' '.join(map(str, ls))))
return sorted(ls)
def judge(original, sorted_list):
if original == sorted_list:
print('Stable')
else:
print('Not stable')
_ = int(eval(input()))
l2 = [Card(i) for i in input().split()]
l2_sort = sorted(l2)
bubble = BubbleSort(l2)
judge(l2_sort, bubble)
select = SelectSort(l2)
judge(l2_sort, select)
| p02261 |
def bubbleSort( cards ):
n = len( cards )
for i in range( 0, n ):
for j in range( n-1 , i, -1 ):
if int( cards[j][1] ) < int( cards[ j-1 ][1] ):
cards[j], cards[ j-1 ] = cards[ j-1 ], cards[j]
print(( " ".join( map( str, cards ) ) ))
def selectionSort( cards ):
n = len( cards )
for i in range( 0, n ):
mini = i
for j in range( i , n ):
if int( cards[j][1] ) < int( cards[ mini ][1] ):
mini = j
if mini != i:
cards[i], cards[ mini ] = cards[ mini ], cards[i]
print(( " ".join( map( str, cards ) ) ))
n = int( eval(input( )) )
cards = input( ).split( " " )
cards2 = list( cards )
bubbleSort( cards )
print( "Stable" )
selectionSort( cards2 )
if " ".join( map( str, cards2 ) ) == " ".join( map( str, cards ) ):
print( "Stable" )
else:
print( "Not stable" ) | def bubbleSort( cards ):
n = len( cards )
for i in range( 0, n ):
for j in range( n-1 , i, -1 ):
if int( cards[j][1] ) < int( cards[ j-1 ][1] ):
cards[j], cards[ j-1 ] = cards[ j-1 ], cards[j]
print(( " ".join( map( str, cards ) ) ))
def selectionSort( cards ):
n = len( cards )
for i in range( 0, n ):
mini = i
for j in range( i , n ):
if int( cards[j][1] ) < int( cards[ mini ][1] ):
mini = j
if mini != i:
cards[i], cards[ mini ] = cards[ mini ], cards[i]
print(( " ".join( map( str, cards ) ) ))
n = int( input( ) )
cards = input( ).split( " " )
cards2 = list( cards )
bubbleSort( cards )
print( "Stable" )
selectionSort( cards2 )
if cards2 == cards:
print( "Stable" )
else:
print( "Not stable" ) | p02261 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
def maxValue(z:int, w:int, a:"List[int]", player:str) -> int:
if not a:
return abs(z-w)
if player == "X": ## playerXが操作する。価値がmaxになるように
value = 0
for i in range(len(a)):
value = max(maxValue(a[i],w,a[i+1:],"Y"),value)
else: ## yが操作,価値がminになるように
value = 10**9
for i in range(len(a)):
value = min(maxValue(z,a[i],a[i+1:],"X"),value)
return value
def solve(N: int, Z: int, W: int, a: "List[int]"):
print((maxValue(Z,W,a,"X")))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
Z = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, Z, W, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, Z: int, W: int, a: "List[int]"):
print((max(abs(a[N-1]-a[N-2]),abs(a[N-1]-W))))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
Z = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, Z, W, a)
if __name__ == '__main__':
main()
| p03550 |
import sys
input = sys.stdin.readline
from collections import *
sys.setrecursionlimit(2100)
def rec(sta, t):
if memo[sta][t]!=-1:
return memo[sta][t]
if t==0:
res = -10**18
for i in range(sta, N):
if i<N-1:
res = max(res, rec(i+1, 1))
else:
if sta==0:
res = max(res, abs(a[N-1]-W))
else:
res = max(res, abs(a[N-1]-a[sta-1]))
else:
res = 10**18
for i in range(sta, N):
if i<N-1:
res = min(res, rec(i+1, 0))
else:
if sta==0:
res = min(res, abs(a[N-1]-Z))
else:
res = min(res, abs(a[N-1]-a[sta-1]))
memo[sta][t] = res
return res
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
memo = [[-1]*2 for _ in range(N)]
print((rec(0, 0))) | import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0]*(2) for _ in range(N)]
for i in range(N-1, -1, -1):
if i==0:
dp[i][0] = abs(a[N-1]-W)
else:
dp[i][0] = abs(a[N-1]-a[i-1])
for j in range(i+1, N):
dp[i][0] = max(dp[i][0], dp[j][1])
if i==0:
dp[i][1] = abs(a[N-1]-Z)
else:
dp[i][1] = abs(a[N-1]-a[i-1])
for j in range(i+1, N):
dp[i][1] = min(dp[i][1], dp[j][0])
print((dp[0][0])) | p03550 |
import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
A = [W] + list(map(int, input().split()))
S = set(A)
GX = {s:[None]*N + [abs(A[N]-s)] for s in S}
GY = {s:[None]*N + [abs(A[N]-s)] for s in S}
minGX = {s:10**10 for s in S}
maxGY = {s:0 for s in S}
for k in range(N-1, -1, -1):
ak = A[k]
gx = max(GY[ak][k+1], maxGY[ak])
gy = min(GX[ak][k+1], minGX[ak])
for s in S:
GX[s][k] = gx
GY[s][k] = gy
for s in S:
maxGY[s] = max(GY[s][k+1], maxGY[s])
minGX[s] = min(GX[s][k+1], minGX[s])
print((GX[W][0])) | import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
A = [W] + list(map(int, input().split())) # A[0]=W, A[i]=ai
GX = [None]*N # GX[i] := YがA[i] を取った直後の状況から到達しうる最大のスコア
GY = [None]*N # GY[i] := XがA[i] を取った直後の状況から到達しうる最小のスコア
minGX = 10**20
maxGY = 0
for k in range(N-1, -1, -1):
GX[k] = max(abs(A[k]-A[N]), maxGY)
GY[k] = min(abs(A[k]-A[N]), minGX)
minGX = min(minGX, GX[k])
maxGY = max(maxGY, GY[k])
print((GX[0])) | p03550 |
import sys
sys.setrecursionlimit(10**6)
INF = 10**12
N, Z, W = list(map(int, input().split()))
a = [Z] + list(map(int, input().split()))
def rec(X,Y,i,count):# i枚目まで取った
if i == N:# 山札がないので得点計算して更新
return abs(X-Y)
else:
if count % 2 == 0:# 今はXのターン
tmp = -INF
for j in range(i+1,N+1):
tmp = max(tmp, rec(a[j], Y, j, count+1))
return tmp
else:# 今はYのターン
tmp = INF
for j in range(i+1,N+1):
tmp = min(tmp, rec(X, a[j], j, count+1))
return tmp
ans = rec(Z,W,0,0)
print(ans) | #!/usr/bin/env python3
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
if N == 1:
print((abs(a[0] - W)))
else:
print((max(abs(a[-1]-W), abs(a[-1]-a[-2])))) | p03550 |
import sys
from functools import lru_cache
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10**7)
def main():
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
"""
O(N^2)dpでも行けるそうです。以下写経：
https://atcoder.jp/contests/abc078/submissions/14886969
dpテーブルが訳分からなくなったら@lru_cache使うのが楽。
"""
@lru_cache(maxsize=None)
def dfs(turn, top, x, y): # turn: 0 => x, 1 => y
if top == N: return abs(x - y)
if turn == 1:
"""
yのターンは、top以降を取ってなるべくスコアが低くなるようなiを選ぶ
"""
ret = 10**9
for i in range(top, N): ret = min(ret, dfs(0, i + 1, x, A[i]))
return ret
else:
"""
xのターンは、top以降を取ってなるべくスコアが高くなるようなiを選ぶ
"""
ret = 0
for i in range(top, N): ret = max(ret, dfs(1, i + 1, A[i], y))
return ret
print((dfs(0, 0, Z, W)))
if __name__ == "__main__":
main()
| import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10**7)
def main():
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
"""
O(N^2)dpでも行けるそうです。以下写経：
https://atcoder.jp/contests/abc078/submissions/14886969
dp[turn][top]の２引数だけでいいのか、[x][y]の２引数も必要ではないかと思うが、
考えてみれば
dfs(0, top, x, y) = dfs(1, top', A[top], y)
= dfs(0, top", A[top], A[top'])
となるので、実はdfs(0, top, x, y)はtop = Nでない限りx, yに依らない。
"""
dp = [[-1] * N for _ in range(2)]
def dfs(turn, top, x, y): # turn: 0 => x, 1 => y
if top == N: return abs(x - y)
if dp[turn][top] != -1: return dp[turn][top]
if turn == 1:
"""
yのターンは、top以降を取ってなるべくスコアが低くなるようなiを選ぶ
"""
ret = 10**9
for i in range(top, N): ret = min(ret, dfs(0, i + 1, x, A[i]))
dp[turn][top] = ret
return ret
else:
"""
xのターンは、top以降を取ってなるべくスコアが高くなるようなiを選ぶ
"""
ret = 0
for i in range(top, N): ret = max(ret, dfs(1, i + 1, A[i], y))
dp[turn][top] = ret
return ret
print((dfs(0, 0, Z, W)))
if __name__ == "__main__":
main()
| p03550 |
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = abs(a[-1] - W)
if N > 1:
ans = max(ans, abs(a[-2] - a[-1]))
print(ans)
| import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = abs(a[-1] - W)
if N > 1:
ans = max(ans, abs(a[-2] - a[-1]))
print(ans)
| p03550 |
#!/usr/bin/env python3
#ABC78 D
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,z,w = LI()
a = LI()
que = deque(a)
tmp1 = que.popleft()
tmp2 = w
turn = 0
cnt = 0
while que:
if turn == 0:
if tmp1 <= que[0]:
tmp1 = que.popleft()
else:
turn = 1
else:
if tmp2 >= que[0]:
tmp2 = que.popleft()
else:
turn = 0
cnt += 1
if cnt > n:
print((abs(tmp1 - tmp2)))
print((abs(tmp1-tmp2)))
| #!/usr/bin/env python3
#ABC78 D
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,z,w = LI()
a = LI()
if n == 1:
print((abs(a[-1] - w)))
else:
print((max(abs(a[-1]-w),abs(a[-2]-a[-1]))))
| p03550 |
n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
xp = [0]*(n)
yp = [10000000000]*(n)
xp[0] = abs(a[n-1]-w)
for i in reversed(list(range(n))):
for j in range(i+1,n):
xp[i] = max(xp[i], yp[j])
yp[i] = min(yp[i], xp[j])
xp[i] = max(xp[i], abs(a[i-1]-a[n-1]))
yp[i] = min(yp[i], abs(a[i-1]-a[n-1]))
print((xp[0])) | n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
if n == 1:
print((abs(a[0]-w)))
else:
print((max(abs(a[n-1]-w),abs(a[n-1]-a[n-2])))) | p03550 |
import sys
sys.setrecursionlimit(10 ** 5)
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
a.reverse()
a += [W] #最後にYさんの手札を加えておく
dp_T = [-1] * (N + 1) #Xの手番
dp_F = [-1] * (N + 1) #Yの手番
def calc(n, flag): #n: 残りの山の枚数 flag: ターンの管理
#既に計算済みの場合その値を返す
# if flag == True and dp_T[n] != -1:
# return dp_T[n]
# if flag == False and dp_F[n] != -1:
# return dp_F[n]
if n == 1: #山の残り枚数が1枚の時 -->引くしかなく得点が決定
return abs(a[0] - a[n])
if flag == True: #Xのターン-->大きくしたい
tmp = 0
for i in range(1, n + 1): #自分が引く枚数 = 1 ~ n枚
if i == n: #残り枚数0で相手に渡す = 自分が最後の1枚を引く -->相手の手札が決まっているから得点が決定
tmp = max(tmp, abs(a[0]-a[n]))
else: #残り枚数が1枚以上ある時、手番は相手に変える
tmp = max(tmp, calc(n-i, not flag))
dp_T[n] = tmp
return tmp
if flag == False: #Yのターン-->小さくしたい
tmp = 10 ** 10 #最大値
for i in range(1, n + 1): #自分が引く枚数 = 1 ~ n枚
if i == n - 1: #残り0枚で相手に渡す
tmp = min(tmp, abs(a[0] - a[n]))
else:
tmp = min(tmp, calc(n-i, not flag))
dp_F[n] = tmp
return tmp
print((calc(N, True)))
| N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
print((max(abs(a[N-1] - W), abs(a[N-1] - a[N - 2])))) | p03550 |
N,Z,W=list(map(int,input().split()))
A=list(map(int,input().split()))
A.append(Z)
A.append(W)
dp=[[[0 for i in range(0,2)] for j in range(0,N+2)] for k in range(0,N+1)]
for i in range(0,N+2):
dp[N-1][i][0]=abs(A[N-1]-A[i])
dp[N-1][i][1]=abs(A[N-1]-A[i])
for i in range(1,N):
for j in range(0,N+2):
I=N-1-i
dp[I][j][0]=max(dp[I+1][I][1],dp[I+1][j][0],abs(A[N-1]-A[j]))
dp[I][j][1]=min(dp[I+1][I][0],dp[I+1][j][1],abs(A[N-1]-A[j]))
print((dp[0][N+1][0])) | N,Z,W=list(map(int,input().split()))
A=list(map(int,input().split()))
A.append(Z)
A.append(W)
dpx=[[0 for j in range(0,N+2)] for k in range(0,N+1)]
dpy=[[0 for j in range(0,N+2)] for k in range(0,N+1)]
for i in range(0,N+2):
dpx[N-1][i]=abs(A[N-1]-A[i])
dpy[N-1][i]=abs(A[N-1]-A[i])
for i in range(1,N):
for j in range(0,N+2):
I=N-1-i
dpx[I][j]=max(dpy[I+1][I],dpx[I+1][j],abs(A[N-1]-A[j]))
dpy[I][j]=min(dpx[I+1][I],dpy[I+1][j],abs(A[N-1]-A[j]))
print((dpx[0][N+1])) | p03550 |
N,Z,W=list(map(int,input().split()))
a=list(map(int,input().split()))
INF=10**19
dp=[[0]*2 for i in range(N+1)]
for i in range(N-1,-1,-1):
dp[i][0]=-INF
if i: Y=a[i-1]
else: Y=W
dp[i][0]=max(dp[i][0],abs(Y-a[N-1]))
for j in range(i+1,N): dp[i][0]=max(dp[i][0],dp[j][1])
dp[i][1]=INF
if i: X=a[i-1]
else: X=Z
dp[i][1]=min(dp[i][1],abs(X-a[N-1]))
for j in range(i+1,N): dp[i][1]=min(dp[i][1],dp[j][0])
print((dp[0][0]))
| N,Z,W=list(map(int,input().split()))
a=list(map(int,input().split()))
if N==1:
print((abs(a[0]-W)))
else:
print((max(abs(a[-1]-W),abs(a[-1]-a[-2]))))
| p03550 |
import sys
INF = 10 ** 9
MOD = 10 ** 9 + 7
from collections import deque
sys.setrecursionlimit(100000000)
input = sys.stdin.readline
MAXN = 2005
dp0 = [[-1] * MAXN for _ in range(MAXN)]
dp1 = [[-1] * MAXN for _ in range(MAXN)]
def dfs(i,j,p,z,w,a,n):
if p == 0:
if dp0[i][j] != -1:
return dp0[i][j]
if i == n:
if j == 0:
return abs(w - a[-1])
return abs(a[j -1] - a[-1])
ans = 0
for k in range(i,n):
ans = max(ans,dfs(k + 1,k,1,z,w,a,n))
if i == 1:
ans = max(ans,abs(a[-1] - w))
else:
ans = max(ans,abs(a[-1]- a[i - 1]))
dp0[i][j] = ans
return ans
elif p == 1:
if dp1[i][j] != -1:
return dp1[i][j]
if i == n:
if j == 0:
return abs(z - a[-1])
return abs(a[j - 1] - a[-1])
ans = INF
for k in range(i,n):
ans = min(ans,dfs(k + 1,k,0,z,w,a,n))
if i == 1:
ans = min(ans,abs(a[-1] - z))
else:
ans = min(ans,abs(a[-1] - a[i - 1]))
dp1[i][j] = ans
return ans
def main():
n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
ans = dfs(1,0,0,z,w,a,n)
print(ans)
if __name__=='__main__':
main() | import sys
INF = 10 ** 9
MOD = 10 ** 9 + 7
from collections import deque
sys.setrecursionlimit(100000000)
input = sys.stdin.readline
def main():
n,z,w = list(map(int,input().split()))
a = list(map(int,input().split()))
if n == 1:
ans = abs(w - a[0])
else:
ans = max(abs(w - a[-1]),abs(a[-1] - a[-2]))
print(ans)
if __name__=='__main__':
main() | p03550 |
# -*- coding: utf-8 -*-
"""
参考：https://kimiyuki.net/writeup/algo/atcoder/arc-085-d/
https://atcoder.jp/contests/abc078/submissions/3854338
・ミニマックス法
・メモ化再帰
・メモの持ち方をシンプルにした版
"""
import sys
from collections import defaultdict
# 再帰呼び出しの回数制限(デフォルト1000)
sys.setrecursionlimit(10 ** 9)
N, Z, W = list(map(int, input().split()))
aN = list(map(int, input().split()))
# メモ[手番][残り山札数] = このルートでのmax,min
memo = [[0] * (N+1) for _ in range(2)]
def dfs(turn, rest, x, y):
if rest == 0:
return abs(x - y)
# 先手番
if turn % 2 == 0:
# 既に見た局面ならメモの内容を返す
if memo[0][rest]:
return memo[0][rest]
mx = -1
for i in range(N-rest, N):
x = aN[i]
idx = i+1
mx = max(dfs(turn+1, N-idx, x, y), mx)
# ここより深い所を探し終わったので結果をメモする
memo[0][rest] = mx
return mx
# 後手番
else:
if memo[1][rest]:
return memo[1][rest]
mn = float('inf')
for i in range(N-rest, N):
y = aN[i]
idx = i+1
mn = min(dfs(turn+1, N-idx, x, y), mn)
memo[1][rest] = mn
return mn
print((dfs(0, N, Z, W)))
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc085/editorial.pdf
・公式解、O(1)の一発解法
・思いつけばいいけど、そういつも上手くいかないよね…。
"""
N, Z, W = list(map(int, input().split()))
aN = list(map(int, input().split()))
if N == 1:
print((abs(aN[0] - W)))
else:
# Xが最後まで引くか、最後から2番目まで引くか
print((max(abs(aN[-1] - W), abs(aN[-2] - aN[-1]))))
| p03550 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, Z, W = MAP()
A = [W] + LIST()
memo = list3d(N+1, N+1, 2, -1)
def rec(cur, prev, turn):
if cur == N:
return abs(A[cur] - A[prev])
if memo[cur][prev][turn] != -1:
return memo[cur][prev][turn]
if turn == 0:
res = 0
for nxt in range(cur+1, N+1):
res = max(res, rec(nxt, cur, 1 - turn))
else:
res = INF
for nxt in range(cur+1, N+1):
res = min(res, rec(nxt, cur, 1 - turn))
memo[cur][prev][turn] = res
return res
print((rec(0, -1, 0)))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, Z, W = MAP()
A = [W] + LIST()
memo = list2d(N+1, 2, -1)
def rec(cur, prev, turn):
if cur == N:
return abs(A[cur] - A[prev])
if memo[cur][turn] != -1:
return memo[cur][turn]
if turn == 0:
res = 0
for nxt in range(cur+1, N+1):
res = max(res, rec(nxt, cur, 1 - turn))
else:
res = INF
for nxt in range(cur+1, N+1):
res = min(res, rec(nxt, cur, 1 - turn))
memo[cur][turn] = res
return res
print((rec(0, 0, 0)))
| p03550 |
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
INF = float("inf")
import sys
sys.setrecursionlimit(10000)
a = []
memo = []
def dfs(no, i):
global memo, a
if memo[no][i]:
return memo[no][i]
ans = abs(a[-1] - a[i])
for j in range(i + 1, len(a) - 1):
nex = dfs(1 - no, j + 1)
# X
if no == 0:
ans = max(ans, nex)
# Y
else:
ans = min(ans, nex)
memo[no][i] = ans
return ans
def solve2(N, Z, W):
global a, memo
a = [Z, W] + a
memo = [[None] * len(a) for _ in range(2)]
return dfs(0, 1)
def solve(N, Z, W):
global a
ans = abs(a[-1] - W)
if len(a) > 1:
ans = max(ans, abs(a[-2] - a[-1]))
return ans
def main():
global a
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
print((solve2(N, Z, W)))
if __name__ == '__main__':
main()
| from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
INF = float("inf")
import sys
sys.setrecursionlimit(10000)
a = []
memo = []
# 相手がi番目を引いたときにだせる最大/最小のスコア
def dfs(turn, i):
global memo, a
if memo[turn][i] != -1:
return memo[turn][i]
ans = 0 if turn == 0 else INF
for j in range(i + 1, len(a)):
if j == len(a) - 1:
s = abs(a[j] - a[i])
else:
s = abs(dfs(1 - turn, j))
# X
if turn == 0:
ans = max(ans, s)
# Y
else:
ans = min(ans, s)
memo[turn][i] = ans
return ans
def solve2(N, Z, W):
global a, memo
a = [W] + a
memo = [[-1] * len(a) for _ in range(2)]
return dfs(0, 0)
def solve(N, Z, W):
global a
ans = abs(a[-1] - W)
if len(a) > 1:
ans = max(ans, abs(a[-2] - a[-1]))
return ans
def main():
global a
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
print((solve2(N, Z, W)))
if __name__ == '__main__':
main()
| p03550 |
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
INF = float("inf")
import sys
sys.setrecursionlimit(10000)
a = []
memo = []
# 相手がi番目を引いたときにだせる最大/最小のスコア
def dfs(turn, i):
global memo, a
if memo[turn][i] != -1:
return memo[turn][i]
ans = 0 if turn == 0 else INF
for j in range(i + 1, len(a)):
if j == len(a) - 1:
s = abs(a[j] - a[i])
else:
s = abs(dfs(1 - turn, j))
# X
if turn == 0:
ans = max(ans, s)
# Y
else:
ans = min(ans, s)
memo[turn][i] = ans
return ans
def solve2(N, Z, W):
global a, memo
a = [W] + a
memo = [[-1] * len(a) for _ in range(2)]
return dfs(0, 0)
def solve(N, Z, W):
global a
ans = abs(a[-1] - W)
if len(a) > 1:
ans = max(ans, abs(a[-2] - a[-1]))
return ans
def main():
global a
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
print((solve2(N, Z, W)))
if __name__ == '__main__':
main()
| from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def main():
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
if N == 1:
print((abs(A[0] - W)))
else:
print((max(abs(A[-1] - W), abs(A[-1] - A[-2]))))
if __name__ == '__main__':
main()
| p03550 |
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
if N > 1:
print((max(abs(W-a[-1]), abs(a[-1] - a[-2]))))
else:
print((abs(W - a[0])))
| N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
if N == 1:
print((abs(a[0] - W)))
else:
print((max(abs(a[-1]-W), abs(a[-1] - a[-2]))))
| p03550 |
import sys
sys.setrecursionlimit(10**7)
from functools import lru_cache
def main():
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
dp = [0] * N
@lru_cache(maxsize=None)
def hoge(z, w, n, turn):
if n == 0:
return abs(z - w)
if turn:
return max(hoge(A[N - 1 - i], w, i, not turn) for i in range(n))
else:
return min(hoge(z, A[N - 1 - i], i, not turn) for i in range(n))
return hoge(Z, W, N, True)
print((main()))
| def main():
N, Z, W = list(map(int, input().split()))
A = list(map(int, input().split()))
if N == 1:
return abs(A[-1] - W)
return max(abs(A[-1] - W), abs(A[-1] - A[-2]))
print((main()))
| p03550 |
# tenka1-2017-beginnerB - Different Distribution
def main():
N, *AB = list(map(int, open(0).read().split()))
A = [(i, j) for i, j in zip(*[iter(AB)] * 2)]
A.sort()
ans = sum(A[-1])
print(ans)
if __name__ == "__main__":
main() | # tenka1-2017-beginnerB - Different Distribution
def main():
N, *AB = list(map(int, open(0).read().split()))
A = max(list(zip(*[iter(AB)] * 2)))
ans = sum(A)
print(ans)
if __name__ == "__main__":
main() | p03588 |
def main():
N=int(eval(input()))
AB=[0]*N
for i in range(N):
AB[i]=list(map(int,input().split()))
AB.sort()
count=AB[-1][0]
while AB[-1][1]-1>=0:
AB[-1][1]-=1
count+=1
print(count)
if __name__=="__main__":
main() | def main():
N=int(eval(input()))
AB=[0]*N
for i in range(N):
AB[i]=list(map(int,input().split()))
AB.sort()
count=AB[-1][0]
count+=AB[-1][1]
print(count)
if __name__=="__main__":
main() | p03588 |
n=int(eval(input()))
a=[]
b=[]
for _ in range(n):
a_ele, b_ele=list(map(int, input().split()))
a.append(a_ele)
b.append(b_ele)
a_min=min(a)
a_max=max(a)
print(((b[a.index(max(a))]-1)+(max(a)+1))) | n=int(eval(input()))
a=[]
b=[]
for _ in range(n):
a_ele, b_ele=list(map(int, input().split()))
a.append(a_ele)
b.append(b_ele)
print(((b[a.index(max(a))]-1)+(max(a)+1))) | p03588 |
N = int(eval(input()))
#A = [list(map(int,input().split())) for i in range(N)]
#print (A)
def bubble_sort(arr1,arr2,n):
for i in range(n):
for j in range(0,n-i-1):
if arr1[j] > arr1[j+1]:
arr1[j],arr1[j+1] = arr1[j+1],arr1[j]
arr2[j],arr2[j+1] = arr2[j+1],arr2[j]
A = []
B = []
for i in range(N):
tmp1,tmp2 = list(map(int,input().split()))
A.append(tmp1)
B.append(tmp2)
bubble_sort(A,B,N)
base = A[-1]
addition = B[-1]
print((base + addition))
| N = int(eval(input()))
#A = [list(map(int,input().split())) for i in range(N)]
#print (A)
def bubble_sort(arr1,arr2,n):
for i in range(n):
for j in range(0,n-i-1):
if arr1[j] > arr1[j+1]:
arr1[j],arr1[j+1] = arr1[j+1],arr1[j]
arr2[j],arr2[j+1] = arr2[j+1],arr2[j]
A = []
B = []
max_key = 0
max_value = 0
for i in range(N):
tmp1,tmp2 = list(map(int,input().split()))
A.append(tmp1)
B.append(tmp2)
if tmp1 > max_key:
max_key = tmp1
max_value = tmp2
print((max_value+max_key))
#bubble_sort(A,B,N)
#base = A[-1]
#addition = B[-1]
#print(base + addition)
| p03588 |
n = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
ans = max(ans, a[i][0])
if ans == a[i][0]:
ind = i
print((ans + a[ind][1])) | n = int(eval(input()))
a = [list(map(int, input().split())) for _ in range(n)]
print((sum(max(a)))) | p03588 |
from operator import add
n = int(eval(input()))
print((min(add(*list(map(int, input().split()))) for _ in range(n))))
| print((min(sum(map(int,input().split()))for _ in range(int(eval(input()))))))
| p03588 |
N = int(eval(input()))
A = []
B = []
for i in range(N):
a,b = list(map(int,input().split()))
A.append(a)
B.append(b)
sum = max(A) - min(A) + 1
sum += min(A) - 1
sum += min(B)
print(sum) | N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
a,b = list(map(int,input().split()))
A[i] = a
B[i] = b
print((max(A) + min(B))) | p03588 |
n = int(eval(input()))
a = sorted([list(map(int, input().split())) for _ in range(n)])
cnt = a[0][0] - 1 + n + a[-1][1]
for i in range(n - 1):
cnt += min(a[i + 1][0] - a[i][0], a[i][1] - a[i + 1][1]) - 1
print(cnt) | n = int(eval(input()))
a = sorted([list(map(int, input().split())) for _ in range(n)])
print((sum(a[-1]))) | p03588 |
n=int(eval(input()))
ab = []
for _ in range(n):
a, b = (int(x) for x in input().split())
ab.append([a, b])
ab = sorted(ab, key=lambda x: -x[0])
print((ab[0][0]+ab[0][1])) | N = int(eval(input()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort(reverse=True)
print((sum(AB[0]))) | p03588 |
def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
N = I()
AB = [LI() for _ in range(N)]
T_AB = list(zip(*AB))
ans = max(T_AB[0])
ans += T_AB[1][T_AB[0].index(max(T_AB[0]))]
print(ans)
| def I(): return int(eval(input()))
def LI(): return list(map(int,input().split()))
N = I()
AB = [LI() for _ in range(N)]
ans,max = 0,0
for x in AB:
a,b = x[0],x[1]
if a>max:
max = a
ans = a+b
print(ans)
| p03588 |
n = int(eval(input()))
a = [[]]*n
for i in range(n):
a[i] = list(map(int, input().split()))
a.sort()
print((a[-1][0]+a[-1][1])) | def main():
n = int(eval(input()))
a = [[]]*n
for i in range(n):
a[i] = list(map(int, input().split()))
a.sort()
print((a[-1][0]+a[-1][1]))
main() | p03588 |
N = int(eval(input()))
list1 = []
ind = 0
cnt = 0
top = 1
bot = 0
for i in range(N):
L = list(map(int, input().split()))
list1.append(L)
list1 = sorted(list1)
if list1[0][0]!=top:
while(top!=list1[0][0]):
cnt+=1
top+=1
if list1[-1][1]!=bot:
bot = list1[-1][1]
while(bot!=0):
cnt+=1
bot-=1
for i in range(N-1):
err = abs(list1[i][0]-list1[i+1][0])
err1 = list1[i][1]-list1[i+1][1]
if err != 1:
cnt += min(err-1, err1-1)
print((cnt+N)) | N = int(eval(input()))
list1 = []
max1 = 0
for i in range(N):
L = list(map(int, input().split()))
if max1 < L[0]:
max1 = L[0]
ans = sum(L)
print(ans) | p03588 |
def main():
n = int(eval(input()))
ab = [] # type:[[int]]
for i in range(n):
ab.append([int(x) for x in input().split()])
a, b = max(ab, key=lambda x: x[0])
print((a + b))
if __name__ == "__main__":
main() | def main():
n = int(eval(input()))
max_a, max_b = 0, 0 # type:int
for _ in range(n):
a, b = input().split()
a = int(a)
if max_a < a:
max_a = a
max_b = int(b)
print((max_a + max_b))
if __name__ == "__main__":
main() | p03588 |
def main():
n = int(eval(input()))
max_a, max_b = 0, 0 # type:int
for _ in range(n):
a, b = list(map(int, input().split(' ')))
# a = int(a)
if max_a < a:
max_a = a
max_b = b # int(b)
print((max_a + max_b))
if __name__ == "__main__":
main() | import sys
from sys import stdin
input = stdin.readline
def main():
n = int(eval(input()))
max_a, max_b = 0, 0 # type:int
for _ in range(n):
a, b = input().split()
a = int(a)
if max_a < a:
max_a = a
max_b = int(b)
print((max_a + max_b))
if __name__ == "__main__":
main() | p03588 |
print((min(eval('eval(input().replace(" ","+")),'*int(eval(input())))))) | print((min(sum(map(int,input().split()))for _ in[0]*int(eval(input()))))) | p03588 |
print((min(eval('sum(map(int,input().split())),'*int(eval(input())))))) | print((min(sum(map(int,input().split()))for _ in[0]*int(eval(input()))))) | p03588 |
def slove():
import sys
input = sys.stdin.readline
n = int(input().rstrip('\n'))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
ab.sort()
print((ab[-1][0] + ab[-1][1]))
if __name__ == '__main__':
slove()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
ab = [list(map(int, readline().split())) for _ in range(n)]
ab.sort()
print(((ab[-1][0] - ab[0][0] + 1) + (ab[0][0] - 1) + (ab[-1][1])))
if __name__ == '__main__':
solve()
| p03588 |
N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
src.sort()
print((src[-1][0] + src[-1][1])) | N = int(eval(input()))
AB = [tuple(map(int,input().split())) for i in range(N)]
a,b = max(AB)
print((a+b)) | p03588 |
#!/usr/bin/env python3
N = int(eval(input()))
ab = [[0, 0] for _ in range(N)]
for i in range(N):
ab[i] = list(map(int, input().split()))
ab.sort(key=lambda x:x[0])
ans = ab[0][0]
for i in range(N)[1::]:
ans += min(ab[i][0] - ab[i-1][0], ab[i-1][1] - ab[i][1])
ans += ab[-1][1]
print(ans)
| #!/usr/bin/env python3
N = int(eval(input()))
A = [0] * N
B = [0] * N
for i in range(N):
A[i], B[i] = list(map(int, input().split()))
idx = A.index(max(A))
print((A[idx] + B[idx]))
| p03588 |
N=int(eval(input()))
AB=[]
for i in range(N):
AB.append(list(map(int,input().split())))
A=[]
B=[]
for i in range(N):
A.append(AB[i][0])
B.append(AB[i][1])
for i in range(N):
if B[i]==min(B):
bmin=i
print((A[bmin]+B[bmin])) | N=int(eval(input()))
AB=[]
for i in range(N):
AB.append(list(map(int,input().split())))
a=AB[0][1]
b=0
for i in range(1,N):
if AB[i][1]<a:
a=AB[i][1]
b=i
print((a+AB[b][0])) | p03588 |
n = int(eval(input()))
al = []
bl = []
for _ in range(n):
a, b = list(map(int, input().split()))
al.append(a)
bl.append(b)
ans = max(al) + bl[al.index(max(al))]
print(ans)
| n = int(eval(input()))
ans1 = ans2 = 0
for _ in range(n):
a, b = list(map(int, input().split()))
if ans1 < a:
ans1 = a
ans2 = b
print((ans1 + ans2))
| p03588 |
n = int(eval(input()))
bottom = 10 ** 9+7
person = 0
for _ in range(n):
a, b = list(map(int, input().split()))
if b < bottom:
person = max(person, a)
bottom = b
ans = person + bottom
print(ans)
| import sys
input = sys.stdin.readline
N = int(eval(input()))
ab = [tuple(map(int, input().split())) for _ in range(N)]
ab.sort()
ans = ab[-1][0] - ab[0][0] + 1
ans += ab[0][0] - 1
ans += ab[-1][1]
print(ans)
| p03588 |
# cf16-finalA - Where's Snuke?
from string import ascii_uppercase
def main():
h, w = list(map(int, input().rstrip().split()))
A = [input().rstrip().split() for _ in range(h)]
S = ascii_uppercase
for i in range(h):
for j in range(w):
if A[i][j] == "snuke":
print(S[j], i + 1, sep="")
return
if __name__ == "__main__":
main()
| # cf16-finalA - Where's Snuke?
from string import ascii_uppercase
def main():
H, W, *S = open(0).read().split()
H, W, abc = int(H), int(W), ascii_uppercase
for i, s in enumerate(S):
if s == "snuke":
print(abc[i % W], i // W + 1, sep="")
return
if __name__ == "__main__":
main()
| p03909 |
h,w=list(map(int,input().split()))
s=[input().split() for i in range(h)]
al=[chr(i) for i in range(65,65+26)]
for i in range(h):
if 'snuke' in s[i]:
print((al[s[i].index('snuke')]+str(i+1))) | al=[chr(ord('A') + i) for i in range(26)]
H,W=list(map(int,input().split()))
S= [list(input().split()) for _ in range(H)]
for i in range(H):
for j in range(W):
if S[i][j]=="snuke":
ans=al[j]+str(i+1)
print(ans) | p03909 |
h, w = list(map(int, input().split()))
S = [input().split() for i in range(h)]
for i in range(h):
for j in range(w):
if S[i][j] == "snuke":
print("%s%d" % ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"[j], i+1)) | def read2():
return list(map(int, input().split()))
def read1():
return input().split()
h, w = read2()
for i in range(h):
s = read1()
for j in range(w):
if s[j] == "snuke":
print("%c%d" % (65 + j, i+1))
| p03909 |
h, w = list(map(int, input().split()))
s = []
for i in range(h):
S = list(input().split())
s.append(S)
for i in range(h):
for j in range(w):
if s[i][j] == "snuke":
l = chr(ord("A") + j)
print((l + str(i + 1)))
exit() | h, w = list(map(int, input().split()))
for i in range(h):
s = input().split()
for j in range(w):
if s[j] == "snuke":
l = chr(ord("A") + j)
print((l + str(i + 1)))
exit() | p03909 |
import sys
input = sys.stdin.readline
MOD = 10**6+3
q = int(eval(input()))
fact = [1]*(MOD+1)
for i in range(1, MOD+1):
fact[i] = fact[i-1]*i%MOD
finv = [pow(f, MOD-2, MOD) for f in fact]
for _ in range(q):
x, d, n = list(map(int, input().split()))
if d == 0:
ans = pow(x, n, MOD)
else:
x_div = x*pow(d, MOD-2, MOD)%MOD
if x_div+n-1 > MOD:
ans = 0
else:
if x_div+n-1 >= MOD:
ans = 0
else:
ans = fact[x_div+n-1]*finv[x_div-1]%MOD*pow(d, n, MOD)%MOD
print(ans)
| import sys
input = sys.stdin.readline
MOD = 10**6+3
q = int(eval(input()))
fact = [1]*(MOD+1)
for i in range(1, MOD+1):
fact[i] = fact[i-1]*i%MOD
for _ in range(q):
x, d, n = list(map(int, input().split()))
if d == 0:
ans = pow(x, n, MOD)
else:
x_div = x*pow(d, MOD-2, MOD)%MOD
if x_div+n-1 > MOD:
ans = 0
else:
if x_div+n-1 >= MOD:
ans = 0
else:
f = fact[x_div+n-1]
fi = pow(fact[x_div-1], MOD-2, MOD)
ans = f*fi%MOD*pow(d, n, MOD)%MOD
print(ans) | p03027 |
M=1000003
f=[1]
for i in range(1,M):f.append(f[i-1]*i%M)
for _ in'_'*int(eval(input())):
x,d,n=list(map(int,input().split()))
t=x*pow(d,M-2,M)%M
print(([pow(x,n,M),(M-n>=t>0)*1and f[t+n-1]*pow(f[t-1],M-2,M)*pow(d,n,M)%M][d>0])) | M,f=1000003,[1]
for i in range(1,M):f.append(f[i-1]*i%M)
for _ in'_'*int(eval(input())):x,d,n=list(map(int,input().split()));t=x*pow(d,M-2,M)%M;print(([pow(x,n,M),(M-n>=t>0)*1and f[t+n-1]*pow(f[t-1],M-2,M)*pow(d,n,M)%M][d>0])) | p03027 |
p,M,f=pow,1000003,[1]
for i in range(1,M):f.append(f[i-1]*i%M)
for _ in'_'*eval(input()):x,d,n=list(map(int,input().split()));t=x*p(d,M-2,M)%M;print([p(x,n,M),M/(t+n)*t and f[t+n-1]*p(f[t-1],M-2,M)*p(d,n,M)%M][d>0]) | p,M=pow,1000003
f=[1]*M
for i in range(1,M):f[i]=f[i-1]*i%M
for _ in'_'*eval(input()):x,d,n=list(map(int,input().split()));t=x*p(d,M-2,M)%M;print([p(x,n,M),M/(t+n)*t and f[t+n-1]*p(f[t-1],M-2,M)*p(d,n,M)%M][d>0]) | p03027 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
MOD = 1000003
class ModInt(object):
def __init__(self, num, mod):
self.num = num
self.mod = mod
if self.num >= self.mod:
self.num %= self.mod
def inv(self):
a, b, u, v = self.mod, self.num, 0, 1
while b != 0:
t = a // b
a -= t * b
u -= t * v
a, b = b, a
u, v = v, u
return ModInt(u % self.mod, self.mod)
def __add__(self, n):
raise NotImplementedError()
def __sub__(self, n):
raise NotImplementedError()
def __mul__(self, n):
return ModInt((self.num * int(n)) % self.mod, self.mod)
def __div__(self, n):
raise NotImplementedError()
def __pow__(self, n):
v = 1
m = self.num
while n != 0:
if n & 1 != 0:
v = (v * m) % self.mod
m = (m * m) % self.mod
n = n >> 1
return ModInt(v, self.mod)
def __int__(self):
return self.num
def __str__(self):
return str(self.num)
def main():
facs = [None] * MOD
facs[0] = ModInt(1, MOD)
for i in range(1, MOD):
facs[i] = facs[i - 1] * i
for _ in range(int(eval(input()))):
x, d, n = list(map(int, input().split()))
if d == 0:
print((ModInt(x, MOD) ** n))
continue
x = int(ModInt(x, MOD) * ModInt(d, MOD).inv())
if x + n - 1 >= MOD:
print((0))
continue
v = facs[x + n - 1]
if x != 0:
v *= facs[x - 1].inv()
if d != 1:
v *= (ModInt(d, MOD) ** n)
print(v)
if __name__ == '__main__':
main()
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
MOD = 1000003
def inv(x, m):
y, u, v = m, 1, 0
while y != 0:
t = x // y
x -= t * y
u -= t * v
x, y = y, x
u, v = v, u
return u % m
def main():
facs = [None] * MOD
invs = [None] * MOD
facs[0] = 1
for i in range(1, MOD):
facs[i] = facs[i - 1] * i % MOD
invs[-1] = facs[-1]
for i in range(MOD - 1, 0, -1):
invs[i - 1] = invs[i] * i % MOD
for _ in range(int(eval(input()))):
x, d, n = list(map(int, input().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
x = x * inv(d, MOD) % MOD
if x + n - 1 >= MOD:
print((0))
continue
v = facs[x + n - 1]
if x != 0:
v = v * invs[x - 1] % MOD
if d != 1:
v = v * pow(d, n, MOD) % MOD
print(v)
if __name__ == '__main__':
main()
| p03027 |
# https://atcoder.jp/contests/m-solutions2019/submissions/5741430
from operator import mul
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
def mod_mul(x, y):
return mul(x, y) % MOD
fact = [1]
for n in range(1, MOD):
fact.append(mod_mul(fact[-1], n))
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = mod_mul(x, inv(d))
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print((mod_mul(mod_mul(fact[xd + n - 1], inv(fact[xd - 1])), dn)))
| # https://atcoder.jp/contests/m-solutions2019/submissions/5741430
from operator import mul
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
def mod_mul(x, y):
return mul(x, y) % MOD
fact = [1]
for n in range(1, MOD):
fact.append(mod_mul(fact[-1], n))
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = mod_mul(x, inv(d))
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print((mod_mul(mod_mul(fact[xd + n - 1], inv(fact[xd - 1])), dn)))
| p03027 |
# https://atcoder.jp/contests/m-solutions2019/submissions/5741430
from operator import mul
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
def mod_mul(x, y):
return mul(x, y) % MOD
fact = [1]
for n in range(1, MOD):
fact.append(mod_mul(fact[-1], n))
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = mod_mul(x, inv(d))
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print((mod_mul(mod_mul(fact[xd + n - 1], inv(fact[xd - 1])), dn)))
| # https://atcoder.jp/contests/m-solutions2019/submissions/5741430
from functools import reduce
from operator import mul
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
def mod_mul(x, y):
return mul(x, y) % MOD
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * inv(d)) % MOD
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print((reduce(mod_mul, (fact[xd + n - 1], inv(fact[xd - 1]), dn))))
| p03027 |
# https://atcoder.jp/contests/m-solutions2019/submissions/5741430
from functools import reduce
from operator import mul
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = inv(fact[-1])
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * inv(d)) % MOD
if xd == 0:
print((0))
continue
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print(((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD))
| # https://atcoder.jp/contests/m-solutions2019/submissions/5741430
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = inv(fact[-1])
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * inv(d)) % MOD
if xd == 0:
print((0))
continue
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print(((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD))
| p03027 |
# https://atcoder.jp/contests/m-solutions2019/submissions/5741430
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
def inv(n):
return pow(n, MOD - 2, MOD)
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = inv(fact[-1])
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * inv(d)) % MOD
if xd == 0:
print((0))
continue
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print(((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD))
| # https://atcoder.jp/contests/m-solutions2019/submissions/5741430
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = pow(fact[-1], MOD - 2, MOD)
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD - 2, MOD)) % MOD
if xd == 0:
print((0))
continue
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print(((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD))
| p03027 |
# https://atcoder.jp/contests/m-solutions2019/submissions/5741430
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = pow(fact[-1], MOD - 2, MOD)
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(eval(input()))
for _ in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD - 2, MOD)) % MOD
if xd == 0:
print((0))
continue
if MOD - xd < n:
print((0))
continue
dn = pow(d, n, MOD)
print(((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD))
| # https://atcoder.jp/contests/m-solutions2019/submissions/5741430
import sys
input = sys.stdin.readline
MOD = 10 ** 6 + 3
fact = [1]
for n in range(1, MOD):
fact.append((fact[-1] * n) % MOD)
# d>1 の数列を d=1 となる数列に変換する
# MODの倍数を含む数列の積は0になるので,
# MODの倍数を含まない区間の積が計算できればよい
# そのような区間の右端はMOD-1であり,fact[MOD-1]が計算できればよい
inv_fact = [-1] * MOD
inv_fact[MOD - 1] = pow(fact[-1], MOD - 2, MOD)
for n in range(MOD - 2, -1, -1):
inv_fact[n] = ((inv_fact[n + 1] * (n + 1)) % MOD)
# inv_factは,inv(n!)にn,n-1,...を掛けるイメージ
Q = int(input())
ans = []
for _ in range(Q):
x, d, n = map(int, input().split())
if x == 0:
ans.append(0)
continue
if d == 0:
ans.append(pow(x, n, MOD))
continue
xd = (x * pow(d, MOD - 2, MOD)) % MOD
if xd == 0:
ans.append(0)
continue
if MOD - xd < n:
ans.append(0)
continue
dn = pow(d, n, MOD)
ans.append((((fact[xd + n - 1] * inv_fact[xd - 1]) % MOD) * dn) % MOD)
print(*ans, sep='\n')
| p03027 |
import sys
input = sys.stdin.readline
q = int(eval(input()))
p=1000003
for j in range(q):
x,d,n=(int(i) for i in input().split())
cnt=0
data1=1
for i in range(p-2):
cnt+=1
data1*=d
data1=data1%p
data2=(x*data1)%p
data3=1
for i in range(n):
data3*=(data2+i)
data3=data3%p
for i in range(n):
data3*=d
data3=data3%p
print(data3) | import sys
input = sys.stdin.readline
q = int(eval(input()))
p=1000003
flist=[1 for i in range(p)]
for i in range(1,p):
flist[i]=flist[i-1]*i%p
for i in range(q):
x,d,n=(int(i) for i in input().split())
if d==0:
ans=pow(x,n,p)
else:
x=x*pow(d,p-2,p)%p
if p<=x+n-1:
ans=0
else:
ans=pow(d,n,p)*flist[x+n-1]*pow(flist[x-1],p-2,p)%p
print((ans%p)) | p03027 |
MOD = 10**6+3
def main():
# preprocess
fac = [1, 1]
f_inv = [1, 1]
inv = [0, 1]
for i in range(2, MOD+1):
fac.append((fac[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD//i)) % MOD)
f_inv.append((f_inv[-1] * inv[-1]) % MOD)
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, input().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
xd = ((x % MOD) * pow(d, MOD-2, MOD)) % MOD
if xd == 0 or xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * f_inv[xd - 1] % MOD))
if __name__ == "__main__":
main() | MOD = 10**6+3
def main():
# preprocess
fac = [1, 1]
f_inv = [1, 1]
inv = [0, 1]
for i in range(2, MOD+1):
fac.append((fac[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD//i)) % MOD)
f_inv.append((f_inv[-1] * inv[-1]) % MOD)
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, input().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD-2, MOD)) % MOD
if xd == 0 or xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * f_inv[xd-1] % MOD))
if __name__ == "__main__":
main() | p03027 |
MOD = 10**6+3
def main():
# preprocess
fac = [1, 1]
f_inv = [1, 1]
inv = [0, 1]
for i in range(2, MOD+1):
fac.append((fac[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD//i)) % MOD)
f_inv.append((f_inv[-1] * inv[-1]) % MOD)
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, input().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD-2, MOD)) % MOD
if xd == 0 or xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * f_inv[xd-1] % MOD))
if __name__ == "__main__":
main() | MOD = 10**6+3
def main():
# preprocess
fac = [1, 1]
for i in range(2, MOD+1):
fac.append((fac[-1] * i) % MOD)
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, input().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD-2, MOD)) % MOD
if xd == 0 or xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * pow(fac[xd-1], MOD-2, MOD) % MOD))
if __name__ == "__main__":
main() | p03027 |
####################
# AC: ms (PyPy)
####################
def main():
MOD = 10**6+3
# preprocess
fac = [None] * (MOD+1)
fac[0] = fac[1] = 1
for i in range(2, MOD+1):
fac[i] = (fac[i-1] * i) % MOD
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, input().split()))
if x == 0:
print((0))
continue
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD-2, MOD)) % MOD
if xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * pow(fac[xd-1], MOD-2, MOD) % MOD))
if __name__ == "__main__":
main() | import sys
def main():
MOD = 10**6+3
# preprocess
fac = [None] * (MOD+1)
fac[0] = fac[1] = 1
for i in range(2, MOD+1):
fac[i] = (fac[i-1] * i) % MOD
Q = int(eval(input()))
for i in range(Q):
x, d, n = list(map(int, sys.stdin.readline().split()))
if d == 0:
print((pow(x, n, MOD)))
continue
xd = (x * pow(d, MOD-2, MOD)) % MOD
if xd == 0 or xd + (n-1) >= MOD:
print((0))
continue
print((pow(d, n, MOD) * fac[xd+(n-1)] * pow(fac[xd-1], MOD-2, MOD) % MOD))
if __name__ == "__main__":
main() | p03027 |
Q = int(eval(input()))
mod = 10**6+3
arr = []
for i in range(Q):
x, d, n = list(map(int, input().split()))
arr.append([x, d, n])
P = [1]*(mod+1)
for i in range(mod):
P[i+1] = P[i]*(i+1)%mod
def rev(a):
return pow(a,mod-2,mod)
def f(x, d, n):
if d == 0:
return pow(x, n, mod)
else:
d_r = rev(d)
if d_r * x % mod == 0:
return 0
elif (d_r*x%mod+n-1) >= mod:
return 0
else:
return (P[d_r*x%mod+n-1] * rev(P[d_r*x%mod-1])%mod)*pow(d,n,mod)%mod
for i in range(Q):
print((f(arr[i][0], arr[i][1], arr[i][2])))
| Q = int(eval(input()))
mod = 10**6+3
arr = []
for i in range(Q):
arr.append(list(map(int, input().split())))
P = [1]*(mod+1)
for i in range(mod):
P[i+1] = P[i]*(i+1)%mod
def rev(a):
return pow(a,mod-2,mod)
def f(x, d, n):
if d == 0:
return pow(x, n, mod)
else:
d_r = rev(d)
xdr = d_r * x % mod
if xdr == 0:
return 0
elif (xdr+n-1) >= mod:
return 0
else:
return (P[xdr+n-1] * rev(P[xdr-1])%mod) * pow(d,n,mod)%mod
for i in range(Q):
print((f(arr[i][0], arr[i][1], arr[i][2]))) | p03027 |
class Combination:
'''
計算量：階乗・逆元テーブルの作成O(N)
nCkを求めるO(1)
'''
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [pow(self.fact[i] ,MOD - 2 ,MOD) for i in range(n + 1)]
self.MOD = MOD
def factorial(self, k):
'''k!を求める'''
return self.fact[k]
def inverse_factorial(self, k):
'''k!の逆元を求める'''
return self.inv_fact[k]
def combination(self, k, r):
'''kCrを求める'''
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
q = int(eval(input()))
MOD = 10**6 + 3
comb = Combination(MOD, MOD)
for i in range(q):
a1, d, n = list(map(int, input().split()))
if d == 0:
print((pow(a1, n, MOD)))
continue
syoko = a1 * (comb.inv_fact[d] * comb.fact[d-1])
syoko %= MOD
if syoko ==0 or syoko + (n-1) >= MOD:
print((0))
else:
ans = pow(d, n, MOD) * comb.fact[syoko+(n-1)] * comb.inv_fact[syoko-1]
print((ans % MOD)) | class Combination:
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [0] * (n + 1)
self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in reversed(list(range(n))):
self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
q = int(eval(input()))
info = [list(map(int, input().split())) for i in range(q)]
MOD = 1000003
comb = Combination(MOD, MOD)
for x, d, n in info:
if d == 0:
ans = pow(x, n, MOD)
print(ans)
continue
ans = pow(d, n, MOD)
x_d = x * pow(d, MOD - 2, MOD) % MOD
# x_d * (x_d + 1) * (x_d + 2) * ... *(x_d + n - 1)
tmp = comb.factorial(min(x_d + n - 1, MOD)) * pow(comb.factorial(x_d - 1), MOD - 2, MOD)
ans *= tmp
print((ans % MOD))
| p03027 |
from itertools import*
import math
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = float("inf")
mod = 1000003
from functools import reduce
import sys
sys.setrecursionlimit(10**7)
input=sys.stdin.readline
Max = mod-1
#二項係数とその逆元テーブルを作る前処理
fac = [0]*(Max)
finv = [0]*(Max)
inv = [0]*(Max)
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,Max):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
#O(1)でmod計算した組合せ数を計算
def Comb(n,r):
if n < r:
return 0
if n < 0 or r < 0 :
return 0
return fac[n]*(finv[r]*finv[n-r]%mod)%mod
def pow_mod(x,n):
if n==0: return 1
if n%2:return x*pow_mod(x,n-1)%mod
a = pow_mod(x,n//2)
return a*a%mod
Q = int(eval(input()))
def query(x,d,n):
if x == 0:
return 0
if d == 0:
return pow_mod(x,n)
k = (x*inv[d])%mod
if k+n-1 >= mod:
return 0
ans = fac[k+n-1]*finv[k-1]%mod
ans *= pow(d,n)
ans %= mod
return ans
for i in range(Q):
x,d,n = list(map(int,input().split()))
print((query(x,d,n))) | from itertools import*
import math
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = float("inf")
mod = 1000003
from functools import reduce
import sys
sys.setrecursionlimit(10**7)
Max = mod
#二項係数とその逆元テーブルを作る前処理
fac = [0]*(Max)
finv = [0]*(Max)
inv = [0]*(Max)
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,Max):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
#O(1)でmod計算した組合せ数を計算
def Comb(n,r):
if n < r:
return 0
if n < 0 or r < 0 :
return 0
return fac[n]*(finv[r]*finv[n-r]%mod)%mod
Q = int(eval(input()))
def query(x,d,n):
if x == 0:
return 0
if d == 0:
return pow(x,n,mod)
k = (x*inv[d])%mod
if k+n-1 >= mod:
return 0
ans = fac[k+n-1]*finv[k-1]%mod
ans *= pow(d,n,mod)
ans %= mod
return ans
for i in range(Q):
x,d,n = list(map(int,input().split()))
print((query(x,d,n))) | p03027 |
import sys
input = sys.stdin.readline
mod=10**6+3
n_max=mod
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[i+1]=pow(F[i+1],mod-2,mod)
for i in range(int(eval(input()))):
x,d,n=list(map(int,input().split()))
print((((d**n)*F[(x*pow(d,mod-2,mod)+n-1)%mod]*FI[(x*pow(d,mod-2,mod)-1)%mod])%mod))
| import sys
input = sys.stdin.readline
mod=10**6+3
n_max=mod
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[i+1]=pow(F[i+1],mod-2,mod)
for i in range(int(eval(input()))):
x,d,n=list(map(int,input().split()))
if d==0:
print((pow(x,n,mod)))
else:
s=(x*pow(d,mod-2,mod)-1)%mod
if s+n>=mod:
print((0))
else:
g=(x*pow(d,mod-2,mod)+n-1)%mod
print((((pow(d,n,mod))*F[g]*FI[s])%mod))
| p03027 |
h,w= list(map(int,input().split()))
ans = h*w
if h % 3 == 0 or h % 3 == 0:
print((0))
exit()
for i in range(1,w):
H1, H2= h//2, -(-h//2)
check = max(h*i,H2*(w-i),H1*(w-i))
check2 = min(h*i,H1*(w-i),H2*(w-i))
ans = min(ans,abs(check-check2))
for i in range(1,h):
w1,w2 = w//2, -(-w//2)
check = max(w*i,w1*(h-i),w2*(h-i))
check2 = min(w*i,w1*(h-i),w2*(h-i))
ans = min(ans,abs(check-check2))
print((min(ans,h,w))) | h,w = list(map(int,input().split()))
ans = float("Inf")
if h % 3 == 0 or w % 3 == 0:
print((0))
exit()
for i in range(1,h):
a = (h-i)*(w//2)
b = (h-i)*-(-w//2)
ans = min(ans,abs(max(i*w,a,b)-min(i*w,a,b)))
for i in range(1,w):
a = (w-i)*(h//2)
b = (w-i)*-(-h//2)
ans = min(ans,abs(max(i*h,a,b)-min(i*h,a,b)))
print((min(ans,h,w))) | p03713 |
import math
H, W = list(map(int, input().split()))
ans = 10**10
for h in range(1, H):
A = h * W
#残りを横に割る
B = W*math.ceil((H-h)/2)
C = H*W - A - B
tmp = max([A,B,C]) - min([A,B,C])
ans = min(ans, tmp)
#残りを縦に割る
B = (H-h)*math.ceil(W/2)
C = H*W - A - B
tmp = max([A,B,C]) - min([A,B,C])
ans = min(ans, tmp)
# 縦横入れ替え
H, W = W, H
for h in range(1, H):
A = h * W
#残りを横に割る
B = W*math.ceil((H-h)/2)
C = H*W - A - B
tmp = max([A,B,C]) - min([A,B,C])
ans = min(ans, tmp)
#残りを縦に割る
B = (H-h)*math.ceil(W/2)
C = H*W - A - B
tmp = max([A,B,C]) - min([A,B,C])
ans = min(ans, tmp)
print(ans) | H, W = list(map(int, input().split()))
if H % 3 == 0 or W % 3 == 0:
print((0))
exit()
ans = H*W
# 高さを変えて調べる
for h in range(1, H+1):
a = h*W
#残りを高さで割る場合
b = ((H-h)//2) * W
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
#残りを幅で割る場合
b = (H-h) * (W//2)
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
# 幅を変えて調べる
for w in range(1, W+1):
a = H*w
#残りを高さで割る場合
b = (W-w) * (H//2)
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
#残りを幅で割る場合
b = ((W-w)//2) * H
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
print(ans) | p03713 |
H, W = list(map(int, input().split()))
if H % 3 == 0 or W % 3 == 0:
print((0))
exit()
ans = H*W
# 高さを変えて調べる
for h in range(1, H+1):
a = h*W
#残りを高さで割る場合
b = ((H-h)//2) * W
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
#残りを幅で割る場合
b = (H-h) * (W//2)
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
# 幅を変えて調べる
for w in range(1, W+1):
a = H*w
#残りを高さで割る場合
b = (W-w) * (H//2)
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
#残りを幅で割る場合
b = ((W-w)//2) * H
c = H*W - a - b
ans = min(ans, max([a,b,c]) - min([a,b,c]))
print(ans) |
H,W = list(map(int, input().split()))
ans = H * W
# 1つめは縦を1ずつ増やしていく場合
for h in range(1, H):
a = h * W
# 残りについて、縦で分割する場合
b = ((H - h) // 2) * W
c = H * W - a - b
ans = min(ans, max(a,b,c) - min(a,b,c))
# 残りについて、横で分割する場合
b = (H - h) * (W // 2)
c = H * W - a - b
ans = min(ans, max(a,b,c) - min(a,b,c))
# 1つめは横を1ずつ増やしていく場合
for w in range(1, W):
a = w * H
# 残りについて、縦で分割する場合
b = (W - w) * (H//2)
c = H * W - a - b
ans = min(ans, max(a,b,c) - min(a,b,c))
# 残りについて、横で分割する場合
b = ((W - w) // 2) * H
c = H * W - a - b
ans = min(ans, max(a,b,c) - min(a,b,c))
print(ans) | p03713 |
H, W = list(map(int, input().split()))
ans = float('inf')
for h in range(1,H):
S = [h * W]
w = W // 2
S += [(H-h) * w]
S += [(H-h) * (W-w)]
ans = min(ans,max(S)-min(S))
for h in range(1,H):
S = [h * W]
hb = (H-h) // 2
S += [hb * W]
S += [(H-h-hb) * W]
ans = min(ans,max(S)-min(S))
for w in range(1,W):
S = [H * w]
h = H // 2
S += [h * (W-w)]
S += [(H-h) * (W-w)]
ans = min(ans,max(S)-min(S))
for w in range(1,W):
S = [w * H]
wb = (W-w) // 2
S += [wb * H]
S += [(W-w-wb) * H]
ans = min(ans,max(S)-min(S))
print(ans) | H, W = list(map(int, input().split()))
S = H * W
ans = S
for h in range(1,H):
s1 = h * W
s2 = W // 2 * (H-h)
s3 = S-s1-s2
ans = min(ans,max(s1,s2,s3)-min(s1,s2,s3))
s2 = (H-h) // 2 * W
s3 = S-s1-s2
ans = min(ans,max(s1,s2,s3)-min(s1,s2,s3))
for w in range(1,W):
s1 = H * w
s2 = H // 2 * (W-w)
s3 = S-s1-s2
ans = min(ans,max(s1,s2,s3)-min(s1,s2,s3))
s2 = (W-w) // 2 * H
s3 = S-s1-s2
ans = min(ans,max(s1,s2,s3)-min(s1,s2,s3))
print(ans) | p03713 |
import math
H,W = list(map(int,input().split()))
if H%3==0 or W%3==0:
print((0))
elif H==2 and W==2:
print((1))
else:
def cal(x,y):
return max(x*y,(W-x)*y,(H-y)*W) - min(x*y,(W-x)*y,(H-y)*W)
x1,x2 = math.floor(W/2),math.ceil(W/2)
y1,y2 = math.floor((2*H)/3),math.ceil((2*H)/3)
ans1 = min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))
W,H = H,W
x1,x2 = math.floor(W/2),math.ceil(W/2)
y1,y2 = math.floor((2*H)/3),math.ceil((2*H)/3)
ans2 = min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))
if H ==2 or W == 2:
print((min(ans1,ans2,max(H,W))))
else:
print((min(ans1,ans2,H,W))) | import math
H,W = list(map(int,input().split()))
if H%3==0 or W%3==0:
print((0))
elif H==2 and W==2:
print((1))
else:
def cal2(h,w):
x1,x2 = math.floor(w/2),math.ceil(w/2)
y1,y2 = math.floor((2*h)/3),math.ceil((2*h)/3)
def cal(x,y):
return max(x*y,(w-x)*y,(h-y)*w) - min(x*y,(w-x)*y,(h-y)*w)
return min(cal(x1,y1),cal(x2,y1),cal(x1,y2),cal(x2,y2))
if H==2 or W ==2:
print((min(cal2(H,W),cal2(W,H),max(H,W))))
else:
print((min(cal2(H,W),cal2(W,H),H,W))) | p03713 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.