input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def cnt(i, oya_i):
if len(ko[i]) == 1 and oya_i:
return 1
if memo[i][oya_i] != 0:
return memo[i][oya_i]
re = 1
for ko_i in ko[i]:
if ko_i == oya_i: continue
re *= (cnt(ko_i, i) + 1)
memo[i][oya_i] = re
return re
def f(n, m):
for _ in range(n - 1):
x, y = list(map(int, input().split()))
ko[x] += [y]
ko[y] += [x]
for start_i in range(1, n + 1):
print((cnt(start_i, 0) % m))
n, m = list(map(int, input().split()))
memo = [[0] * (n + 1) for _ in range(n + 1)]
ko = [[] for _ in range(n + 1)]
f(n, m)
| import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
def cnt(i, oya_i):
if len(ko[i]) == 1 and oya_i:
return 1
if memo[i][oya_i] != 0:
return memo[i][oya_i]
re = 1
for ko_i in ko[i]:
if ko_i == oya_i: continue
re *= (cnt(ko_i, i) + 1)
memo[i][oya_i] = re = re % m
return re
def f(n, m):
for _ in range(n - 1):
x, y = list(map(int, input().split()))
ko[x] += [y]
ko[y] += [x]
for start_i in range(1, n + 1):
print((cnt(start_i, 0) % m))
n, m = list(map(int, input().split()))
memo = [[0] * (n + 1) for _ in range(n + 1)]
ko = [[] for _ in range(n + 1)]
f(n, m)
| p03181 |
import sys
from functools import reduce
from operator import mul
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[0] = -1
par[p] -1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
def topological_sort_tree(E, r):
Q = [r]
L = []
visited = set([r])
while Q:
vn = Q.pop()
L.append(vn)
for vf in E[vn]:
if vf not in visited:
visited.add(vf)
Q.append(vf)
return L
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N, M = map(int, input().split())
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, sys.stdin.readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
P = getpar(Edge, 0)
L = topological_sort_tree(Edge, 0)
C = getcld(P)
dp1 = [1]*N
for l in L[N-1:0:-1]:
p = P[l]
dp1[p] = (dp1[p]*(dp1[l]+1)) % M
dp2 = [1]*N
dp2[0] = dp1[0]
info = [0]*(N+1)
vmul = [reduce(mul, [dp1[j]+1 for j in C[i]], 1) for i in range(N)]
for l in L[1:]:
p = P[l]
pp = P[p]
res = vmul[p]//(dp1[l]+1) % M
res = res*(1+info[pp]) % M
dp2[l] = dp1[l]*(res+1) % M
info[p] = res % M
print(*dp2, sep = '\n')
| import sys
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[0] = -1
par[p] -1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
def topological_sort_tree(E, r):
Q = [r]
L = []
visited = set([r])
while Q:
vn = Q.pop()
L.append(vn)
for vf in E[vn]:
if vf not in visited:
visited.add(vf)
Q.append(vf)
return L
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N, M = map(int, input().split())
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, sys.stdin.readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
P = getpar(Edge, 0)
L = topological_sort_tree(Edge, 0)
C = getcld(P)
dp1 = [1]*N
for l in L[N-1:0:-1]:
p = P[l]
dp1[p] = (dp1[p]*(dp1[l]+1)) % M
dp2 = [1]*N
dp2[0] = dp1[0]
info = [0]*(N+1)
vidx = [0]*N
vmull = [None]*N
vmulr = [None]*N
for i in range(N):
Ci = C[i]
res = [1]
for j, c in enumerate(Ci, 1):
vidx[c] = j
res.append(res[-1] * (1+dp1[c]) % M)
vmulr[i] = res + [1]
res = [1]
for c in Ci[::-1]:
res.append(res[-1] * (1+dp1[c]) % M)
vmull[i] = [1] + res[::-1]
for l in L[1:]:
p = P[l]
pp = P[p]
vi = vidx[l]
res = vmulr[p][vi-1] * vmull[p][vi+1] % M
res = res*(1+info[pp]) % M
dp2[l] = dp1[l]*(res+1) % M
info[p] = res % M
print(*dp2, sep = '\n')
| p03181 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n, MOD = map(int,input().split())
E = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = map(int,input().split())
u -= 1; v -= 1
E[u].append(v)
E[v].append(u)
deg = [len(E[v]) - 1 for v in range(n)]
deg[0] += 1
topological_sort = []
parent = [None] * n
stack = [(~0, -1), (0, -1)] # (v, p)
while stack:
v, p = stack.pop()
if v >= 0:
parent[v] = p
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
if deg[~v] == 0:
topological_sort.append(~v)
deg[p] -= 1
# tree DP
dp = [None] * n
for v in topological_sort:
res = 1
for nv in E[v]:
if nv == parent[v]:
continue
res = res * (dp[nv] + 1) % MOD
dp[v] = res
# rerooting
def rerooting(v, p):
if v == -1 or p == -1:
return
# 初めは計算量を無視
p_res = 1
for nv in E[p]:
if nv == v:
continue
p_res = p_res * (dp[nv] + 1) % MOD
dp[p] = p_res
v_res = 1
for nv in E[v]:
v_res = v_res * (dp[nv] + 1) % MOD
dp[v] = v_res
ans = [None] * n
ans[0] = dp[0]
stack = [(~0, -1), (0, -1)]
while stack:
v, p = stack.pop()
if v >= 0:
rerooting(v, p)
ans[v] = dp[v]
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
rerooting(p, ~v)
def rerooting(v, p):
if v == -1 or p == -1:
return
# 初めは計算量を無視
p_res = 1
for nv in E[p]:
if nv == v:
continue
p_res = p_res * (dp[nv] + 1) % MOD
dp[p] = p_res
v_res = 1
for nv in E[v]:
v_res = v_res * (dp[nv] + 1) % MOD
dp[v] = v_res
print(*ans, sep = '\n')
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n, MOD = map(int,input().split())
if n == 1:
print(1)
return
E = [[] for _ in range(n)]
nv_to_idx = [{} for _ in range(n)]
for _ in range(n - 1):
u, v = map(int,input().split())
u -= 1; v -= 1
nv_to_idx[u][v] = len(E[u])
nv_to_idx[v][u] = len(E[v])
E[u].append(v)
E[v].append(u)
deg = [len(E[v]) - 1 for v in range(n)]
deg[0] += 1
topological_sort = []
parent = [None] * n
stack = [(~0, -1), (0, -1)] # (v, p)
while stack:
v, p = stack.pop()
if v >= 0:
parent[v] = p
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
if deg[~v] == 0:
topological_sort.append(~v)
deg[p] -= 1
# tree DP
dp = [None] * n
for v in topological_sort:
res = 1
for nv in E[v]:
if nv == parent[v]:
continue
res = res * (dp[nv] + 1) % MOD
dp[v] = res
# rerooting
def rerooting(v, p):
# rerooting を先に済ませる
if p != -1 and v != -1:
idx = nv_to_idx[p][v]
p_res = 1
if idx > 0:
p_res *= cum_left[p][idx - 1]
if idx < len(E[p]) - 1:
p_res *= cum_right[p][idx + 1]
dp[p] = p_res % MOD
if v == -1:
return
# monoid に対する cumulative sum を計算
if cum_left[v] is None:
left = [(dp[nv] + 1) % MOD for nv in E[v]]
right = [(dp[nv] + 1) % MOD for nv in E[v]]
k = len(E[v])
for i in range(k - 1):
left[i + 1] *= left[i]
left[i + 1] %= MOD
for i in range(k - 1, 0, -1):
right[i - 1] *= right[i]
right[i - 1] %= MOD
cum_left[v] = left
cum_right[v] = right
dp[v] = cum_left[v][-1]
ans = [None] * n
ans[0] = dp[0]
stack = [(~0, -1), (0, -1)]
cum_left = [None] * n
cum_right = [None] * n
while stack:
v, p = stack.pop()
if v >= 0:
rerooting(v, p)
ans[v] = dp[v]
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
rerooting(p, ~v)
print(*ans, sep = '\n')
resolve()
| p03181 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n, MOD = map(int,input().split())
if n == 1:
print(1)
return
E = [[] for _ in range(n)]
nv_to_idx = [{} for _ in range(n)]
for _ in range(n - 1):
u, v = map(int,input().split())
u -= 1; v -= 1
nv_to_idx[u][v] = len(E[u])
nv_to_idx[v][u] = len(E[v])
E[u].append(v)
E[v].append(u)
# tree DP
dp = [1] * n
deg = [len(E[v]) - 1 for v in range(n)]
deg[0] += 1
stack = [(0, -1)]
while stack:
v, p = stack.pop()
if v >= 0:
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
if deg[~v] == 0:
dp[p] = dp[p] * (dp[~v] + 1) % MOD
deg[p] -= 1
# rerooting
def rerooting(v, p):
# p-rooted -> dp[p] を v-rooted に modify
if p != -1:
idx = nv_to_idx[p][v]
p_res = 1
if idx > 0:
p_res *= cum_left[p][idx - 1]
if idx < len(E[p]) - 1:
p_res *= cum_right[p][idx + 1]
dp[p] = p_res % MOD
# monoid に対する cumulative sum を計算
if cum_left[v] is None:
left = [(dp[nv] + 1) % MOD for nv in E[v]]
right = [(dp[nv] + 1) % MOD for nv in E[v]]
k = len(E[v])
for i in range(k - 1):
left[i + 1] *= left[i]
left[i + 1] %= MOD
for i in range(k - 1, 0, -1):
right[i - 1] *= right[i]
right[i - 1] %= MOD
cum_left[v] = left
cum_right[v] = right
dp[v] = cum_left[v][-1]
ans = [None] * n
stack = [(0, -1)]
cum_left = [None] * n
cum_right = [None] * n
while stack:
v, p = stack.pop()
if v >= 0:
rerooting(v, p)
ans[v] = dp[v]
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
rerooting(p, ~v)
print(*ans, sep = '\n')
resolve()
| import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7 # 998244353
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n, MOD = map(int,input().split())
E = [[] for _ in range(n)]
nv_to_idx = [{} for _ in range(n)]
for _ in range(n - 1):
u, v = map(int,input().split())
u -= 1; v -= 1
nv_to_idx[u][v] = len(E[u])
nv_to_idx[v][u] = len(E[v])
E[u].append(v)
E[v].append(u)
# tree DP
dp = [1] * n
deg = [len(E[v]) - 1 for v in range(n)]
deg[0] += 1
stack = [(0, -1)]
while stack:
v, p = stack.pop()
if v >= 0:
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
if deg[~v] == 0:
dp[p] = dp[p] * (dp[~v] + 1) % MOD
deg[p] -= 1
# rerooting
def rerooting(v, p):
# p-rooted -> dp[p] を v-rooted に modify
if p != -1:
idx = nv_to_idx[p][v]
dp[p] = cum_left[p][idx] * cum_right[p][idx + 1] % MOD
# monoid に対する cumulative sum を計算
if cum_left[v] is None:
k = len(E[v])
left = [1] * (k + 1)
right = [1] * (k + 1)
for i in range(k):
left[i + 1] = left[i] * (dp[E[v][i]] + 1) % MOD
for i in range(k - 1, -1, -1):
right[i] = right[i + 1] * (dp[E[v][i]] + 1) % MOD
cum_left[v] = left
cum_right[v] = right
# dp[v] を v-rooted に modify
dp[v] = cum_left[v][-1]
ans = [None] * n
stack = [(0, -1)]
cum_left = [None] * n
cum_right = [None] * n
while stack:
v, p = stack.pop()
if v >= 0:
rerooting(v, p)
ans[v] = dp[v]
for nv in E[v]:
if nv == p:
continue
stack.append((~nv, v))
stack.append((nv, v))
else:
rerooting(p, ~v)
print(*ans, sep = '\n')
resolve()
| p03181 |
import sys
from collections import deque
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
Edge = [[] for _ in range(N)]
for _ in range(N-1):
x, y = list(map(int, input().split()))
Edge[x-1].append(y-1)
Edge[y-1].append(x-1)
Par = [-1] * N
Son = [[] for _ in range(N)]
SonNum = [0] * N
q = deque()
for s in Edge[0]: q.append((s, 0))
while q:
nn, pn = q.popleft()
Par[nn] = pn
Son[pn].append(nn)
SonNum[pn] += 1
for ne in Edge[nn]:
if ne != pn: q.append((ne, nn))
DP = [1 for i in range(N)]
visited = [0] * N
for i, s in enumerate(SonNum):
if s == 0 and Par[i] > -1:
q.append((Par[i], 1))
DP[i] = 1
while q:
nn, v = q.popleft()
DP[nn] *= v + 1
visited[nn] += 1
if visited[nn] == SonNum[nn] and nn > 0: q.append((Par[nn], DP[nn]))
for s in Son[0]: q.append((s, DP[0]))
while q:
nn, v = q.popleft()
DP[nn] *= v // (DP[nn] + 1) + 1
for s in Son[nn]: q.append((s, DP[nn]))
for i, d in enumerate(DP): print((d % M))
return 0
if __name__ == "__main__":
solve() | import sys
from collections import deque
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
Edge = [[] for _ in range(N)]
for _ in range(N-1):
x, y = list(map(int, input().split()))
Edge[x-1].append(y-1)
Edge[y-1].append(x-1)
Par = [-1] * N
Son = [[] for _ in range(N)]
SonNum = [0] * N
q = deque()
for s in Edge[0]: q.append((s, 0))
while q:
nn, pn = q.popleft()
Par[nn] = pn
Son[pn].append(nn)
SonNum[pn] += 1
for ne in Edge[nn]:
if ne != pn: q.append((ne, nn))
DP = [1 for i in range(N)]
visited = [0] * N
for i, s in enumerate(SonNum):
if s == 0 and i > 0: q.append((Par[i], 1))
while q:
nn, v = q.popleft()
DP[nn] *= v + 1
visited[nn] += 1
if visited[nn] == SonNum[nn] and nn > 0: q.append((Par[nn], DP[nn]))
for s in Son[0]: q.append((s, DP[0]))
while q:
nn, v = q.popleft()
DP[nn] *= (v // (DP[nn] + 1) + 1) % M
for s in Son[nn]: q.append((s, DP[nn]))
for i, d in enumerate(DP): print((d % M))
return 0
if __name__ == "__main__":
solve() | p03181 |
import sys,os,io
input = sys.stdin.readline
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
parent[start] = -1
while stack:
v = stack[-1]
marker = 0
for u in edge[v]:
if u==parent[v]:
continue
if parent[u]==N: #子へ降ろす
marker = 1
parent[u]=v
stack.append(u)
else: #子から吸い上げる
ans[v] *= ans[u]+1
ans[v] %=M
if marker==0:
stack.pop()
return
def dfs2(start):
stack = [start]
parent = [N]*N
parent[start] = -1
p_value = [0]*N
while stack:
v = stack.pop()
cum1 = [1]*(len(edge[v])+1)
cum2 = [1]*(len(edge[v])+1)
for i,u in enumerate(edge[v]):
if u==parent[v]:
cum1[i+1] = cum1[i]*(p_value[v]+1)%M
else:
cum1[i+1] = cum1[i]*(ans[u]+1)%M
for i,u in enumerate(edge[v][::-1]):
if u==parent[v]:
cum2[-i-2] = cum2[-i-1]*(p_value[v]+1)%M
else:
cum2[-i-2] = cum2[-i-1]*(ans[u]+1)%M
for i,u in enumerate(edge[v]):
if u==parent[v]:
continue
parent[u]=v
p_value[u] = cum1[i]*cum2[i+1]%M
ans[u] *= (p_value[u]+1)
ans[u] %= M
stack.append(u)
ans[v] %= M
return
ans = [1]*N
dfs(0)
dfs2(0)
print(*ans, sep='\n')
| import sys,os,io
# input = sys.stdin.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for i in range(N-1):
a,b = list(map(int, input().split()))
edge[a-1].append(b-1)
edge[b-1].append(a-1)
def dfs(start):
stack = [start]
parent = [N]*N
parent[start] = -1
while stack:
v = stack[-1]
marker = 0
for u in edge[v]:
if u==parent[v]:
continue
if parent[u]==N: #子へ降ろす
marker = 1
parent[u]=v
stack.append(u)
else: #子から吸い上げる
ans[v] *= ans[u]+1
ans[v] %=M
if marker==0:
stack.pop()
return
def dfs2(start):
stack = [start]
parent = [N]*N
parent[start] = -1
p_value = [0]*N
while stack:
v = stack.pop()
cum1 = [1]*(len(edge[v])+1)
cum2 = [1]*(len(edge[v])+1)
for i,u in enumerate(edge[v]):
if u==parent[v]:
cum1[i+1] = cum1[i]*(p_value[v]+1)%M
else:
cum1[i+1] = cum1[i]*(ans[u]+1)%M
for i,u in enumerate(edge[v][::-1]):
if u==parent[v]:
cum2[-i-2] = cum2[-i-1]*(p_value[v]+1)%M
else:
cum2[-i-2] = cum2[-i-1]*(ans[u]+1)%M
for i,u in enumerate(edge[v]):
if u==parent[v]:
continue
parent[u]=v
p_value[u] = cum1[i]*cum2[i+1]%M
ans[u] *= (p_value[u]+1)
ans[u] %= M
stack.append(u)
ans[v] %= M
return
ans = [1]*N
dfs(0)
dfs2(0)
print(*ans, sep='\n')
| p03181 |
n,m,*t=list(map(int,open(0).read().split()))
e=[[]for _ in range(n)]
for a,b in zip(*[iter(t)]*2):
e[a-1]+=b-1,
e[b-1]+=a-1,
o=[]
s=[0]
f=[1]*n
for v in s:
o+=v,
f[v]=0
t=[]
for w in e[v]:
if f[w]:
s+=w,
t+=w,
e[v]=t
dp1=[0]*n
c=[[]for _ in range(n)]
for v in o[::-1]:
c1,c2=[1],[1]
for w in e[v]:
c1+=c1[-1]*(dp1[w]+1)%m,
for w in e[v][::-1]:
c2+=c2[-1]*(dp1[w]+1)%m,
dp1[v]=c1[-1]
c[v]=c1,c2[-2::-1]
dp2=[0]*n
dp2[0]=1
for v in o:
t=dp2[v]
for w,c1,c2 in zip(e[v],*c[v]):
dp2[w]=(t*c1*c2+1)%m
for dp1,dp2 in zip(dp1,dp2):
print((dp1*dp2%m)) | n,m,*t=list(map(int,open(0).read().split()))
e=[[]for _ in range(n)]
for a,b in zip(*[iter(t)]*2):
e[a-1]+=b-1,
e[b-1]+=a-1,
o=[]
s=[0]
f=[1]*n
for v in s:
o+=v,
f[v]=0
t=[]
for w in e[v]:
if f[w]:
s+=w,
t+=w,
e[v]=t
dp1=[0]*n
c=[[]for _ in range(n)]
for v in o[::-1]:
x,y=[1],[1]
for w in e[v]:x+=x[-1]*(dp1[w]+1)%m,
for w in e[v][::-1]:y+=y[-1]*(dp1[w]+1)%m,
dp1[v]=x[-1]
c[v]=x,y[-2::-1]
dp2=[1]+[0]*n
for v in o:
for w,x,y in zip(e[v],*c[v]):dp2[w]=(dp2[v]*x*y+1)%m
for x,y in zip(dp1,dp2):print((x*y%m)) | p03181 |
from collections import deque
from functools import reduce
def f(a):
return (a + 1) % M
def g(a, b):
return a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t) | from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t)
| p03181 |
from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t)
| import sys
input = sys.stdin.readline
from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t) | p03181 |
import sys
input = sys.stdin.readline
from collections import deque
from functools import reduce
f = lambda a: (a+1) % M
g = lambda a, b: a * b % M
init = 1
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
T = []
while Q:
i = deque.popleft(Q)
T.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N # Bottom Up
TD = [1] * N # Top Down
for i in T[::-1]:
BU[i] = reduce(g, [f(BU[j]) for j in X[i]]) if len(X[i]) else init
for i in T:
B = [1] * (len(X[i]) + 1)
for k, j in enumerate(X[i]):
B[k+1] = g(B[k], f(BU[j]))
a = init
for k in range(len(X[i]))[::-1]:
j = X[i][k]
TD[j] = f(g(TD[i], g(a, B[k])))
a = g(a, f(BU[j]))
for t in [g(a, b) for a, b in zip(BU, TD)]:
print(t) | import sys
input = sys.stdin.readline
from collections import deque
N, M = list(map(int, input().split()))
X = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
X[x-1].append(y-1)
X[y-1].append(x-1)
P = [-1] * N
Q = deque([0])
R = []
while Q:
i = deque.popleft(Q)
R.append(i)
for a in X[i]:
if a != P[i]:
P[a] = i
X[a].remove(i)
deque.append(Q, a)
BU = [0] * N
TD = [1] * N
for i in R[::-1]:
a = 1
for j in X[i]:
a = a * (BU[j] + 1) % M
BU[i] = a
for i in R:
c = len(X[i])
AL = [1] * (c + 1)
AR = [1] * (c + 1)
for j in range(c):
AL[j+1] = AL[j] * (BU[X[i][j]] + 1) % M
for j in range(c)[::-1]:
AR[j] = AR[j+1] * (BU[X[i][j]] + 1) % M
for j in range(c):
TD[X[i][j]] = (TD[i] * AL[j] * AR[j+1] + 1) % M
for i in range(N):
print((BU[i] * TD[i] % M)) | p03181 |
# coding: utf-8
# Your code here!
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n,MOD = [int(i) for i in input().split()]
to = [[] for _ in [0]*n]
for _ in range(n-1):
x,y = [int(i)-1 for i in input().split()]
to[x].append(y)
to[y].append(x)
dp = [[0]*len(to_i) for to_i in to]
parent_index = [-9999]*n
ans = [0]*n
def dfs(v, p):
res = 1
for i, vc in enumerate(to[v]):
if vc == p:
parent_index[v] = i
continue
dp[v][i] = dfs(vc, v)
res *= dp[v][i]+1
res %= MOD
return res
def dfs2(v, res_p, p):
deg = len(to[v])
if p >= 0:
dp[v][parent_index[v]] = res_p
accl = [1]*(deg+1)
for i, dpvi in enumerate(dp[v]):
accl[i+1] = accl[i]*(dpvi+1)%MOD
accr = [1]*(deg+1)
for i, dpvir in enumerate(reversed(dp[v])):
accr[-i-2] = accr[-i-1]*(dpvir+1)%MOD
ans[v] = accr[0]
for i,vc in enumerate(to[v]):
if vc == p: continue
dfs2(vc, accl[i]*accr[i+1]%MOD, v)
dfs(0,-1)
#print(dp)
dfs2(0,0,-1)
#print(dp)
for i in ans:
print(i) | # coding: utf-8
# Your code here!
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n,MOD = [int(i) for i in input().split()]
to = [[] for _ in [0]*n]
for _ in range(n-1):
x,y = [int(i)-1 for i in input().split()]
to[x].append(y)
to[y].append(x)
dp = [[0]*len(to_i) for to_i in to]
parent_index = [-9999]*n
ans = [0]*n
def dfs(v, p):
res = 1
for i, vc in enumerate(to[v]):
if vc == p:
parent_index[v] = i
continue
dp[v][i] = dfs(vc, v)
res *= dp[v][i]+1
res %= MOD
return res
def dfs2(v, res_p, p):
deg = len(to[v])
if p >= 0:
dp[v][parent_index[v]] = res_p
accl = [1]*(deg+1)
accr = [1]*(deg+1)
for i in range(1, deg+1):
accl[i] = accl[i-1] * (dp[v][i-1] + 1) % MOD
accr[-i-1] = accr[-i] * (dp[v][-i] + 1) % MOD
ans[v] = accr[0]
for i,vc in enumerate(to[v]):
if vc == p: continue
dfs2(vc, accl[i]*accr[i+1]%MOD, v)
dfs(0,-1)
#print(dp)
dfs2(0,0,-1)
#print(dp)
for i in ans:
print(i) | p03181 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1]*self.n
self.depth = [-1]*self.n
self.subsize = [1]*self.n
self.result = [1]*self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v]+1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the result you want using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
SisterAll = [{} for _ in range(n)]
ans = [0]*n
ans[0] = self.result[0]
s = [self.root]
while s:
v = s.pop()
if v != self.root:
ans[v] = SisterAll[v][self.parent[v]]*self.result[v]
ans[v] %= m
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1]*(self.result[w]+1))
s.append(w)
else:
cum1[v].append(cum1[v][-1]*SisterAll[v][w])
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1]*(self.result[w]+1))
else:
cum2[v].append(cum2[v][-1]*SisterAll[v][w])
cum2[v] = cum2[v][::-1]
for i, w in enumerate(self.g[v]):
SisterAll[w][v] = cum1[v][i]*cum2[v][i+1]+1
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
T1 = Tree(n, g, 0)
ans = T1.rerooting()
for x in T1.rerooting():
print(x)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1]*self.n
self.depth = [-1]*self.n
self.subsize = [1]*self.n
self.result = [1]*self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v]+1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the result you want using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
FromParent = [0]*n
ans = [0]*n
ans[0] = self.result[0]
s = [self.root]
while s:
v = s.pop()
if v != self.root:
ans[v] = (FromParent[v]+1)*self.result[v]
ans[v] %= m
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1]*(self.result[w]+1) % m)
s.append(w)
else:
cum1[v].append(cum1[v][-1]*(FromParent[v]+1) % m)
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1]*(self.result[w]+1) % m)
else:
cum2[v].append(cum2[v][-1]*(FromParent[v]+1) % m)
cum2[v] = cum2[v][::-1]
for i, w in enumerate(self.g[v]):
FromParent[w] = cum1[v][i]*cum2[v][i+1] % m
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
T1 = Tree(n, g, 0)
ans = T1.rerooting()
for x in T1.rerooting():
print(x)
| p03181 |
import sys
sys.setrecursionlimit(10**9)
from collections import deque
N, M = list(map(int, input().split()))
tree = [[] for i in range(N)]
for i in range(N-1):
x, y = list(map(int, input().split()))
tree[x-1].append(y-1)
tree[y-1].append(x-1)
dp1 = [0] * N
dp2 = [0] * N
def solve(node, parent):
global dp1
if dp1[node] > 0:
return dp1[node]
else:
children = tree[node]
t = 1
for child in children:
if child == parent:
continue
t *= (solve(child, node) + 1)
# t %= M
dp1[node] = t
return t
_ = solve(0, -1)
dp2[0] = dp1[0]
d = deque([])
for child in tree[0]:
d.append([child, 0])
while d:
node, parent = d.popleft()
dp2[node] = (dp2[parent]//(dp1[node]+1) + 1) * dp1[node]
children = tree[node]
for child in children:
if child == parent:
continue
d.append([child, node])
for ans in dp2:
print((ans%M)) | # 参考 -> https://atcoder.jp/contests/dp/submissions/8271798
import itertools
import sys
input = sys.stdin.readline
N, MOD = map(int, input().split())
XY = [list(map(int, input().split())) for i in range(N-1)]
prod = lambda x, y: x*y%MOD
tree = [[] for i in range(N)]
for x, y in XY:
tree[x-1].append(y-1)
tree[y-1].append(x-1)
root = 0
parent = [-1] * (N+1)
order = []
stack = [root]
while stack:
node = stack.pop()
order.append(node)
for child in tree[node]:
if child == parent[node]:
continue
parent[child] = node
stack.append(child)
# dp_down[i] : 頂点iを黒く塗ったときの子側の塗り方
dp_down = [0] * N
for node in order[::-1]: # 葉から根に向かって伝搬させる
res = 1
for child in tree[node]:
res *= dp_down[child] + 1
res %= MOD
dp_down[node] = res
# dp_up[i] : 頂点iを黒く塗ったときの親側の塗り方
dp_up = [1] * N
for node in order: # 根から葉に向かって伝搬させる
par = parent[node]
arr = [dp_down[c]+1 if c!=par else dp_up[node] for c in tree[node]]
# それぞれの子(=c)について、自身を根とする下側の部分木を除いた積
left = [1] + list(itertools.accumulate(arr, prod))[:-1]
right = list(itertools.accumulate(reversed(arr), prod))[-2::-1] + [1]
upper_cases = [l*r%MOD for l, r in zip(left, right)]
for c, res in zip(tree[node], upper_cases):
if c != par:
dp_up[c] = res + 1 # (+1 : cより上側が全て白である場合を足し合わせる)
ans = [d*u%MOD for d, u in zip(dp_down, dp_up)]
print(*ans, sep='\n')
| p03181 |
import sys
sys.setrecursionlimit(10**7)
input=sys.stdin.readline
def dfs(v,p):
if res_v[v]!=-1:
return res_v[v]
size[v]=len(G[v])
dp[v]=[0]*size[v]
res=1
for i in range(size[v]):
nv=G[v][i]
if nv==p:
p_i[v]=i
continue
R=dfs(nv,v)
dp[v][i]=R
res=res*(R+1)%MOD
return res
def reroot(v,res_p,p):
if p!=-1:
dp[v][p_i[v]]=res_p
for i in range(size[v]):
ans[v]=ans[v]*(dp[v][i]+1)%MOD
dp_L=[1]*(size[v]+1)
dp_R=[1]*(size[v]+1)
for i in range(size[v]):
dp_L[i+1]=dp_L[i]*(dp[v][i]+1)%MOD
for i in reversed(range(size[v])):
dp_R[i]=dp_R[i+1]*(dp[v][i]+1)%MOD
for i in range(size[v]):
nv=G[v][i]
if nv==p:
continue
reroot(nv,dp_L[i]*dp_R[i+1]%MOD,v)
N,MOD=map(int,input().split())
G=[[] for i in range(N)]
for i in range(N-1):
x,y=map(lambda x:int(x)-1,input().split())
G[x].append(y)
G[y].append(x)
res_v=[-1]*N
dp=[[] for i in range(N)]
size=[-1]*N
p_i=[-1]*N
dp_L=[[] for i in range(N)]
dp_R=[[] for i in range(N)]
ans=[1]*N
z_root=dfs(0,-1)
res_v[0]=z_root
reroot(0,0,-1)
print(*ans,sep='\n')
| import sys
sys.setrecursionlimit(10**7)
input=sys.stdin.readline
def dfs(v,p):
size[v]=len(G[v])
dp[v]=[0]*size[v]
res=1
for i in range(size[v]):
nv=G[v][i]
if nv==p:
p_i[v]=i
continue
R=dfs(nv,v)
dp[v][i]=R
res=res*(R+1)%MOD
return res
def reroot(v,res_p,p):
if p!=-1:
dp[v][p_i[v]]=res_p
for i in range(size[v]):
ans[v]=ans[v]*(dp[v][i]+1)%MOD
dp_L=[1]*(size[v]+1)
dp_R=[1]*(size[v]+1)
for i in range(size[v]):
dp_L[i+1]=dp_L[i]*(dp[v][i]+1)%MOD
for i in reversed(range(size[v])):
dp_R[i]=dp_R[i+1]*(dp[v][i]+1)%MOD
for i in range(size[v]):
nv=G[v][i]
if nv==p:
continue
reroot(nv,dp_L[i]*dp_R[i+1]%MOD,v)
N,MOD=map(int,input().split())
G=[[] for i in range(N)]
for i in range(N-1):
x,y=map(lambda x:int(x)-1,input().split())
G[x].append(y)
G[y].append(x)
dp=[[] for i in range(N)]
size=[-1]*N
p_i=[-1]*N
dp_L=[[] for i in range(N)]
dp_R=[[] for i in range(N)]
ans=[1]*N
z_root=dfs(0,-1)
reroot(0,0,-1)
print(*ans,sep='\n')
| p03181 |
import itertools
while 1:
n,m,s=list(map(int,input().split()))
if n==0:break
dp=[[0 for _ in range(s+2)] for _ in range(n*n+1)]
dp[0][0]=1
for i,j in itertools.product(list(range(1,m+1)),list(range(n*n,0,-1))):
for k in range(i,s+1):
dp[j][k]=(dp[j][k]+dp[j-1][k-i])%100000
print((dp[n*n][s])) | import itertools
while 1:
n,m,s=list(map(int,input().split()))
if n==0:break
dp=[[0 for _ in range(s+1)] for _ in range(n*n+1)]
dp[0][0]=1
for i,j in itertools.product(list(range(1,n*n+1)),list(range(s+1))):
if j>=i:dp[i][j]+=dp[i-1][j-i]+dp[i][j-i]
if j-m>=1:dp[i][j]+=100000-dp[i-1][j-m-1]
dp[i][j]%=100000
print((dp[n*n][s])) | p00460 |
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():
*a,=map(int,open(0))
def S_():
return input()
def IS():
return input().split()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2)
found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['YES','NO']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
show_flg=False
show_flg=True
ans=0
n,m=LI()
g,c=GI(n,m)
def bfs(x):
v=[0]*n
q=[x]
while q:
c=q.pop()
v[c]=1
for nb in g[c]:
if v[nb]==0:
q.append(nb)
v[nb]=1
return sum(v),v
x,cx=bfs(0)
y,cy=bfs(1)
if x<y:
cy=[1 if cx[i]==0 else 0 for i in range(n)]
nx,ny=x,n-x
else:
cx=[1 if cy[i]==0 else 0 for i in range(n)]
nx,ny=n-y,y
for i in range(n):
if cx[i]==1: # i belongs to x
ans+=nx-1-len(g[i])
else:
ans+=ny-1-len(g[i])
print(ans//2)
| from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from functools import *
from itertools import permutations,combinations,groupby
import sys
import bisect
import string
import math
import time
import random
def Golf():
*a,=map(int,open(0))
def S_():
return input()
def IS():
return input().split()
def LS():
return [i for i in input().split()]
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def NI(n):
return [int(input()) for i in range(n)]
def NI_(n):
return [int(input())-1 for i in range(n)]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def LtoS(ls):
return ''.join([chr(i+97) for i in ls])
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
mp=[1]*(w+2)
found={}
for i in range(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[1]+[mp_def[j] for j in s]+[1]
mp+=[1]*(w+2)
return h+2,w+2,mp,found
def bit_combination(k,n=2):
rt=[]
for tb in range(n**k):
s=[tb//(n**bt)%n for bt in range(k)]
rt+=[s]
return rt
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['YES','NO']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
rmin,rmax=1,10
a=[random.randint(rmin,rmax) for _ in range(n)]
return n,a
show_flg=False
show_flg=True
ans=0
n,m=LI()
g,c=GI(n,m)
def bfs(x):
v=[0]*n
q=[x]
while q:
c=q.pop()
v[c]=1
for nb in g[c]:
if v[nb]==0:
q.append(nb)
v[nb]=1
return sum(v)
x=min(bfs(0),bfs(1))
print(n*(n-1)//2-x*(n-x)-m)
| p03508 |
def main():
n=int(eval(input()))
aa=list(map(int,input().split()))
ll={}
for i,a in enumerate(aa,1):
x=i-a
if x < 1:
continue
if x not in ll:
ll[x]=[i]
else:
ll[x].append(i)
c=0
for i,a in enumerate(aa,1):
x=i+a
if x not in ll:
continue
c+=sum(j>i for j in ll[x])
print(c)
main() | def main():
n=int(eval(input()))
aa=list(map(int,input().split()))
ll={}
c=0
for i,a in enumerate(aa,1):
x=i-a
if x in ll:
c+=len(ll[x])
y=i+a
if y in ll:
ll[y].append(i)
else:
ll[y]=[i]
print(c)
main() | p02691 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
N = int(readline().rstrip())
A = list(map(int, readline().split()))
import itertools
pairs = list(itertools.combinations(list(range(0, N)), 2))
ans = 0
for pair in pairs:
x1, x2 = pair
if abs(x1 - x2) == A[x1] + A[x2]:
ans += 1
print(ans) | import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
N = int(readline().rstrip())
A = list(map(int, readline().split()))
d1 = {}
d2 = {}
for n in range(1, N+1):
x1 = n + A[n-1]
if x1 in d1:
d1[x1] += 1
else:
d1[x1] = 1
x2 = n - A[n-1]
if x2 in d2:
d2[x2] += 1
else:
d2[x2] = 1
ans = 0
for d in d1:
if d in d2:
ans += (d1[d] * d2[d])
print(ans) | p02691 |
from collections import Counter
n = int(eval(input()))
a = list(map(int,input().split()))
L = [0]*n
R = [0]*n
cnt=0
for i in range(n):
L[i] = i+a[i]
R[i] = i-a[i]
z1=dict(Counter(L))
z2=dict(Counter(R))
cnt=0
for k1,v1 in list(z1.items()):
for k2,v2 in list(z2.items()):
if k1 == k2:
cnt += v1*v2
print(cnt) | from collections import Counter
n = int(eval(input()))
a = list(map(int,input().split()))
L = [0]*n
R = [0]*n
cnt=0
for i in range(n):
L[i] = i+a[i]
R[i] = i-a[i]
z1=Counter(L)
z2=Counter(R)
cnt=0
for k1,v1 in list(z1.items()):
v2 = z2[k1]
cnt += v1*v2
print(cnt) | p02691 |
from collections import Counter
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
c = []
for i in range(n):
b.append(a[i] + i + 1)
c.append(i + 1 - a[i])
b = list(Counter(b).items())
c = Counter(c)
answer = 0
for i, n in b:
if i in c:
answer += n * c[i]
print(answer)
if __name__ == '__main__':
main()
| def main():
n = int(eval(input()))
a = list(map(int, input().split()))
b = []
c = {}
answer = 0
for i in range(n):
b.append(a[i] + i + 1)
tmp = -a[i] + i + 1
if tmp in c:
c[tmp] += 1
else:
c[tmp] = 1
for i in range(n):
if b[i] in c:
answer += c[b[i]]
print(answer)
if __name__ == '__main__':
main()
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
diff_i = [A[i] + i + 1 for i in range(N)]
diff_j = [i + 1 - A[i] for i in range(N)]
diff = set(diff_i) & set(diff_j)
ans = 0
for d in diff:
ans += diff_i.count(d) * diff_j.count(d)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
cnt1 = {}
cnt2 = {}
for i in range(N):
tmp1 = A[i] + i + 1
tmp2 = i + 1 - A[i]
if tmp1 not in cnt1:
cnt1[tmp1] = 1
else:
cnt1[tmp1] += 1
if tmp2 not in cnt2:
cnt2[tmp2] = 1
else:
cnt2[tmp2] += 1
diff = set(list(cnt1.keys())) & set(list(cnt2.keys()))
ans = 0
for d in diff:
ans += cnt1[d] * cnt2[d]
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
A1 = [[-a-i,i] for i, a in enumerate(A)]
A2 = [[a-i,i] for i, a in enumerate(A)]
A1.sort()
A2.sort()
i = j = 0
cnt = 0
while i < N and j < N:
if A1[i][0] == A2[j][0]:
buf1 = 1
for k in range(i+1, N):
if A1[k][0] != A1[i][0]:
break
buf1 += 1
buf2 = 1
for k in range(j+1, N):
if A2[k][0] != A2[j][0]:
break
buf2 += 1
for i_ in range(i, i+buf1):
for j_ in range(j, j+buf2):
if A1[i_][1] < A2[j_][1]:
cnt += 1
i += buf1
j += buf2
elif A1[i][0] < A2[j][0]:
i += 1
else:
j += 1
print(cnt)
| N = int(eval(input()))
A = list(map(int, input().split()))
A1 = [[-a-i,i] for i, a in enumerate(A)]
A2 = [[a-i,i] for i, a in enumerate(A)]
A1.sort()
A2.sort()
i = j = 0
cnt = 0
while i < N and j < N:
if A1[i][0] == A2[j][0]:
buf1 = 1
for k in range(i+1, N):
if A1[k][0] != A1[i][0]:
break
buf1 += 1
buf2 = 1
for k in range(j+1, N):
if A2[k][0] != A2[j][0]:
break
buf2 += 1
cnt += buf1 * buf2
i += buf1
j += buf2
elif A1[i][0] < A2[j][0]:
i += 1
else:
j += 1
print(cnt)
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
A1 = [[-a-i,i] for i, a in enumerate(A)]
A2 = [[a-i,i] for i, a in enumerate(A)]
A1.sort()
A2.sort()
i = j = 0
cnt = 0
while i < N and j < N:
if A1[i][0] == A2[j][0]:
buf1 = 1
for k in range(i+1, N):
if A1[k][0] != A1[i][0]:
break
buf1 += 1
buf2 = 1
for k in range(j+1, N):
if A2[k][0] != A2[j][0]:
break
buf2 += 1
cnt += buf1 * buf2
i += buf1
j += buf2
elif A1[i][0] < A2[j][0]:
i += 1
else:
j += 1
print(cnt)
| N = int(eval(input()))
A = list(map(int, input().split()))
A1, A2 = {}, {}
for i, a in enumerate(A):
key1 = str(-a-i)
if key1 in A1:
A1[key1] = (key1 in A1) * A1[key1] + 1
else:
A1[key1] = 1
key2 = str(a-i)
if key2 in A2:
A2[key2] += 1
else:
A2[key2] = 1
cnt = 0
for key, value in list(A1.items()):
if key in A2:
cnt += value * A2[key]
print(cnt)
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
a_p = [0]*n
a_m = [0]*n
ans = 0
for i in range(n):
a_p[i] = a[i] + i+1
a_m[i] = i+1 -a[i]
ans = 0
for i in range(n):
for j in range(i+1,n):
if a_p[i] == a_m[j]:
ans = ans + 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
dp = dict()
for i in range(n):
a_p = a[i] + i+1
a_m = i+1 -a[i]
if a_p in dp:
dp[a_p] = dp[a_p] + 1
else:
dp[a_p] = 1
if a_m in dp:
ans = ans + dp[a_m]
print(ans) | p02691 |
n = int(eval(input()))
a_l = list(map(int,input().split()))
count = 0
for i in range(n-1):
for j in range(i+a_l[i]+1,n):
if (j-i) == (a_l[j] + a_l[i]):
count += 1
print(count)
| n = int(eval(input()))
a_l = list(map(int,input().split()))
ia = list(enumerate(a_l))
x_dict = {}
y_dict = {}
for i, a in ia:
x = i+a
y = i-a
if x in x_dict:
x_dict[x] += 1
else:
x_dict[x] = 1
if y in y_dict:
y_dict[y] += 1
else:
y_dict[y] = 1
count = 0
for xkey in list(x_dict.keys()):
if xkey in y_dict:
count += x_dict[xkey] * y_dict[xkey]
print(count) | p02691 |
#coding: utf-8
N = int(eval(input()))
A = list(map(int, input().split()))
count = 0
for i, a in enumerate(A):
for offset in range(N - i):
if (a + A[i + offset]) == offset:
count += 1
print(count)
| #coding: utf-8
N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
for i, a in enumerate(A):
k = i + a
if k not in L:
L[k] = 1
else:
L[k] += 1
count = 0
for j, a in enumerate(A):
k = j - a
if k in L:
count += L[k]
print(count)
| p02691 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.readline
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
from itertools import combinations
def run():
N = int(eval(input()))
A = list(map(int, sysread().split()))
A = [(idx, val) for idx, val in enumerate(A, 1) if val < N]
ret = 0
for (i,Ai), (j,Aj) in combinations(A, 2):
if abs(i-j) == Ai+Aj:
ret += 1
print(ret)
if __name__ == "__main__":
run() | # coding: utf-8
import sys
sysread = sys.stdin.readline
def run():
N = int(eval(input()))
A = list(map(int, sysread().split()))
A = [(idx, val) for idx, val in enumerate(A, 1) if val < N]
ret = 0
store = [0] * N
for idx, val in A:
if idx - val > 0:
ret += store[idx - val]
try:
store[idx + val] += 1
except:
continue
print(ret)
if __name__ == "__main__":
run() | p02691 |
n=int(eval(input()))
a=list(map(int,input().split()))
k=[]
ans=0
for i in range(400005):
k.append(0)
for i in range(n):
if i-a[i]>=0:
ans+=k[i-a[i]]
if a[i]+i<400005:
k[a[i]+i]+=1
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
thing={}
ans=0
for i in range(n):
if i-a[i] in thing:
ans+=thing[i-a[i]]
if i+a[i] in thing:
thing[i+a[i]]+=1
else:
thing[i+a[i]]=1
print(ans) | p02691 |
N=int(eval(input()))
A=list(map(int,input().split()))
np,nm=[],[]
for i in range(N):
np.append(A[i]+i)
nm.append(i-A[i])
sp,sm=sorted(np),sorted(nm)
ans=0
for i in range(N):
p,m=np[i],nm[i]
l,r=0,N
while not l+1==r:
x=(l+r)//2
if sm[x]<=p:
l=x
else:
r=x
while sm[l]==p and l>=0:
ans+=1
l-=1
l,r=0,N
while not l+1==r:
x=(l+r)//2
if sp[x]<=m:
l=x
else:
r=x
while sp[l]==m and l>=0:
ans+=1
l-=1
print((ans//2)) | N=int(eval(input()))
A=list(map(int,input().split()))
np,nm=[],[]
for i in range(N):
np.append(A[i]+i)
nm.append(i-A[i])
sp,sm=sorted(np),sorted(nm)
ans=0
for i in range(N):
p,m=np[i],nm[i]
l,r=-1,N
while not l+1==r:
x=(l+r)//2
if sm[x]<=p:
l=x
else:
r=x
tmp=l
l,r=-1,N
while not l+1==r:
x=(l+r)//2
if sm[x]<p:
l=x
else:
r=x
ans+=tmp-l
l,r=-1,N
while not l+1==r:
x=(l+r)//2
if sp[x]<=m:
l=x
else:
r=x
tmp=l
l,r=-1,N
while not l+1==r:
x=(l+r)//2
if sp[x]<m:
l=x
else:
r=x
ans+=tmp-l
print((ans//2)) | p02691 |
from collections import defaultdict
N, *A = list(map(int, open(0).read().split()))
ctr1 = defaultdict(int)
ctr2 = defaultdict(int)
for i in range(N):
ctr2[i + A[i]] += 1
if i - A[i] > 0:
ctr1[i - A[i]] += 1
ans = 0
for v in ctr1:
ans += ctr1[v] * ctr2[v]
print(ans)
|
from collections import defaultdict
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
ctr = defaultdict(list)
for i in range(N):
ctr[i + A[i]].append(i)
ans = 0
for i in range(N):
v = i - A[i]
if v in ctr:
ans += bisect_left(ctr[v], i)
print(ans)
| p02691 |
N = int(eval(input()))
A = [int(i) for i in input().split()]
dp = [0] * 10 ** 7
ans = 0
for i in range(N):
x = i + 1 - A[i]
if x >= 0:
ans += dp[x]
y = i + 1 + A[i]
if y < 10 ** 7:
dp[y] += 1
print(ans)
| N = int(eval(input()))
A = [int(i) for i in input().split()]
INF = 2 * 10 ** 5
dp = [0] * INF
ans = 0
for i in range(N):
i_i_ = i + 1 - A[i]
if 0 < i_i_ < INF:
ans += dp[i_i_]
i_ = i + 1 + A[i]
if 0 < i_ < INF:
dp[i_] += 1
print(ans) | p02691 |
# coding: utf-8
import bisect
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
j_minus_aj_ = sorted([(j - A[j], j) for j in range(N)])
j_minus_aj, j_minus_aj_j = [None] * N, [None] * N
for j in range(N):
j_minus_aj[j], j_minus_aj_j[j] = j_minus_aj_[j]
j_plus_aj_ = sorted([(j + A[j], j) for j in range(N)])
j_plus_aj, j_plus_aj_j = [None] * N, [None] * N
for j in range(N):
j_plus_aj[j], j_plus_aj_j[j] = j_plus_aj_[j]
ans = 0
for i in range(N):
# i <= j
i_plus_ai = i + A[i]
left = bisect.bisect_left(j_minus_aj, i_plus_ai)
right = bisect.bisect_right(j_minus_aj, i_plus_ai)
for j in range(left, right):
if j_minus_aj_j[j] >= i:
ans += 1
i_minus_ai = i - A[i]
left = bisect.bisect_left(j_plus_aj, i_minus_ai)
right = bisect.bisect_right(j_plus_aj, i_minus_ai)
for j in range(left, right):
if j_plus_aj_j[j] < i:
ans += 1
return ans // 2
# for i in range(N):
# # i <= j
# i_plus_ai = i + A[i]
# # left = geq_search(j_minus_aj, i_plus_ai-1)
# # dif = 0
# # while left+dif+1 < N and j_minus_aj[left+dif+1] != i_plus_ai:
# # dif += 1
# # left = left + dif
# left = bisect.bisect_left(j_minus_aj, i_plus_ai)
# # right = leq_search(j_minus_aj, i_plus_ai+1)
# # dif = 0
# # while 0 <= right-dif-1 and j_minus_aj[right-dif-1] != i_plus_ai:
# # dif += 1
# # right = right - dif
# right = bisect.bisect_left(j_minus_aj, i_plus_ai)
# for j in range(left, right):
# if j_minus_aj_j[j] >= i:
# ans += 1
# i_minus_ai = i - A[i]
# # left = geq_search(j_plus_aj, i_minus_ai-1)
# # dif = 0
# # while left+dif+1 < N and j_plus_aj[left+dif+1] != i_minus_ai:
# # dif += 1
# # left = left + dif
# left = bisect.bisect_left(j_plus_aj, i_minus_ai)
# # right = leq_search(j_plus_aj, i_minus_ai+1)
# # dif = 0
# # while 0 <= right-dif-1 and j_plus_aj[right-dif-1] != i_minus_ai:
# # dif += 1
# # right = right - dif
# right = bisect.bisect_left(j_plus_aj, i_minus_ai)
# for j in range(left, right):
# if j_plus_aj_j[j] < i:
# ans += 1
# return ans
print((main()))
| # coding: utf-8
import bisect
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
j_minus_aj_ = sorted([(j - A[j], j) for j in range(N)])
j_minus_aj, j_minus_aj_j = [None] * N, [None] * N
for j in range(N):
j_minus_aj[j], j_minus_aj_j[j] = j_minus_aj_[j]
j_plus_aj_ = sorted([(j + A[j], j) for j in range(N)])
j_plus_aj, j_plus_aj_j = [None] * N, [None] * N
for j in range(N):
j_plus_aj[j], j_plus_aj_j[j] = j_plus_aj_[j]
ans = 0
for i in range(N):
# i <= j
i_plus_ai = i + A[i]
left = bisect.bisect_left(j_minus_aj, i_plus_ai)
right = bisect.bisect_right(j_minus_aj, i_plus_ai)
# for j in range(left, right):
# if j_minus_aj_j[j] >= i:
# ans += 1
ans += right - left
i_minus_ai = i - A[i]
left = bisect.bisect_left(j_plus_aj, i_minus_ai)
right = bisect.bisect_right(j_plus_aj, i_minus_ai)
# for j in range(left, right):
# if j_plus_aj_j[j] < i:
# ans += 1
ans += right - left
return ans // 2
# for i in range(N):
# # i <= j
# i_plus_ai = i + A[i]
# # left = geq_search(j_minus_aj, i_plus_ai-1)
# # dif = 0
# # while left+dif+1 < N and j_minus_aj[left+dif+1] != i_plus_ai:
# # dif += 1
# # left = left + dif
# left = bisect.bisect_left(j_minus_aj, i_plus_ai)
# # right = leq_search(j_minus_aj, i_plus_ai+1)
# # dif = 0
# # while 0 <= right-dif-1 and j_minus_aj[right-dif-1] != i_plus_ai:
# # dif += 1
# # right = right - dif
# right = bisect.bisect_left(j_minus_aj, i_plus_ai)
# for j in range(left, right):
# if j_minus_aj_j[j] >= i:
# ans += 1
# i_minus_ai = i - A[i]
# # left = geq_search(j_plus_aj, i_minus_ai-1)
# # dif = 0
# # while left+dif+1 < N and j_plus_aj[left+dif+1] != i_minus_ai:
# # dif += 1
# # left = left + dif
# left = bisect.bisect_left(j_plus_aj, i_minus_ai)
# # right = leq_search(j_plus_aj, i_minus_ai+1)
# # dif = 0
# # while 0 <= right-dif-1 and j_plus_aj[right-dif-1] != i_minus_ai:
# # dif += 1
# # right = right - dif
# right = bisect.bisect_left(j_plus_aj, i_minus_ai)
# for j in range(left, right):
# if j_plus_aj_j[j] < i:
# ans += 1
# return ans
print((main()))
| p02691 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
B = A[:]
for n in range(N):
B[n] -= (n + 1)
D = defaultdict(int)
ans = 0
for i, a, b in zip(reversed(list(range(N))), A[::-1], B[::-1]):
ans += D[-(i + a + 1)]
D[b] += 1
print(ans)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
P = [i + a for i, a in enumerate(A, start=1)]
Q = [j - a for j, a in enumerate(A, start=1)]
ans = 0
QC = Counter(Q)
for p in P:
ans += QC[p]
print(ans)
| p02691 |
import sys
import os
from itertools import combinations
def file_input():
f = open('../Beginner_Contest_166/input.txt', 'r')
sys.stdin = f
def main():
#file_input()
N=int(eval(input())) #人数
A=list(map(int, input().split())) #身長
ans=0
# A_set=set(A)
sum=set()
for c in list(combinations(A,2)):
sum.add(c[0]+c[1])
# print(c)
# print(str(c[0]-1)+str(c[1]-1)+" : "+str(A[c[0]-1])+str(A[c[1]-1]))
# print(str(abs(A[c[0]-1]-A[c[1]-1]))+" : "+str(abs(c[0]-1-(c[1]-1))))
# if abs(A[c[0]-1]+A[c[1]-1])==abs(c[0]-1-(c[1]-1)):
# ans+=1
# print(sum)
for s in sum:
# print("sum : "+str(s))
for i in range(N-s):
if A[i]+A[i+s]==s:
# print("h : "+str(i)+","+str(i+s))
ans+=1
print(ans)
if __name__ == '__main__':
main()
| import sys
import os
from itertools import combinations
def file_input():
f = open('../Beginner_Contest_166/input.txt', 'r')
sys.stdin = f
def main():
#file_input()
N=int(eval(input())) #人数
A=list(map(int, input().split())) #身長
ans=0
A_set=set(A)
sum=set()
tmp=[x*2 for x in set(A) if A.count(x) > 1]
sum=sum|set(tmp)
# print(type(tmp))
for c in list(combinations(A_set,2)):
sum.add(c[0]+c[1])
# print(c)
# print(str(c[0]-1)+str(c[1]-1)+" : "+str(A[c[0]-1])+str(A[c[1]-1]))
# print(str(abs(A[c[0]-1]-A[c[1]-1]))+" : "+str(abs(c[0]-1-(c[1]-1))))
# if abs(A[c[0]-1]+A[c[1]-1])==abs(c[0]-1-(c[1]-1)):
# ans+=1
# print(sum)
for s in sum:
# print("sum : "+str(s))
for i in range(N-s):
if A[i]+A[i+s]==s:
# print("h : "+str(i)+","+str(i+s))
ans+=1
print(ans)
if __name__ == '__main__':
main()
| p02691 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
di = defaultdict(int)
dj = defaultdict(int)
for i in range(1, N+1):
di[i + A[i-1]] += 1
dj[i - A[i-1]] += 1
ans = 0
for key in list(di.keys()):
ans += dj[key] * di[key]
print(ans) | from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
di = defaultdict(int)
for i, a in enumerate(A):
ans += di[i+1 - a]
di[i+1 + a] += 1
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
for org in range(N-1):
for i in range(org+A[org],N):
if A[org]+A[i]==i-org:
cnt+=1
print(cnt) | N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
R_val = []
for i in range(N):
if i+A[i] not in L:
L[i+A[i]] = 0
L[i+A[i]]+=1
R_val.append(i-A[i])
ans = 0
for one in R_val:
if one in L:
ans+=L[one]
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int,input().split()))
save = [0]*n
#Ai + i
save = [a[i]+i for i in range(n)]
#j-Aj
ans = 0
for j in range(n):
b = j-a[j]
if(b<0):
continue
ans += save[0:j].count(b)
print(ans) | n = int(eval(input()))
mp = list(map(int,input().split()))
#Ai + i
#j-Aj
ans = 0
cnt = [0]*(n+1)
for i in range(n-1):
j=i+1
a = mp[i]+i
if(a<=n):
cnt[a] += 1
b = j-mp[j]
if(b<0):
continue
ans += cnt[b]
print(ans) | p02691 |
from collections import Counter
N = int(eval(input()))
A = list(enumerate(list(map(int, input().split()))))
b = Counter([x[0]+x[1]+1 for x in A])
c = Counter([x[0]-x[1]+1 for x in A])
count = 0
for x in list(b.items()):
for y in list(c.items()):
if x[0] == y[0]:
count += x[1] * y[1]
print(count) | from collections import Counter
N = int(eval(input()))
A = list(enumerate(list(map(int, input().split()))))
b = Counter([x[0]+x[1]+1 for x in A])
c = Counter([x[0]-x[1]+1 for x in A])
count = 0
for x in list(b.items()):
count += x[1] * c[x[0]]
print(count) | p02691 |
from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
q1=[]
q2=[]
for i in range(n):
q1.append(i+a[i])
q2.append(i-a[i])
c1=Counter(q1)
c2=Counter(q2)
ans=0
for i in list(c1.keys()):
num1=c1[i]
num2=c2[i]
ans+=num1*num2
print(ans) | from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
q1=[]
q2=[]
for i in range(n):
q1.append(i+a[i])
q2.append(i-a[i])
c2=Counter(q2)
ans=0
for i in q1:
ans+=c2[i]
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
check = []
ans = 0
for i, v in enumerate(A):
if v in check:
ans += check.count(v)
check.append(-v)
check = list([x+1 for x in check])
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
check = {}
ans = 0
for i, v in enumerate(A):
if (i-v) in check:
ans += check[i-v]
if v+i in check:
check[v+i] += 1
else:
check[v+i] = 1
print(ans)
| p02691 |
from collections import Counter
N,*A = list(map(int,open(0).read().split()))
#j - i = Aj + Ai
#j - Aj = Ai + i
#L = i + Ai, R = j - Aj とおく
L = []
R = []
for i in range(N):
L.append(i+1 + A[i])
R.append(i+1 - A[i])
l = Counter(L)
r = Counter(R)
#print(l)
#print(r)
cnt = 0
a=[]
for i in range(1,N+1):
if i in l and i in r:
cnt += l[i]*r[i]
a.append(i)
print(cnt) | from collections import Counter
N,*A = list(map(int,open(0).read().split()))
#j - i = Aj + Ai
#j - Aj = Ai + i
#L = i + Ai, R = j - Aj とおく
L = []
R = []
for i in range(N):
L.append(i+1 + A[i])
R.append(i+1 - A[i])
l = Counter(L)
r = Counter(R)
cnt = 0
a = []
for i in range(1,N+1):
if i in l and i in r:
cnt += l[i] * r[i]
a.append(i)
print(cnt) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(n):
for j in range(i + a[i], n):
if j - i == a[i] + a[j]:
cnt += 1
print(cnt) | n = int(eval(input()))
a = list(map(int, input().split()))
r = {}
for i in range(n):
try:
r[i-a[i]] += 1
except:
r[i-a[i]] = 1
cnt = 0
for i in range(n):
r[i-a[i]] -= 1
try:
cnt += r[i+a[i]]
except:
pass
print(cnt) | p02691 |
N = int(eval(input()))
List = list(map(int, input().split()))
res = 0
A = [[0 for j in range(N)] for i in range(N)]
B = [[0 for j in range(N)] for i in range(N)]
for i in range(N):
for j in range(i,N):
if A[j][i] != 0:
pass
else:
A[i][j] = List[i]+List[j]
B[i][j] = A[i][j]-abs(j-i)
if B[i][j] == 0:
res = res + 1
print(res) | n = int(eval(input()))
A = list(map(int, input().split()))
m = {}
ans = 0
for i in range(n):
x = A[i] + i #i番目と当該数字の和
if x not in m:
m[x] = 0 #和の属性値を0とする
m[x] += 1 #和の属性値に１を足す
if i - A[i] in m: #i番目と当該数字の差
ans += m[i - A[i]] #差の位置に当たる属性値を答えに足す
print(ans) | p02691 |
#!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
dic_Lg = {}
dic_Lw = {}
for i in range(N):
x = i - A[i]
if x in dic_Lg:
dic_Lg[x]+=1
else:
dic_Lg[x]=1
y = i + A[i]
if y in dic_Lw:
dic_Lw[y]+=1
else:
dic_Lw[y]=1
LP = list(dic_Lw.keys()) + list(dic_Lg.keys())
LP = set(LP)
ret = 0
for i in LP:
if i in dic_Lg and i in dic_Lw:
ret += dic_Lg[i] * dic_Lw[i]
print(ret)
if __name__ == '__main__':
main() | #!/usr/bin python3
# -*- coding: utf-8 -*-
import sys
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
dic_Lg = {}
dic_Lw = {}
for i in range(N):
x = i - A[i]
if x in dic_Lg:
dic_Lg[x]+=1
else:
dic_Lg[x]=1
y = i + A[i]
if y in dic_Lw:
dic_Lw[y]+=1
else:
dic_Lw[y]=1
LP = list(dic_Lw.keys()) + list(dic_Lg.keys())
LP = set(LP)
ret = 0
for i in LP:
if i in dic_Lg and i in dic_Lw:
ret += dic_Lg[i] * dic_Lw[i]
print(ret)
if __name__ == '__main__':
main() | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(A[i], N):
if(A[i] + A[j] == j-i):
ans += 1
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
L = [0] * N
R = list()
for i in range(N):
R.append(i-A[i])
if(i+A[i]<=N-1):
L[i+A[i]] += 1
for r in R:
if(r > 0):
ans += L[r]
print(ans) | p02691 |
n=int(eval(input()))
a=list(map(int,input().split()))
def add(n):
return n+1
cnt=0
li=[]
for i in range(n):
cnt += li.count(a[i])
li=list(map(add,li))
li.append(1-a[i])
print(cnt) | n=int(eval(input()))
a=list(map(int,input().split()))
d={}
ans=0
for i in range(n):
if i+a[i] in list(d.keys()):
d[i+a[i]]+=1
else:
d[i+a[i]]=1
if i-a[i] in list(d.keys()):
ans+=d[i-a[i]]
print(ans)
| p02691 |
import itertools
N = int(eval(input()))
A_list = []
inp_list = list(map(int, input().split(" ")))
for i in range(N):
A_list.append([i+1, inp_list[i]])
answer = 0
for v in itertools.combinations(A_list, 2):
if abs(v[0][0] - v[1][0]) == (v[0][1] + v[1][1]):
answer += 1
print(answer) | N = int(eval(input()))
X1_dict = {}
X2_dict = {}
inp_list = list(map(int, input().split(" ")))
for i, a_i in enumerate(inp_list):
X1 = i + 1 + a_i
X2 = i + 1 - a_i
if X1 in list(X1_dict.keys()):
X1_dict[X1] += 1
else:
X1_dict[X1] = 1
if X2 in list(X2_dict.keys()):
X2_dict[X2] += 1
else:
X2_dict[X2] = 1
answer = 0
for key, value in list(X1_dict.items()):
if key in list(X2_dict.keys()):
answer += value * X2_dict[key]
print(answer) | p02691 |
import collections
n = int(eval(input()))
a = list(map(int, input().split()))
l = [a[i] +i+1 for i in range(n)]
r = [i+1 -a[i] for i in range(n)]
L = collections.Counter(l)
R = collections.Counter(r)
c = 0
for i in range(max(max(l),max(r))+1):
c += L.get(i, 0) * R.get(i, 0)
print(c) | import collections
n = int(eval(input()))
a = list(map(int, input().split()))
l = [a[i] +i+1 for i in range(n)]
r = [i+1 -a[i] for i in range(n)]
L = collections.Counter(l)
R = collections.Counter(r)
c = 0
for i in list(L.keys()):
c += L.get(i, 0) * R.get(i, 0)
print(c) | p02691 |
n=int(eval(input()));a=list(map(int,input().split()));b,c,f=[],[],0
for i,q in enumerate(a):b+=i+q,;c+=i-q,
from collections import*
for d,e in list(Counter(b).items()):f+=e*Counter(c)[d]
print(f) | n=int(eval(input()))
a=list(map(int,input().split()))
b,c=[],[]
for i,q in enumerate(a):
b.append(i+q)
c.append(i-q)
from collections import*
b=list(Counter(b).items())
c=Counter(c)
z=0
for d,e in b:z+=e*c[d]
print(z)
| p02691 |
n,*l=list(map(int,open(0).read().split()))
from collections import*
d=defaultdict(int)
a=0
for i in range(n): d[i+l[i]]+=1; a+=d[i-l[i]]*(i>l[i])
print(a) | n,*l=list(map(int,open(0).read().split()));d,a={},0
for i in range(n):d[i+l[i]]=d.get(i+l[i],0)+1;a+=d.get(i-l[i],0)
print(a) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
left = []
right = []
for i in range(n):
left.append(a[i]+i)
right.append(i-a[i])
ans = 0
for i in range(n):
for j in range(i+1, n):
#print(i,j)
if left[i]==right[j]:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
mp = [0] * n
ans = 0
for i in range(n):
if i-a[i] >= 0:
ans += mp[i-a[i]]
if n > a[i]+i:
mp[a[i]+i] += 1
print(ans) | p02691 |
import time
startTimeProblem=time.time()
import fileinput, sys, itertools, functools, copy
from math import *
from bisect import *
from heapq import *
from collections import *
def lcm(a, b):
return (a*b)/gcd(a, b)
class InputHelper:
def __init__(self):
self.myinput = fileinput.input()
def isLocal(self):
return not fileinput.isstdin()
def int(self):
return int(self.myinput.readline().rstrip())
def ints(self):
return [int(_) for _ in self.myinput.readline().rstrip().split()]
def str(self):
return self.myinput.readline().rstrip()
def strs(self):
return [_ for _ in self.myinput.readline().rstrip().split()]
class OutputHelper:
def int(self, a):
print(a)
def ints(self, a):
print((" ".join([str(_) for _ in a])))
def intsNL(self, a):
for _ in a:
print(_)
def str(self, s):
print(s)
def strs(self, s):
print((" ".join([_ for _ in s])))
def strsNL(self, s):
for st in s:
print(st)
class ListNode:
def __init__(self, val):
self.val = val
self.next = None
self.prev = None
In = InputHelper()
Out = OutputHelper()
######################################
N = In.int()
A = In.ints()
drueb = [defaultdict(int) for i in range(N)]
for i in range(N):
if i>=1:
drueb[i] = copy.deepcopy(drueb[i-1])
val = i+1
drueb[i][A[i]-val] += 1
ans=0
for i in range(N):
j = i+A[i]+1
if j<len(drueb):
if -A[i]-(i+1) in drueb[-1]:
ans+=drueb[-1][-A[i]-(i+1)]
Out.int(ans)
######################################
if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
fin = (time.time()-startTimeProblem)*1000
print(("{:.2f}".format(fin) + "ms")) | import time
startTimeProblem=time.time()
import fileinput, sys, itertools, functools, copy
from math import *
from bisect import *
from heapq import *
from collections import *
def lcm(a, b):
return (a*b)/gcd(a, b)
class InputHelper:
def __init__(self):
self.myinput = fileinput.input()
def isLocal(self):
return not fileinput.isstdin()
def int(self):
return int(self.myinput.readline().rstrip())
def ints(self):
return [int(_) for _ in self.myinput.readline().rstrip().split()]
def str(self):
return self.myinput.readline().rstrip()
def strs(self):
return [_ for _ in self.myinput.readline().rstrip().split()]
class OutputHelper:
def int(self, a):
print(a)
def ints(self, a):
print((" ".join([str(_) for _ in a])))
def intsNL(self, a):
for _ in a:
print(_)
def str(self, s):
print(s)
def strs(self, s):
print((" ".join([_ for _ in s])))
def strsNL(self, s):
for st in s:
print(st)
class ListNode:
def __init__(self, val):
self.val = val
self.next = None
self.prev = None
In = InputHelper()
Out = OutputHelper()
######################################
N = In.int()
A = In.ints()
drueb = [defaultdict(int) for i in range(N)]
for i in range(N):
# if i>=1:
# drueb[i] = copy.copy(drueb[i-1])
val = i+1
drueb[-1][A[i]-val] += 1
ans=0
for i in range(N):
j = i+A[i]+1
if j<len(drueb):
if -A[i]-(i+1) in drueb[-1]:
ans+=drueb[-1][-A[i]-(i+1)]
Out.int(ans)
######################################
if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
fin = (time.time()-startTimeProblem)*1000
print(("{:.2f}".format(fin) + "ms")) | p02691 |
import collections
N = int(eval(input()))
arr = list(map(int, input().split()))
i_arr =[]
j_arr =[]
ans = 0
for i in range(N):
i_arr.append(i+arr[i])
dic = collections.Counter(i_arr)
j_arr.append(-1*arr[i]+i)
ans += dic[j_arr[-1]]
print(ans)
| N = int(eval(input()))
arr = list(map(int, input().split()))
dic = {}
j_arr =[]
ans = 0
for i in range(N):
if i+arr[i] not in dic:
dic[i+arr[i]] = 0
dic[i+arr[i]] += 1
j_arr.append(-1*arr[i]+i)
if -1*arr[i]+i in dic:
ans += dic[-1*arr[i]+i]
print(ans) | p02691 |
# coding: utf-8
from bisect import bisect_left
from collections import defaultdict
def solve(*args: str) -> str:
n = int(args[0])
A = list(map(int, args[1].split()))
ret = 0
X = defaultdict(list)
for i, a in enumerate(A):
X[a+i].append(i)
for j, a in enumerate(A):
if 0 <= j-a:
ret += bisect_left(X[j-a], j)
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| # coding: utf-8
from collections import defaultdict
def solve(*args: str) -> str:
n = int(args[0])
A = list(map(int, args[1].split()))
ret = 0
X = defaultdict(int)
for i, a in enumerate(A):
X[a+i] += 1
if 0 <= i-a:
ret += X[i-a]
return str(ret)
if __name__ == "__main__":
print((solve(*(open(0).read().splitlines()))))
| p02691 |
N=int(eval(input()))
count=0
a=list(map(int,input().split()))
w=[]
s=[]
for i in range(N):
w.append(1+i+a[i])
s.append(1+i-a[i])
for i in range(N):
count+=s.count(w[i])
print(count) | N=int(eval(input()))
count=0
a=list(map(int,input().split()))
w=[]
s=[]
num=[0]*N
maxi=max(a)
for i in range(N):
s.append(1+i-a[i])
if 1+i+a[i]<N:
num[1+i+a[i]]+=1
for i in range(N):
if s[i]>=0:
count+=num[s[i]]
print(count) | p02691 |
N=int(eval(input()))
count=0
a=list(map(int,input().split()))
w=[]
s=[]
num=[0]*N
maxi=max(a)
for i in range(N):
s.append(1+i-a[i])
if 1+i+a[i]<N:
num[1+i+a[i]]+=1
for i in range(N):
if s[i]>=0:
count+=num[s[i]]
print(count) | N=int(eval(input()))
count=0
a=list(map(int,input().split()))
w=[]
s=[]
num=[0]*N
maxi=max(a)
for i in range(N):
s.append(i-a[i])
if i+a[i]<N:
num[i+a[i]]+=1
for i in range(N):
if s[i]>=0:
count+=num[s[i]]
print(count) | p02691 |
n = int(eval(input()))
lst = [int(i) for i in input().split()]
dic = {}
for i in range(n):
a = lst[i]
if a >= n - 1:
continue
if a not in dic:
dic[a] = set()
dic[a].add(i)
#print(dic)
count = 0
for a in list(dic.keys()):
set_ = dic[a]
for index in set_:
b = a + index
if b > n:
continue
for c in list(dic.keys()):
j = b + c
if j in dic[c]:
count += 1
print(count)
| n = int(eval(input()))
lst = [int(i) for i in input().split()]
dic = {}
count = 0
for i in range(n):
num = lst[i]
a = i + num
if a not in dic:
dic[a] = 1
else:
dic[a] += 1
b = i - num
if b in dic:
count += dic[b]
print(count) | p02691 |
N=int(eval(input()))
a=list(map(int,input().split()))
ans=0
min_a=min(a)
for i in range(N-1,0,-1):
num=a[i]
for j in range(max(i-num+1-min_a,0)):
if a[j]+num==i-j:
ans+=1
print(ans)
| N=int(eval(input()))
a=list(map(int,input().split()))
ans=0
L={}
R={}
for i in range(N):
if a[i]+i in L:
k=L.get(a[i]+i)
del L[a[i]+i]
L[a[i]+i]=k+1
else:
L[a[i]+i]=1
if i-a[i]>0:
if i-a[i] in R:
k=R.get(i-a[i])
del R[i-a[i]]
R[i-a[i]]=k+1
else:
R[i-a[i]]=1
for x in list(L.keys()):
if x in R:
ans+=L.get(x)*R.get(x)
print(ans)
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
sorted_a = sorted(a, reverse = True)
max_a = sorted_a[0]
cnt = 0
ans = 0
for i in range(n - 1):
if a[i] == max_a:
cnt += 1
max_a = sorted_a[cnt]
for j in range(a[i] + i + 1, min(n, a[i] + i + max_a + 1)):
if a[i] + a[j] == j - i:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
dp = [0] * n
ans = 0
for i, j in enumerate(a):
if i + j < n:
dp[i + j] += 1
if 0 < i - j:
ans += dp[i - j]
print(ans) | p02691 |
from collections import defaultdict
import bisect
def f():
return []
d=defaultdict(f)
n=int(eval(input()))
a=list(map(int,input().split()))
x=[i+1+a[i] for i in range(n)]
y=[i+1-a[i] for i in range(n)]
for i in range(n):
d[y[i]].append(i)
ans=0
for i in range(n):
p=x[i]
ans+=len(d[p])-bisect.bisect_right(d[p],i)
print(ans) | from collections import defaultdict
import bisect
def f():
return []
d=defaultdict(f)
n=int(eval(input()))
a=list(map(int,input().split()))
x=[i+1+a[i] for i in range(n)]
y=[i+1-a[i] for i in range(n)]
for i in range(n):
d[y[i]].append(i)
ans=0
for i in range(n):
ans+=len(d[x[i]])
print(ans) | p02691 |
from collections import defaultdict
n=int(eval(input()))
a=list(map(int,input().split()))
d=defaultdict(int)
for i in range(n):
d[i+1-a[i]]+=1
print((sum(d[i+1+a[i]] for i in range(n)))) | from collections import defaultdict
n=int(eval(input()))
a=list(map(int,input().split()))
d=defaultdict(int)
for i in range(n):
d[i-a[i]]+=1
ans=0
for i in range(n):
ans+=d[i+a[i]]
print(ans) | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
for j in range(max(i,A[i]+1),N):
if j -i == A[i]+A[j]:
ans += 1
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
L = {}
R = {}
for i in range(N):
t = A[i]+i
if t in L:
L[t] += 1
else:
L[t] = 1
s = i - A[i]
if s in R:
R[s] += 1
else:
R[s] = 1
#print(L,R)
ans = 0
for i in range(N):
t = A[i]+i
#ans += R[t]
if t in list(R.keys()):
ans += R[t]
#print(t,R[t])
print(ans) | p02691 |
import bisect
n=int(eval(input()))
A=list(map(int,input().split()))
X=[A[i]-(i+1) for i in range(n)]
Y=[-A[i]-(i+1) for i in range(n)]
ans=0
X.sort()
for y in Y:
i=bisect.bisect_left(X,y)
for j in range(i,n):
if X[j]==y:
ans+=1
else:
break
print(ans) | from _collections import defaultdict
n=int(eval(input()))
A=list(map(int,input().split()))
X=[A[i]-(i+1) for i in range(n)]
Y=[-A[i]-(i+1) for i in range(n)]
ans=0
P=defaultdict(int)
Q=defaultdict(int)
for x in X:
P[x]+=1
for y in Y:
Q[y]+=1
p=set(P.keys())
q=set(Q.keys())
r=p&q
for key in r:
ans+=P[key]*Q[key]
print(ans)
| p02691 |
N = int(eval(input()))
A = [int(v) for v in input().split()]
count = 0
for i in range(len(A)-1):
for j in range(i+1,len(A)):
a1,a2 = A[i],A[j]
diff = j-i
if diff == a1+a2:
count += 1
print(count) | N = int(eval(input()))
A = [int(v) for v in input().split()]
L, R = {}, {}
for i,a in enumerate(A):
l,r = i+a,i-a
if l not in L: L[l]=0
if r not in R: R[r]=0
L[l]+=1
R[r]+=1
count = 0
for X in L:
if X not in R: continue
count += L[X]*R[X]
print(count) | p02691 |
from collections import Counter
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
minus = Counter([i-a[i] for i in range(n)])
plus = Counter([i+a[i] for i in range(n)])
cnt = 0
for i in minus:
if i in plus:
cnt += minus[i] * plus[i]
print(cnt)
| from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
minus = Counter([i - a[i] for i in range(n)])
plus = Counter([i + a[i] for i in range(n)])
cnt = 0
for i in minus:
if i in plus:
cnt += minus[i] * plus[i]
print(cnt)
| p02691 |
n = int(eval(input()))
a = list(map(int,input().split()))
plus = []
minus = []
for i in range(n):
plus.append(a[i]+i+1)
minus.append(i+1-a[i])
c = 0
for i in range(n-1):
for j in range(i,n):
if plus[i] == minus[j]:
c += 1
print(c) | n = int(eval(input()))
a = list(map(int,input().split()))
plus = dict()
minus = dict()
for i in range(n):
num = i+1
p = a[i] + num
m = num - a[i]
if p in plus:
plus[p] += 1
else:
plus[p] = 1
if (m) in minus:
minus[m] += 1
else:
minus[m] = 1
c = 0
for v in list(plus.keys()):
if v in minus:
c += plus[v] * minus[v]
print(c) | p02691 |
def solve(n, xs):
ans = 0
for i in range(n):
for j in range(i,n):
if abs(i-j) == xs[i] + xs[j]:
ans +=1
return ans
if __name__ == "__main__":
n = int(eval(input()))
xs = [int(i) for i in input().split()]
print((solve(n, xs)))
| def solve(n, xs):
ans = 0
tmp = {}
for i in range(n-1, -1, -1):
l = i+1 + xs[i]
r = i+1 - xs[i]
if l in tmp:
ans += tmp[l]
if r in tmp:
tmp[r] += 1
else:
tmp[r] = 1
return ans
if __name__ == "__main__":
n = int(eval(input()))
xs = [int(i) for i in input().split()]
print((solve(n, xs)))
| p02691 |
import itertools
N = int(eval(input()))
A = list(map(int,input().split()))
comb = itertools.combinations(list(range(N)), 2)
ans = 0
for c in comb:
if A[c[0]]+A[c[1]] == abs(c[0]-c[1]):
ans += 1
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
L={}
R={}
for i in range(1,len(A)+1):
L[str(i+A[i-1])] = L.get(str(i+A[i-1]),0)+1
R[str(i-A[i-1])] = R.get(str(i-A[i-1]),0)+1
ans = 0
for i in range(1,N+1):
if str(i) in L and str(i) in R:
ans += L[str(i)] * R[str(i)]
print(ans)
| p02691 |
n = int(eval(input()))
a = [int(i) for i in input().split()]
j_Aj = [0]
for j, aj in enumerate(a):
j_Aj.append(j + 1 - aj)
i_Ai = [0] * (max(j_Aj)+1)
ans = 0
for j, j_aj in enumerate(j_Aj):
if j == 0:
continue
if j_aj >= 2:
ans += i_Ai[j_aj]
if j + a[j - 1]<=max(j_Aj):
i_Ai[j + a[j - 1]] += 1
print(ans) | n = int(eval(input()))
a = [int(i) for i in input().split()]
j_Aj = [0]
for j, aj in enumerate(a):
j_Aj.append(j + 1 - aj)
maxj=max(j_Aj)
i_Ai = [0] * (maxj+1)
ans = 0
for j, j_aj in enumerate(j_Aj):
if j == 0:
continue
if j_aj >= 2:
ans += i_Ai[j_aj]
if j + a[j - 1]<=maxj:
i_Ai[j + a[j - 1]] += 1
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n-1):
for j in range(i+2, n):
if a[i] >= abs(i-j) or a[j] >= abs(i-j):
if a[i] > abs(i-(n-1)): break
else: continue
if abs(i-j) == a[i]+a[j]: ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
b = []
c = {}
ans = 0
for i in range(n):
b.append(a[i]+i+1)
x = -a[i]+i+1
if x in c:
c[x] += 1
else:
c[x] = 1
for i in range(n):
if b[i] in c:
ans += c[b[i]]
print(ans) | p02691 |
import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
del_n = [abs(x - y) for x, y in itertools.combinations(list(range(1, n+1)), 2)]
sum_a = [x + y for x, y in itertools.combinations(a, 2)]
# print(del_n)
# print(sum_a)
cnt = 0
for d, s in zip(del_n, sum_a):
if d == s:
cnt += 1
print(cnt)
| import itertools
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(1, n+1):
if n > a[i-1]:
for j in range(max(a[i-1], i+1), n+1):
if abs(i - j) == a[i-1] + a[j-1]:
cnt += 1
print(cnt)
| p02691 |
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}
ipnl = lambda n: [int(eval(input())) for _ in range(n)]
inp = lambda :int(eval(input()))
ip = lambda :[int(w) for w in input().split()]
mp = lambda :list(map(int,input().split()))
n = inp()
x = ip()
ctr = 0
for i in range(n-1):
for j in range(i+1,n):
if (j-i) == x[i]+x[j]:
ctr += 1
print(ctr) | #dt = {} for i in x: dt[i] = dt.get(i,0)+1
#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}
ipnl = lambda n: [int(eval(input())) for _ in range(n)]
inp = lambda :int(eval(input()))
ip = lambda :[int(w) for w in input().split()]
mp = lambda :list(map(int,input().split()))
n = inp()
x = ip()
ctr = 0
a = [i+x[i] for i in range(n)]
b = [i-x[i] for i in range(n)]
dt1 = {}
for i in a: dt1[i] = dt1.get(i,0)+1
dt2 = {}
for i in b: dt2[i] = dt2.get(i,0)+1
for i in dt1:
if i in dt2:
ctr += dt1[i]*dt2[i]
print(ctr) | p02691 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
B = [a+i for i, a in enumerate(A)]
C = [j-a for j, a in enumerate(A)]
b_min = min(B)
b_max = max(B)
B, C = Counter(B), Counter(C)
ans = 0
for k in range(b_min, b_max):
ans += B[k]*C[k]
print(ans) | from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
B = [a+i for i, a in enumerate(A)]
C = [j-a for j, a in enumerate(A)]
B, C = Counter(B), Counter(C)
ans = 0
for k in list(B.keys()):
ans += B[k]*C[k]
print(ans) | p02691 |
import itertools
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
h_list = list(map(int, input().split()))
c_list = list(itertools.combinations(list(range(N)),2))
ans = 0
for c in c_list:
if abs(c[0] - c[1]) == h_list[c[0]] + h_list[c[1]]:
ans += 1
print(ans)
if __name__ == '__main__':
main() | eval(input())
A = [int(h) for h in input().split()]
iph_dic = {}
pair_of_spies = 0
for i, h in enumerate(A):
if i - h in iph_dic:
pair_of_spies += iph_dic[i - h]
if i + h in iph_dic:
iph_dic[i + h] += 1
else:
iph_dic[i + h] = 1
print(pair_of_spies) | p02691 |
import itertools
import math
N=int(eval(input()))
*A,=list(map(int,input().split()))
def agent(a,i,j):
return abs(i-j)==abs(a[i-1]+a[j-1])
count=0
X=list(range(1,N+1))
for c in itertools.combinations(X,2):
if agent(A,*c):
count+=1
print(count)
|
N=int(eval(input()))
*A,=list(map(int,input().split()))
ref,count={},0
for i,a in enumerate(A):
if i-a in ref:
count += ref[i-a]
if i+a in ref:
ref[i+a]+=1
else:
ref[i+a]=1
print(count) | p02691 |
n=int(eval(input()))
a=[0]*n
a=list(map(int,input().split()))
L=[]
R=[]
ans=0
for i in range(n):
L.append(i-a[i])
R.append(i+a[i])
ans+=L.count(R[i])+R.count(L[i])
print(ans) | n=int(eval(input()))
a=[0]*n
a=list(map(int,input().split()))
L={}
R={}
ans=0
for i in range(n):
L.setdefault(i-a[i],0)
R.setdefault(i+a[i],0)
L[i-a[i]]+=1
R[i+a[i]]+=1
if (i-a[i] in R):
ans+=R[i-a[i]]
#print(ans,L[i-a[i]])
if (i+a[i] in L):
ans+=L[i+a[i]]
print(ans)
#print(L)
#print(R) | p02691 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
L = defaultdict(list)
R = defaultdict(list)
for i in range(N):
L[i + A[i]].append(i)
R[i - A[i]].append(i)
# print(L)
# print(R)
ans = 0
for k in list(L.keys()):
l = L[k]
r = R[k]
cnt = 0
for i in l:
for j in r:
if i < j:
ans += 1
print(ans) | from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
L = defaultdict(int)
R = defaultdict(int)
for i in range(N):
L[i + A[i]] += 1
R[i - A[i]] += 1
ans = 0
for k, v in list(L.items()):
ans += v * R[k]
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
vals = []
ans = 0
for i in range(1, n+1):
vals.append(i-a[i-1])
for i in range(n):
for v in range(n):
if(i+1+a[i] == vals[v] or i+1+a[i] == vals[v]):
ans+=1
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
vals = []
mappy = {}
ans = 0
for i in range(n):
if(i+1-a[i] > 0):
if(i+1-a[i] in mappy):
mappy[i+1-a[i]]+=1
else:
mappy[i+1-a[i]] =1
for i in range(n):
if(i+1+a[i]in mappy):
ans+=mappy[i+1+a[i]]
print(ans)
| p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
for i in range(N):
if i!= N-1:
for j in range(N-i-1):
if (N-j-1)-i == A[i] + A[N-j-1]:
ans += 1
print(ans) | # 二分探索モジュール bisect
# 添字はiとjの分で相殺(本当の添字は+1が必要だが[(i+1)-(j+1)]なのでいらない(以下は式変形))
import bisect
N = int(eval(input()))
A = list(map(int, input().split()))
X = [A[i]+i for i in range(N)]
Y = [j - A[j] for j in range(N)]
ans = 0
Y.sort()
for i in range(N):
ans += bisect.bisect_right(Y,X[i]) - bisect.bisect_left(Y,X[i])
print(ans)
'''
bisect 二分探索モジュール
A = [1,1,3,3,3,4,5,6]
B = 3
bisect.bisect_left(A, b) 配列Aにbが左から何番目に入るかを返す #2
bisect.bisect_right(A,b) 配列Aにbが右から何晩目に入るかを返す #5
''' | p02691 |
N = int(eval(input()))
A = list(map(int, input().split()))
m = A[0]
c = 0
for i in range(1, N):
if i < m+A[i]:
m = min(m, A[i])
else:
for j in range(0, i):
if A[i] + A[j] == i - j:
c += 1
m = min(m, A[i])
print(c) | N = int(eval(input()))
A = list(map(int, input().split()))
L = [ i+1+A[i] for i in range(N) ]
R = [j+1-A[j] for j in range(N) ]
Ld = {}
Rd = {}
for i in range(N):
if R[i] in list(Rd.keys()):
Rd[R[i]] += 1
else:
Rd[R[i]] = 1
ans = 0
for i in range(N):
if L[i] in list(Rd.keys()):
ans += Rd[L[i]]
if L[i] == R[i]:
ans -= 1
print(ans) | p02691 |
import itertools
N = int(eval(input()))
A = list(map(int,input().split()))
N_comb = list(itertools.combinations([n for n in range(1,N+1)],2))
cnt = 0
for i in range(len(N_comb)):
x = N_comb[i][0]
y = N_comb[i][1]
if abs(x-y)==A[x-1]+A[y-1]:
cnt = cnt + 1
del N_comb
print(cnt) | N = int(eval(input()))
A = list(map(int,input().split()))
cnt = 0
for i in range(0,N):
for j in range(i+1,N):
if abs(i-j) == A[i]+A[j]:
cnt = cnt + 1
print(cnt) | p02691 |
n = int(eval(input()))
a = list(map(int,input().split()))
i = 0
j = 1
ans = 0
p = 0
nextj = 0
while True:
if j == n:
i += 1
p = 0
j = min(n-1,min(i+a[i]+1,nextj))
if p == 0 and a[i] + a[j] == j-i:
ans += 1
nextj = j
p = 1
elif p == 1 and a[i] + a[j] == j-i:
ans += 1
j += 1
if i == n-1:
print(ans)
exit()
| n = int(eval(input()))
a = list(map(int,input().split()))
mae = {}
ans = 0
for i in range(n):
mae[i+a[i]]=mae.get(i+a[i],0)+1
ans += mae.get(i-a[i],0)
print(ans) | p02691 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
heights = list(map(int, input().split()))
cnt_height_plus_ind = {}
cnt_height_minus_ind = {}
cnt_ind_minus_height = {}
cnt_minus_height_minus_ind = {}
for ind in range(N):
height = heights[ind]
if ind - height not in cnt_ind_minus_height:
cnt_ind_minus_height[ind - height] = 0
cnt_ind_minus_height[ind - height] += 1
if ind + height not in cnt_height_plus_ind:
cnt_height_plus_ind[ind + height] = 0
cnt_height_plus_ind[ind + height] += 1
if height - ind not in cnt_height_minus_ind:
cnt_height_minus_ind[height - ind] = 0
cnt_height_minus_ind[height - ind] += 1
if - ind - height not in cnt_minus_height_minus_ind:
cnt_minus_height_minus_ind[-ind-height] = 0
cnt_minus_height_minus_ind[-ind-height] += 1
ans = 0
for val in cnt_height_minus_ind:
if val in cnt_minus_height_minus_ind:
ans += cnt_height_minus_ind[val] * cnt_minus_height_minus_ind[val]
for val in cnt_height_plus_ind:
if val in cnt_ind_minus_height:
ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val]
print((ans//2)) | import sys
input = sys.stdin.readline
N = int(eval(input()))
heights = list(map(int, input().split()))
cnt_height_plus_ind = {}
cnt_height_minus_ind = {}
cnt_ind_minus_height = {}
cnt_minus_height_minus_ind = {}
for ind in range(N):
height = heights[ind]
if ind - height not in cnt_ind_minus_height:
cnt_ind_minus_height[ind - height] = 0
cnt_ind_minus_height[ind - height] += 1
if ind + height not in cnt_height_plus_ind:
cnt_height_plus_ind[ind + height] = 0
cnt_height_plus_ind[ind + height] += 1
if height - ind not in cnt_height_minus_ind:
cnt_height_minus_ind[height - ind] = 0
cnt_height_minus_ind[height - ind] += 1
if - ind - height not in cnt_minus_height_minus_ind:
cnt_minus_height_minus_ind[-ind-height] = 0
cnt_minus_height_minus_ind[-ind-height] += 1
ans = 0
#for val in cnt_height_minus_ind:
# if val in cnt_minus_height_minus_ind:
# ans += cnt_height_minus_ind[val] * cnt_minus_height_minus_ind[val]
for val in cnt_height_plus_ind:
if val in cnt_ind_minus_height:
ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val]
print(ans) | p02691 |
import sys
input = sys.stdin.readline
N = int(eval(input()))
heights = list(map(int, input().split()))
cnt_height_plus_ind = {}
cnt_height_minus_ind = {}
cnt_ind_minus_height = {}
cnt_minus_height_minus_ind = {}
for ind in range(N):
height = heights[ind]
if ind - height not in cnt_ind_minus_height:
cnt_ind_minus_height[ind - height] = 0
cnt_ind_minus_height[ind - height] += 1
if ind + height not in cnt_height_plus_ind:
cnt_height_plus_ind[ind + height] = 0
cnt_height_plus_ind[ind + height] += 1
if height - ind not in cnt_height_minus_ind:
cnt_height_minus_ind[height - ind] = 0
cnt_height_minus_ind[height - ind] += 1
if - ind - height not in cnt_minus_height_minus_ind:
cnt_minus_height_minus_ind[-ind-height] = 0
cnt_minus_height_minus_ind[-ind-height] += 1
ans = 0
#for val in cnt_height_minus_ind:
# if val in cnt_minus_height_minus_ind:
# ans += cnt_height_minus_ind[val] * cnt_minus_height_minus_ind[val]
for val in cnt_height_plus_ind:
if val in cnt_ind_minus_height:
ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val]
print(ans) | N = int(eval(input()))
heights = list(map(int, input().split()))
cnt_height_plus_ind = {}
cnt_ind_minus_height = {}
for ind in range(N):
height = heights[ind]
if ind - height not in cnt_ind_minus_height:
cnt_ind_minus_height[ind - height] = 0
cnt_ind_minus_height[ind - height] += 1
if ind + height not in cnt_height_plus_ind:
cnt_height_plus_ind[ind + height] = 0
cnt_height_plus_ind[ind + height] += 1
ans = 0
for val in cnt_height_plus_ind:
if val in cnt_ind_minus_height:
ans += cnt_height_plus_ind[val] * cnt_ind_minus_height[val]
print(ans) | p02691 |
from collections import defaultdict
d = defaultdict(int)
N = int(eval(input()))
arr = list(map(int, input().split()))
ans = 0
for i in range(N):
ans += d[(i+1)-arr[i]]
d[(i+1)+arr[i]] += 1
print(ans) | from collections import defaultdict
N = int(eval(input()))
arr = list(map(int, input().split()))
d = defaultdict(int)
ans = 0
for i in range(N):
if i-arr[i] >= 0:
ans += d[i-arr[i]]
d[i+arr[i]] += 1
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
if abs(j-i) == a[i]+a[j]:
ans += 1
print(ans) | import sys
# sys.stdin = open('input.txt')
# i < j
# j - i == Ai + Aj
# j - Aj == i + Ai
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
# key: i + Ai, value: count
d = {}
for j in range(n):
a1 = j - a[j]
try:
ans += d[a1]
except KeyError:
d[a1] = 0
a2 = j + a[j]
try:
d[a2] += 1
except KeyError:
d[a2] = 1
print(ans) | p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
if abs(i-j) == a[i]+a[j]:
ans += 1
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
L = {}
R = {}
for i in range(n):
if i + a[i] in L:
L[i + a[i]] = L[i + a[i]] + 1
else:
L[i + a[i]] = 1
if i - a[i] in R:
R[i - a[i]] = R[i - a[i]] + 1
else:
R[i - a[i]] = 1
#print(L,R,sep="\n")
ans = 0
for key in list(L.keys()):
if key in R:
#print(L[key], R[key])
ans += L[key] * R[key]
print(ans)
"""
ans = 0
for i in range(n):
for j in range(i+1, n):
if abs(i-j) == a[i]+a[j]:
ans += 1
print(ans)
"""
| p02691 |
n = int(eval(input()))
L, R = [0] * n, [0] * n
i = 0
for ipt in input().split():
L[i] = i + int(ipt)
R[i] = i - int(ipt)
i += 1
def make_dic(L):
L_set = set(L)
return dict([(i, L.count(i)) for i in L_set])
L_dic, R_dic = make_dic(L), make_dic(R)
cnt = 0
for Lk, Lv in list(L_dic.items()):
try:
cnt += R_dic[Lk] * Lv
except KeyError:
pass
print(cnt) | n = int(eval(input()))
L_dict, R_dict = {}, {}
i = 0
for ipt in input().split():
try:
L_dict[i + int(ipt)] += 1
except KeyError:
L_dict[i + int(ipt)] = 1
try:
R_dict[i - int(ipt)] += 1
except KeyError:
R_dict[i - int(ipt)] = 1
i += 1
cnt = 0
for Lk, Lv in list(L_dict.items()):
try:
cnt += R_dict[Lk] * Lv
except KeyError:
pass
print(cnt) | p02691 |
#!python3
from collections import defaultdict
iim = lambda: list(map(int, input().rstrip().split()))
def resolve():
N = int(eval(input()))
A = list(iim())
d1 = defaultdict(int)
d2 = defaultdict(int)
for i, ai in enumerate(A):
d1[i+ai] += 1
d2[i-ai] += 1
ans = 0
for k, v in list(d1.items()):
if k in d2:
ans += v * d2[k]
print(ans)
if __name__ == "__main__":
resolve()
| #!python3
from collections import defaultdict
iim = lambda: list(map(int, input().rstrip().split()))
def resolve():
N = int(eval(input()))
A = list(iim())
ans = 0
dp = [0]*N
for i, ai in enumerate(A):
x = i + ai
if x < N:
dp[x] += 1
x = i - ai
if x >= 0:
ans += dp[x]
print(ans)
if __name__ == "__main__":
resolve()
| p02691 |
N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
p = [i + A[i] for i in range(N)]
m = [j - A[j] for j in range(N)]
a = min(p)
b = max(m)
for i in range(a,b+1):
if i in p and i in m:
ans += p.count(i) * m.count(i)
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
ans = 0
p = {}
m = {}
for i in range(N):
if p.get(i+A[i]) is None:
p[i+A[i]] = 1
else:
p[i+A[i]] += 1
for i in range(N):
if m.get(i-A[i]) is None:
m[i-A[i]] = 1
else:
m[i-A[i]] += 1
for x in range(min(p),max(m)+1):
if x in p and x in m:
ans += p[x] * m[x]
print(ans) | p02691 |
N = int(eval(input())) + 1
A = [0] + [int(i) for i in input().split()]
MAX_I = 10 ** 9
cnt = 0
for i in range(1, N):
if MAX_I >= i + A[i]:
for j in range(i + A[i], N):
if (j - i) == (A[i] + A[j]):
cnt += 1
print(cnt) | N = int(eval(input()))
A = [int(i) for i in input().split()]
i_Ai = {}
cnt = 0
for i, h in enumerate(A):
imh = i - h
if imh in i_Ai:
cnt += i_Ai[imh]
iph = i + h
if iph in i_Ai:
i_Ai[iph] += 1
else:
i_Ai[iph] = 1
print(cnt) | p02691 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
maxVal = N + max(A)
ans = 0
L = defaultdict(int)
R = defaultdict(int)
for x in range(1, maxVal+1):
for i in range(1, N+1):
if i + A[i-1] == x:
L[i+A[i-1]] += 1
for j in range(1, N+1):
if j - A[j-1] == x:
R[j-A[j-1]] += 1
for x in range(1, maxVal+1):
ans += L[x] * R[x]
print(ans)
| from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
maxVal = N + max(A)
ans = 0
candidatesL = defaultdict(int)
for i in range(1, N+1):
candidatesL[i+A[i-1]] += 1
candidatesR = defaultdict(int)
for j in range(1, N+1):
candidatesR[j-A[j-1]] += 1
ans = 0
for x in list(candidatesL.keys()):
ans += candidatesL[x] * candidatesR[x]
print(ans)
| p02691 |
n = int(eval(input()))
a = list(map(int, input().split()))
c = 0
for i in range(n):
for j in range(i+1, n):
if max(i-j, j-i) == a[i]+a[j]:
c +=1
print(c) | n = int(eval(input()))
A = list(map(int, input().split()))
# a+i と i-aのとりうる値の個数をカウントするが
# 一致するとしても[0, n)の範囲だけなのでDの大きさはnで十分
D = [0]*n
for i, a in enumerate(A):
if 1+i+a < n:
D[i+a] += 1
ans = 0
# i-aに対応するD[i-a]を加えるだけで答えが求まる
for i, a in enumerate(A):
if 1+i-a >= 0:
ans += D[i-a]
print(ans) | p02691 |
N = int(eval(input()))
A = tuple(map(int, input().split()))
AI = tuple(i + a for i, a in enumerate(A))
AJ = tuple(i - a for i, a in enumerate(A))
count = 0
for k in range(0, max(AI)):
ci = AI.count(k)
cj = AJ.count(k)
count += ci * cj
print(count) | N = int(eval(input()))
A = tuple(map(int, input().split()))
AI = tuple(i + a for i, a in enumerate(A))
AJ = tuple(i - a for i, a in enumerate(A))
cai = {}
caj = {}
vali = set()
valj = set()
for ai, aj in zip(AI, AJ):
if not ai in cai:
cai[ai] = 0
if not aj in caj:
caj[aj] = 0
cai[ai] += 1
vali.add(ai)
caj[aj] += 1
valj.add(aj)
count = 0
for val in vali & valj:
count += cai[val] * caj[val]
print(count) | p02691 |
n = int(eval(input()))
A = list(map(int, input().split()))
D1 = {}
D2 = {}
def count(D, s):
if s in D:
D[s] += 1
else:
D[s] = 1
for i, a in enumerate(A):
count(D1, a+i)
count(D2, i-a)
ans = 0
for d, num in list(D1.items()):
if d in D2:
ans += num * D2[d]
print(ans) | n = int(eval(input()))
A = list(map(int, input().split()))
# a+i と i-aのとりうる値の個数をカウントするが
# 一致するとしても[0, n)の範囲だけなのでDの大きさはnで十分
D = [0]*n
for i, a in enumerate(A):
if i+a < n:
D[i+a] += 1
ans = 0
# i-aに対応するD[i-a]を加えるだけで答えが求まる
for i, a in enumerate(A):
if i-a >= 0:
ans += D[i-a]
print(ans) | p02691 |
#!/usr/bin/env python
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
for i in range(n-1):
b = a[i]
c = 0
for j in range(i+b, n):
if a[j] == c:
cnt += 1
c += 1
print(cnt)
if __name__ == '__main__':
main()
| #!/usr/bin/env python
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
lst1 = [0] * n
lst2 = [0] * n
for i in range(1, n+1):
p = i - a[i-1]
q = i + a[i-1]
if 0 <= p < n:
lst1[p] += 1
if 0 <= q < n:
lst2[q] += 1
for i in range(n):
cnt += lst1[i] * lst2[i]
print(cnt)
if __name__ == '__main__':
main()
| p02691 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import collections
# 標準入力の取得
N = int(eval(input()))
A = list(map(int, input().split()))
# 求解処理
# A_i + i = -A_j + j (i < j)
left = [A[i] + i for i in range(N)]
right = collections.Counter([-A[j] + j for j in range(N)])
result = 0
for l in left:
result += right[l]
# 結果出力
print(result)
| # -*- coding: utf-8 -*-
# モジュールのインポート
import collections
# 標準入力の取得
N = int(eval(input()))
A = list(map(int, input().split()))
# 求解処理
left = {}
result = 0
for j in range(N):
r = -A[j] + j
result += left.get(r, 0)
l = A[j] + j
left[l] = left.get(l, 0) + 1
# 結果出力
print(result)
| p02691 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import collections
# 標準入力の取得
N = int(eval(input()))
A = list(map(int, input().split()))
# 求解処理
left = {}
result = 0
for j in range(N):
r = -A[j] + j
result += left.get(r, 0)
l = A[j] + j
left[l] = left.get(l, 0) + 1
# 結果出力
print(result)
| # -*- coding: utf-8 -*-
# 標準入力の取得
N = int(eval(input()))
A = list(map(int, input().split()))
def main() -> None:
"""Entry point
"""
# 求解処理
"""
1 <= i < j <= Nとすると、
j - i = A_i + A_j ⇒ -A_j + j = A_i +i
となる。
したがって、各jについて、左辺の値を計算し、等式が成立するようなi(< j)の個数を求めればよい。
"""
right = {}
result = 0
for j in range(N):
l = -A[j] + j
result += right.get(l, 0)
r = A[j] + j
right[r] = right.get(r, 0) + 1
# 結果出力
print(result)
if __name__ == "__main__":
main()
| p02691 |
from sys import stdin
n = int(stdin.readline().rstrip())
an = list(map(int, input().split()))
l = {}
r = {}
for i in range(n):
x = i + an[i]
if x not in l:
l[x] = [i]
else:
l[x].append(i)
x = i - an[i]
if x not in r:
r[x] = [i]
else:
r[x].append(i)
sum = 0
for k in l:
if k in r:
for i in range(len(l[k])):
for j in range(len(r[k])):
if l[k][i] != r[k][j]:
sum += 1
print(sum)
| from sys import stdin
n = int(stdin.readline().rstrip())
an = list(map(int, input().split()))
l = {}
r = {}
for i in range(n):
x = i + an[i]
if x not in l:
l[x] = [i]
else:
l[x].append(i)
x = i - an[i]
if x not in r:
r[x] = [i]
else:
r[x].append(i)
sum = 0
for k in l:
if k in r:
sum += len(l[k])*len(r[k])
print(sum)
| p02691 |
from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
l=[]
r=[]
for i,j in enumerate(a):
l.append(i+j)
r.append(i-j)
#ref = dict(Counter(r))
#ans = 0
#for i in l:
# ans += ref.get(i, 0)
#print(ans)
for i in l:
ans+=r.count(i)
print(ans) | from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
l=[]
r=[]
for i,j in enumerate(a):
l.append(i+j)
r.append(i-j)
#ref = dict(Counter(r))
#ans = 0
#for i in l:
# ans += ref.get(i, 0)
#print(ans)
b=Counter(r)
for i in l:
ans+=b.get(i,0)
print(ans) | p02691 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.