input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,m=list(map(int,input().split()))
a=[[int(j) for j in input().split()] for i in range(n)]
c=[[int(j) for j in input().split()] for i in range(m)]
for i in range(n):
d=10e8
b=0
for j in range(m):
if abs(a[i][0]-c[j][0])+abs(a[i][1]-c[j][1])<d:
d=abs(a[i][0]-c[j][0])+abs(a[i][1]-c[j][1])
b=j+1
print(b) | n,m=list(map(int,input().split()))
ab=[[int(j) for j in input().split()] for i in range(n)]
cd=[[int(j) for j in input().split()] for i in range(m)]
for a,b in ab:
l=[abs(a-c)+abs(b-d) for c,d in cd]
print((l.index(min(l))+1)) | p03774 |
N,M = list(map(int,input().split()))
students = [list(map(int,input().split()))for i in range(N)]
checkPoints = [list(map(int,input().split()))for i in range(M)]
for i in range(N):
idx = -1
mindis = 3*10**8
sx,sy = students[i]
for j in range(M):
cx,cy = checkPoints[j]
distance = abs(sx-cx)+ abs(sy-cy)
if mindis > distance:
idx = j+1
mindis = distance
print(idx)
| N,M = list(map(int,input().split()))
students = [list(map(int,input().split()))for i in range(N)]
checkPoints = [list(map(int,input().split()))for i in range(M)]
for i in range(N):
idx = 1
mindis = abs(students[i][0]-checkPoints[0][0])+ abs(students[i][1]-checkPoints[0][1])
sx,sy = students[i]
for j in range(1,M):
cx,cy = checkPoints[j]
distance = abs(sx-cx)+ abs(sy-cy)
if mindis > distance:
idx = j+1
mindis = distance
print(idx)
| p03774 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf')
ans = 0 ;count = 0 ;pro = 1
n,m=list(map(int,input().split()))
ab=[tuple(map(int,input().split())) for i in range(n)]
cd=[tuple(map(int,input().split())) for i in range(m)]
for a,b in ab:
tmp=inf
candi=0
for j in range(m):
c=cd[j][0]
d=cd[j][1]
k=abs(a-c)+abs(b-d)
if tmp>k:
tmp=k
candi=j
print((candi+1))
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,m = list(map(int,input().split()))
CD = [tuple(map(int,input().split())) for i in range(n)]
AB = [tuple(map(int,input().split())) for i in range(m)]
for c,d in CD:
print((min(list(range(m)),key = lambda x:abs(AB[x][0]-c) + abs(AB[x][1]-d))+1))
| p03774 |
import math
INF = 1001001001
def resolve():
n, m = list(map(int, input().split()))
s = []
c = []
for i in range(n):
a, b = list(map(int, input().split()))
s.append([a, b])
for i in range(m):
a, b = list(map(int, input().split()))
c.append([a, b])
for a in s:
ans = 0
dist = INF
for i in range(m):
if abs(a[0] - c[i][0]) + abs(a[1] - c[i][1]) < dist:
dist = abs(a[0] - c[i][0]) + abs(a[1] - c[i][1])
ans = i+1
print(ans)
return
if __name__ == "__main__":
resolve()
| def resolve():
n, m = list(map(int, input().split()))
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
cd = []
for i in range(m):
cd.append(list(map(int, input().split())))
for a in ab:
ans = 0
dist = 10000000000
for i in range(m):
tmp = abs(a[0] - cd[i][0]) + abs(a[1] - cd[i][1])
if tmp < dist:
ans = i+1
dist = tmp
print(ans)
return
if __name__ == "__main__":
resolve()
| p03774 |
N,M = map(int,input().split())
st = [tuple(map(int,input().split())) for i in range(N)]
ch = [tuple(map(int,input().split())) for i in range(M)]
ans = []
for sx,sy in st:
minci = 1
mind = float('inf')
for i,(cx,cy) in enumerate(ch):
d = abs(sx-cx) + abs(sy-cy)
if d < mind:
mind = d
minci = i+1
ans.append(str(minci))
print(*ans, sep='\n')
| N,M = list(map(int,input().split()))
A = [tuple(map(int,input().split())) for i in range(N)]
C = [tuple(map(int,input().split())) for i in range(M)]
for ax,ay in A:
min_d = 10**10
min_i = -1
for i,(cx,cy) in enumerate(C):
d = abs(ax-cx) + abs(ay-cy)
if d < min_d:
min_d = d
min_i = i
print((min_i + 1)) | p03774 |
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(N)]
cd = [list(map(int, input().split())) for _ in range(M)]
ans = []
for i in range(N):
index = 0
lowest = pow(10, 8) * 4
for j in range(M):
dist = abs(ab[i][0] - cd[j][0]) + abs(ab[i][1] - cd[j][1])
if lowest > dist:
lowest = dist
index = j
print((index + 1))
| n, m = list(map(int, input().split()))
ss = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(m)]
INF = 10 ** 8 * 4
for s in ss:
dist = INF
c_point = 0
a, b = s
for i, v in enumerate(p):
c, d = v
manhattan = abs(a - c) + abs(b - d)
if manhattan < dist:
c_point = i + 1
dist = manhattan
print(c_point)
| p03774 |
N, M = list(map(int, input().split(" ")))
student = [];
pos = [];
for i in range(N) :
a, b = list(map(int, input().split(" ")))
student.append((a, b))
for i in range(M) :
a, b = list(map(int, input().split(" ")))
pos.append((a,b))
for st in student :
ans = -1;
score = 10**10;
for i in range(M) :
tmpscore = abs(st[0] - pos[i][0]) + abs(st[1] - pos[i][1])
if score > tmpscore :
score = tmpscore;
ans = i;
print((ans+1)); | N, M = list(map(int, input().split()))
student = [ tuple( map(int, input().split()) ) for x in range(N)]
point = [ tuple( map(int, input().split()) ) for x in range(M)]
for (x1, y1) in student :
data = [ abs(x1 - x2) + abs(y1 - y2) for (x2, y2) in point ]
ans = data.index(min(data))
print((ans + 1)) | p03774 |
N, M = list(map(int, input().split()))
ab = [tuple(map(int, input().split())) for i in range(N)]
cd = [tuple(map(int, input().split())) for i in range(M)]
for a, b in ab:
ret = -1
dis = 10**20
for i, x in enumerate(cd):
c, d = x
if dis > abs(c-a) + abs(d-b):
dis = abs(c-a) + abs(d-b)
ret = i
print((ret+1))
| N, M = map(int, input().split())
ab = [tuple(map(int, input().split())) for i in range(N)]
cd = [tuple(map(int, input().split())) for j in range(M)]
ans = [0]*N
for i, x in enumerate(ab):
a, b = x
D = 10**9
for j, y in enumerate(cd):
c, d = y
dis = abs(a-c) + abs(b-d)
if dis < D:
D = dis
ans[i] = j + 1
print(*ans, sep='\n')
| p03774 |
n,m=map(int,input().split())
ab=[list(map(int,input().split())) for i in range(n)]#学生の位置
cd=[list(map(int,input().split())) for i in range(m)]#ゴール
l=[0]*n
for i in range(n):
ans=10**18
for j in range(m):
a=abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1])
if ans>a:
ans=a
l[i]=j+1
if ans==0:
break
print(*l,sep='\n')
| n,m=list(map(int,input().split()))
ab=[list(map(int,input().split())) for i in range(n)]
cd=[list(map(int,input().split())) for i in range(m)]
for i in range(n):
x=ab[i][0]
y=ab[i][1]
ans = [float('inf')] * 2
for j in range(m):
man=abs(x-cd[j][0])+abs(y-cd[j][1])
if ans[0]>man:
ans=[man,j+1]
print((ans[1]))
| p03774 |
N,M = [int(c) for c in input().split()]
ab = [list(map(int,input().split())) for c in range(N)]
cd = [list(map(int,input().split())) for c in range(M)]
for i in range(N):
mi = 2*10**9
for j in range(M):
tmp = abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1])
if mi > tmp:
mi = tmp
ans = j+1
print(ans)
| N,M = [int(c) for c in input().split()]
ab = [list(map(int,input().split())) for c in range(N)]
cd = [list(map(int,input().split())) for c in range(M)]
for i in range(N):
mi = 10**9
for j in range(M):
tmp = abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1])
if mi > tmp:
mi = tmp
ans = j+1
print(ans)
| p03774 |
n, m = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for i in range(n)]
CD = [[int(i) for i in input().split()] for i in range(m)]
for a, b in AB:
dist = [abs(a - c) + abs(b - d) for c, d in CD]
print((dist.index(min(dist)) + 1)) | n, m = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for i in range(n)]
CD = [[int(i) for i in input().split()] for i in range(m)]
for ab in AB:
ans = 10 ** 12
id = 0
for i, cd in enumerate(CD):
tmp = abs(ab[0] - cd[0]) + abs(ab[1] - cd[1])
if tmp < ans:
ans = tmp
id = i + 1
print(id) | p03774 |
n, m = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(n)]
B = [list(map(int, input().split())) for i in range(m)]
ans = []
for a in A:
cur = float('inf')
for i, b in enumerate(B):
x = abs(a[0] - b[0]) + abs(a[1] - b[1])
if x < cur:
cur = x
checkpoint = i + 1
ans.append(checkpoint)
for i in range(n):
print((ans[i])) | n, m = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(n)]
CD = [list(map(int, input().split())) for i in range(m)]
for a, b in AB:
dist = [[abs(a - c) + abs(b - d)] for c, d in CD]
print((dist.index(min(dist)) + 1)) | p03774 |
#!/usr/bin/env python3
import sys
import heapq
import copy
import itertools
inf = float('inf')
a = '.'
b = '#'
class Graph_dijkstra(object):
def __init__(self, V: "List[int]", E: "Set[Tuple[Tuple, Tuple]]", L: "Dict[Tuple[Tuple, Tuple], int]"):
self.V = V
self.E = E
self.L = L
self.adjacent = self.init_adjacent() # type: Dict[int: List[int]]
self.shortest_path = self.init_shortest_path() # type: Dict[FrozenSet[int, int], int]
def init_adjacent(self):
ret = {v: [] for v in self.V}
for e in self.E:
ret[e[0]].append(e[1])
return ret
def init_shortest_path(self):
ret = {(s, g): inf for s, g in itertools.permutations(self.V, 2)}
for v in self.V:
ret[(v, v)] = 0
return ret
def dijkstra(self, s: int):
D = {v: inf for v in self.V}
D[s] = 0
prev = {v: None for v in self.V}
Q = [(0, s)]
while len(Q) > 0:
du, u = heapq.heappop(Q)
for v in self.adjacent[u]:
e = (u, v)
alt = du + self.L[e]
if alt < D[v]:
D[v] = alt
prev[v] = u
heapq.heappush(Q, (D[v], v))
for v in self.V:
self.shortest_path[(s, v)] = D[v]
def find_shortest_path(self, s: int, g:int):
d = self.shortest_path[(s, g)]
if d < inf:
return d
self.dijkstra(s)
return self.shortest_path[(s, g)]
def solve(H, W, s):
V = []
E = set()
L = dict()
direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
field = [[b for w in range(W+2)] for h in range(H+2)]
white_count = 0
for h in range(H):
field[1+h][1:W+1] = s[h]
for h in range(H):
for w in range(W):
if field[1+h][1+w] == b:
continue
V.append((1+h, 1+w))
white_count += 1
for d in direction:
if field[1+h+d[0]][1+w+d[1]] == b:
continue
e = ((1+h, 1+w), (1+h+d[0], 1+w+d[1]))
E.add(e)
L[e] = 1
G = Graph_dijkstra(V, E, L)
path_length = G.find_shortest_path((1, 1), (H, W))
if path_length == inf:
print((-1))
else:
print((white_count - (path_length + 1)))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
s = [[c for c in next(tokens)] for _ in range(H)] # type: "List[str]"
solve(H, W, s)
pass
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import heapq
import copy
import itertools
inf = float('inf')
a = '.'
b = '#'
def solve(H, W, s):
white_count = sum([line.count(a) for line in s])
field = [[b for w in range(W+2)] for h in range(H+2)]
for h in range(H):
field[1+h][1:W+1] = s[h]
D = {(h, w): inf for h, w in itertools.product(list(range(H+2)), list(range(W+2)))}
start = (1, 1)
D[start] = 1
Q = [(D[start], start)]
direction = [(1, 0), (0, 1), (-1, 0), (0, -1)]
while len(Q) > 0:
Du, u = heapq.heappop(Q)
for d in direction:
v = (u[0]+d[0], u[1]+d[1])
if field[u[0]+d[0]][u[1]+d[1]] == b:
continue
if Du + 1 < D[v]:
D[v] = Du + 1
heapq.heappush(Q, (D[v], v))
path_length = D[(H, W)]
if path_length == inf:
print((-1))
return
print((white_count - path_length))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
s = [[c for c in next(tokens)] for _ in range(H)] # type: "List[str]"
solve(H, W, s)
pass
if __name__ == '__main__':
main()
| p03436 |
mod = 1000000007
n= int(eval(input()))
a= list(map(int,input().split()))
check = [0]*(n+1)
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n+1+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
def cmb2(n,r):
mod = 1000000007
if (r<0 or r>n ):return 0
r = min(r, n-r)
return g1[n]*g2[r]*g2[n-r]%mod
r=-1
jn=-1
for i in range(n+1):
check[a[i]-1]+=1
if check[a[i]-1]==2:
jn,r=a[i],i
break
l=a.index(jn)
s = min(l,n-r)
t = max(l,n-r)
print(n)
for p in range(2,n+1):
w2=cmb2(n+1,p)
x=p-t-1
y=s
yobun=0
for k in range(max(p-t-1,0),s+1):
if p-t-1<=k<=s:
yobun+=cmb2(s,k)*cmb2(t,p-k-1)
print((((w2+mod)-yobun) % mod))
print((1))
| mod = 1000000007
n= int(eval(input()))
a= list(map(int,input().split()))
check = [0]*(n+1)
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n+1+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
def cmb2(n,r):
mod = 1000000007
if (r<0 or r>n ):return 0
r = min(r, n-r)
return g1[n]*g2[r]*g2[n-r]%mod
r=-1
jn=-1
for i in range(n+1):
check[a[i]-1]+=1
if check[a[i]-1]==2:
jn,r=a[i],i
break
l=a.index(jn)
s = min(l,n-r)
t = max(l,n-r)
print(n)
for p in range(2,n+1):
w2=cmb2(n+1,p)
y2=cmb2(s+t,p-1)
print((((w2+mod)-y2) % mod))
print((1)) | p03674 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
n = int(eval(input()))
a = [int(i) for i in input().split()]
factorial = [1]
for i in range(1,n+2):
tmp = factorial[-1]*i
factorial.append(tmp)
def combinations_count(n,r):
if n-r < 0:
return 0
return factorial[n]//(factorial[n-r]*factorial[r])
A = copy.deepcopy(a)
A.sort()
for i in range(n+1):
if A[i] == A[i+1]:
double = A[i]
break
cnt = 0
for i in range(n+1):
if a[i] == double:
if cnt == 0:
l = i+1
cnt += 1
else:
r = i+1
# print(l,r)
for k in range(1,n+2):
# print(n+1,k,l+n-r,k-1)
ans = (combinations_count(n+1,k)-combinations_count((l+n-r),(k-1)))%mod
print(ans)
| # encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
n = int(eval(input()))
a = [int(i) for i in input().split()]
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, n+2):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod-2, mod))
def combinations_count(n,r):
if n-r < 0:
return 0
return factorial[n]*inverse[r]*inverse[n-r]%mod
A = copy.deepcopy(a)
A.sort()
for i in range(n+1):
if A[i] == A[i+1]:
double = A[i]
break
cnt = 0
for i in range(n+1):
if a[i] == double:
if cnt == 0:
l = i+1
cnt += 1
else:
r = i+1
# print(l,r)
for k in range(1,n+2):
# print(n+1,k,l+n-r,k-1)
ans = (combinations_count(n+1,k)-combinations_count((l+n-r),(k-1)))%mod
print(ans)
| p03674 |
from statistics import mode
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
# 2回表れている値とそのインデックスを取得
C = mode(A)
C_indexes = [i for i, x in enumerate(A) if x == C]
# 二つのCの外側にそれぞれ何個ずつあるか
outside = C_indexes[0] + len(A) - C_indexes[1] - 1
# 階乗・逆元の値を保存
factorial = [1]
inverse = [1]
for i in range(1, N+2):
factorial.append(factorial[-1]*i % MOD)
inverse.append((pow(factorial[i], MOD-2, MOD)))
# combination計算
def nCr(n, r):
if n<r or n==0 or r==0:
return 0
return factorial[n] * inverse[r] * inverse[n-r] % MOD
print(N)
for i in range(2, N+2):
print((int(nCr(N+1, i) - nCr(outside, i-1)) % MOD)) | """
実験のためにkobaya0514様のコードをいじくらせていただいております
"""
N = int(eval(input()))
A = [int(x) for x in input().split()]
# 重複始点終点調査
se = []
c = sum(A) - N * (N + 1) / 2
for i in range(len(A)):
if A[i] == c:
se.append(i)
l = se[0]
r = se[1]
mod = 10 ** 9 + 7
# 階乗計算
factorial = [1]
inverse = [1]
for i in range(1, N + 2):
factorial.append(factorial[-1] * i % mod)
inverse.append((pow(factorial[-1], mod - 2, mod)))
# combination計算
def nCr(n, r):
if n < r or n == 0 or r == 0:
return 0
return factorial[n] * inverse[r] * inverse[n - r] % mod
print(N)
for i in range(2, N + 2):
print((int(nCr(N + 1, i) - nCr(l + N - r, i - 1)) % mod)) | p03674 |
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
mod = 10 **9 + 7
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, N+2):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod-2, mod))
# 組み合わせ計算
def nCr(n, r):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % mod
X = Counter(A).most_common(1)[0][0]
X_index = []
for i, a in enumerate(A, start=1):
if a == X:
X_index.append(i)
L, R = X_index[0], X_index[1]
for k in range(1, N + 2):
if k == 1:
print(N)
else:
print(((nCr(N + 1, k) - nCr(N - R + L, k - 1)) % mod))
| N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
duplicate_x = None
checked = set()
for a in A:
if a in checked:
duplicate_x = a
checked.add(a)
x_l_index = A.index(duplicate_x)
x_r_index = N + 1 - A[::-1].index(duplicate_x) - 1
# 逆元の前計算
factorial = [1, 1]
inverse = [1, 1]
invere_base = [0, 1]
for i in range(2, N + 2):
factorial.append((factorial[-1] * i) % MOD)
invere_base.append((-invere_base[MOD % i] * (MOD // i)) % MOD)
inverse.append((inverse[-1] * invere_base[-1]) % MOD)
def nCr(n, r):
if not 0 <= r <= n:
return 0
return factorial[n] * inverse[r] * inverse[n - r] % MOD
for k in range(1, N + 1 + 1):
print(((nCr(N + 1, k) - nCr(max(0, x_l_index) + max(N + 1 - x_r_index - 1, 0), k - 1)) % MOD))
| p03674 |
def memfact(a,m):
temp = 1
yield temp
for i in range(1,a+1):
temp = temp * i % m
yield temp
def comb(n,r,m):
if r == 0: return 1
return (memf[n]*pow(memf[r],m-2,m)*pow(memf[n-r],m-2,m)) % m
n,*a = list(map(int, open(0).read().split()))
m = 1000000007
checker = set()
for i in range(n+1):
if a[i] in checker:
left = a.index(a[i])
right = n - i
break
else:
checker.add(a[i])
memf = []
mfappend = memf.append
for x in memfact(n+1,m):
mfappend(x)
for i in range(1,n+2):
ans = comb(n+1,i,m)
for j in range(max(0,i-right-1),min(left,i-1)+1):
ans = (ans-comb(left,j,m)*comb(right,i-j-1,m)) % m
print(ans) | def memfact(a,m):
temp = 1
yield temp
for i in range(1,a+1):
temp = temp * i % m
yield temp
def comb(n,r,m):
if r == 0: return 1
return (memf[n]*pow(memf[r],m-2,m)*pow(memf[n-r],m-2,m)) % m
n,*a = list(map(int, open(0).read().split()))
m = 1000000007
checker = set()
for i in range(n+1):
if a[i] in checker:
left = a.index(a[i])
right = n - i
break
else:
checker.add(a[i])
memf = []
mfappend = memf.append
for x in memfact(n+1,m):
mfappend(x)
lr = left + right
for i in range(1,n+2):
ans = comb(n+1,i,m)
if i <= lr + 1:
ans = (ans-comb(lr,i-1,m)) % m
print(ans) | p03674 |
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
div = pow(10, 9) + 7
# print(A)
d = dict()
for i in range(N+1):
if A[i] not in d: d[A[i]] = [i]
else: d[A[i]].append(i)
i1, i2 = 0, 0
for a in d:
if len(d[a]) == 2:
i1, i2 = d[a]
break
M = i1 + N-i2
# print(N, i1, i2)
# N+1_C_l
pow1 = [1, 1]
for i in range(2, N+2):
pow1.append(pow1[-1]*i % div)
pow2 = [1, 1]
for i in range(2, N+2):
j = powquick(i, div-2, div)
# print((i * j) % div)
pow2.append(pow2[-1]*j % div)
# print(pow1)
# print(pow2)
for l in range(1, N+2):
v = (pow1[N+1]*pow2[l]*pow2[N+1-l]) % div
# print(v)
if l <= M+1:
v -= (pow1[M]*pow2[l-1]*pow2[M-l+1]) % div
print((v % div))
def powquick(x, y, div):
if y == 0: return 1
if y == 1: return x % div
if y % 2 == 0: return pow(powquick(x, y // 2, div), 2) % div
if y % 2 == 1: return pow(powquick(x, y// 2, div), 2) * x % div
if __name__ == '__main__':
main() | def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
div = pow(10, 9) + 7
# print(A)
d = dict()
for i in range(N+1):
if A[i] not in d: d[A[i]] = [i]
else: d[A[i]].append(i)
i1, i2 = 0, 0
for a in d:
if len(d[a]) == 2:
i1, i2 = d[a]
break
M = i1 + N-i2
# print(N, i1, i2)
# N+1_C_l
pow1 = [1, 1]
for i in range(2, N+2):
pow1.append(pow1[-1]*i % div)
# pow2 = [1, 1]
# for i in range(2, N+2):
# j = powquick(i, div-2, div)
# pow2.append(pow2[-1]*j % div)
pow2 = [1, 1]
inv = [0, 1]
for i in range(2, N+2):
inv.append((-inv[div % i]) *(div // i) % div)
pow2.append(pow2[-1] * inv[-1] % div)
for l in range(1, N+2):
v = (pow1[N+1]*pow2[l]*pow2[N+1-l]) % div
# print(v)
if l <= M+1:
v -= (pow1[M]*pow2[l-1]*pow2[M-l+1]) % div
print((v % div))
def powquick(x, y, div):
if y == 0: return 1
if y == 1: return x % div
if y % 2 == 0: return pow(powquick(x, y // 2, div), 2) % div
if y % 2 == 1: return pow(powquick(x, y// 2, div), 2) * x % div
if __name__ == '__main__':
main() | p03674 |
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
div = pow(10, 9) + 7
# print(A)
d = dict()
for i in range(N+1):
if A[i] not in d: d[A[i]] = [i]
else: d[A[i]].append(i)
i1, i2 = 0, 0
for a in d:
if len(d[a]) == 2:
i1, i2 = d[a]
break
M = i1 + N-i2
# print(N, i1, i2)
# N+1_C_l
pow1 = [1, 1]
for i in range(2, N+2):
pow1.append(pow1[-1]*i % div)
pow2 = [1, 1]
for i in range(2, N+2):
j = powquick(i, div-2, div)
pow2.append(pow2[-1]*j % div)
# pow2 = [1, 1]
# inv = [0, 1]
# for i in range(2, N+2):
# inv.append((-inv[div % i]) *(div // i) % div)
# pow2.append(pow2[-1] * inv[-1] % div)
for l in range(1, N+2):
v = (pow1[N+1]*pow2[l]*pow2[N+1-l]) % div
# print(v)
if l <= M+1:
v -= (pow1[M]*pow2[l-1]*pow2[M-l+1]) % div
print((v % div))
def powquick(x, y, div):
if y == 0: return 1
if y == 1: return x % div
if y % 2 == 0: return pow(powquick(x, y // 2, div), 2) % div
if y % 2 == 1: return pow(powquick(x, y// 2, div), 2) * x % div
if __name__ == '__main__':
main() |
def main():
N = int(eval(input()))
A = [int(a) for a in input().split()]
div = pow(10, 9) + 7
# print(A)
d = dict()
for i in range(N+1):
if A[i] not in d: d[A[i]] = [i]
else: d[A[i]].append(i)
i1, i2 = 0, 0
for a in d:
if len(d[a]) == 2:
i1, i2 = d[a]
break
M = i1 + N-i2
# print(N, i1, i2)
# N+1_C_l
pow1 = [1, 1]
for i in range(2, N+2):
pow1.append(pow1[-1]*i % div)
# pow2 = [1, 1]
# for i in range(2, N+2):
# j = powquick(i, div-2, div)
# pow2.append(pow2[-1]*j % div)
pow2 = [1, 1]
inv = [0, 1]
for i in range(2, N+2):
inv.append((-inv[div % i]) *(div // i) % div)
pow2.append(pow2[-1] * inv[-1] % div)
for l in range(1, N+2):
v = (pow1[N+1]*pow2[l]*pow2[N+1-l]) % div
# print(v)
if l <= M+1:
v -= (pow1[M]*pow2[l-1]*pow2[M-l+1]) % div
print((v % div))
# def powquick(x, y, div):
# if y == 0: return 1
# if y == 1: return x % div
# if y % 2 == 0: return pow(powquick(x, y // 2, div), 2) % div
# if y % 2 == 1: return pow(powquick(x, y// 2, div), 2) * x % div
if __name__ == '__main__':
main() | p03674 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
A = [0] + LI()
mod = 10**9+7
count = [0]*(N+1)
for i in range(1,N+2):
if count[A[i]] != 0:
a = count[A[i]]
b = i
else:
count[A[i]] = i
kaijou = [1]
for i in range(1,N+2):
kaijou.append((kaijou[-1]*i) % mod)
def nCr(n,r):
if n < r:
return 0
return (kaijou[n]*pow(kaijou[r],mod-2,mod)*pow(kaijou[n-r],mod-2,mod)) % mod
for k in range(1,N+2):
print(((nCr(N+1,k)-nCr(N+a-b,k-1)) % mod))
| import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
A = [0] + LI()
mod = 10**9+7
count = [0]*(N+1)
for i in range(1,N+2):
if count[A[i]] != 0:
a,b = count[A[i]],i # 重複する文字のあるindex
else:
count[A[i]] = i
kaijou = [1]
for i in range(1,N+2):
kaijou.append((kaijou[-1]*i) % mod)
def nCr(n,r):
if n < r:
return 0
return (kaijou[n]*pow(kaijou[r],mod-2,mod)*pow(kaijou[n-r],mod-2,mod)) % mod
for k in range(1,N+2):
print(((nCr(N+1,k)-nCr(N+a-b,k-1)) % mod))
| p03674 |
import sys
input = sys.stdin.readline
######## modあり modは素数 ###############
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**5+1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
n=int(eval(input()))
A=list(map(int,input().split()))
v=[-1]*n
for i,a in enumerate(A):
#print(i,a)
if v[a-1]!=-1:
s=v[a-1]
f=i
if v[a-1]==-1:
v[a-1]=i
#print(s,f)
mod=10**9+7
for i in range(1,n+1):
"""sousuu=cmb(n+1,i,mod)
tyouhuku=cmb(s+n-f,i-1,mod)"""
if i==1:
sousuu=n+1
tyouhuku=1
else:
sousuu*=(n+2-i)
sousuu//=i
tyouhuku*=(s+n-f+1-i+1)
tyouhuku//=(i-1)
#print(sousuu,tyouhuku)
print(((sousuu-tyouhuku)%mod))
print((1))
| import sys
input = sys.stdin.readline
######## modあり modは素数 ###############
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**5+1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
n=int(eval(input()))
A=list(map(int,input().split()))
v=[-1]*n
for i,a in enumerate(A):
#print(i,a)
if v[a-1]!=-1:
s=v[a-1]
f=i
if v[a-1]==-1:
v[a-1]=i
#print(s,f)
mod=10**9+7
for i in range(1,n+1):
sousuu=cmb(n+1,i,mod)
tyouhuku=cmb(s+n-f,i-1,mod)
"""if i==1:
sousuu=n+1
tyouhuku=1
else:
sousuu*=(n+2-i)
sousuu//=i
tyouhuku*=(s+n-f+1-i+1)
tyouhuku//=(i-1)"""
#print(sousuu,tyouhuku)
print(((sousuu-tyouhuku)%mod))
print((1))
| p03674 |
mod = int(1e9) + 7
def power(x, y):
if y == 0:
return 1
elif y == 1:
return x % mod
elif y % 2 == 0:
return power(x, y//2)**2 % mod
else:
return power(x, y//2)**2 * x % mod
fact = [1] * int(1e5+1)
for i in range(1, int(1e5+1)):
fact[i] = (i * fact[i-1]) % mod
inv = [1] * int(1e5+1)
for i in range(0, int(1e5+1)):
inv[i] = power(fact[i], mod-2) % mod
def combination(n, r):
return fact[n] * inv[r] * inv[n-r] % mod
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
idx = [-1] * (N+1)
x = 0
for i in range(N+1):
if idx[A[i]] == -1:
idx[A[i]] = i
else:
x = i - idx[A[i]]
for i in range(1, N+2):
ans = combination(N+1, i)
if i <= (N+1-x):
ans = (ans - combination(N+1-(x+1), i-1)) % mod
print(ans)
if __name__ == "__main__":
main()
| mod = int(1e9) + 7
def power(x, y):
if y == 0:
return 1
elif y == 1:
return x % mod
elif y % 2 == 0:
return power(x, y//2)**2 % mod
else:
return power(x, y//2)**2 * x % mod
fact = [1] * int(1e5+2)
for i in range(1, int(1e5+2)):
fact[i] = (i * fact[i-1]) % mod
inv = [1] * int(1e5+2)
inv[int(1e5+1)] = power(fact[int(1e5+1)], mod-2) % mod
for i in range(int(1e5), 0, -1):
inv[i] = (inv[i+1] * (i+1)) % mod
def combination(n, r):
return fact[n] * inv[r] * inv[n-r] % mod
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
idx = [-1] * (N+1)
x = 0
for i in range(N+1):
if idx[A[i]] == -1:
idx[A[i]] = i
else:
x = i - idx[A[i]]
for i in range(1, N+2):
ans = combination(N+1, i)
if i <= (N+1-x):
ans = (ans - combination(N+1-(x+1), i-1)) % mod
print(ans)
if __name__ == "__main__":
main()
| p03674 |
from math import factorial
from collections import Counter
mod = 10**9 + 7
n = int(eval(input()))
length = n+1
li = list(map(int,input().split()))
counter = Counter(li)
dup = counter.most_common()[0][0]
be, af = [i for i, x in enumerate(li) if x==dup]
soto = be + length - af - 1
for k in range(1, n+2):
if k == 1:
print(n)
elif k == n+1:
print((1))
else:
zyouhukuari = factorial(length) // (factorial(k)*factorial(length-k))
if soto-k+1 >= 0:
zyouhuku = factorial(soto) // (factorial(k-1)*factorial(soto-k+1))
else:
zyouhuku = 0
val = zyouhukuari - zyouhuku
print((val%mod)) | import collections
N = int(eval(input()))
a = list(map(int, input().split()))
c = collections.Counter(a)
dup = c.most_common()[0][0]
id = [i for i, x in enumerate(a) if x == dup]
L = id[0]
R = id[1]
MOD = 10**9 +7
factorial = [1]
inverse = [1]
for i in range(1, N+2):
factorial.append(factorial[i-1] * i % MOD)
inverse.append(pow(factorial[i], MOD-2, MOD))
def C(n, r):
if n < r:
return 0
return (factorial[n] * inverse[r] * inverse[n-r]) % MOD
print(N)
for i in range(2, N+2):
ans = (C(N+1, i) - C(L+(N-R), i-1)) % MOD
print(ans)
| p03674 |
n = int(eval(input()))
A =list(map(int, input().split()))
mod = 10**9+7
d = {}
for i in range(n+1):
if A[i] not in d:
d[A[i]] = i
else:
l = d[A[i]]
r = i
break
#print(l, r)
def cmb1(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
for k in range(1, n+2):
ans = cmb1(n+1, k, mod) - cmb1(l+n-r, k-1, mod)
print((ans%mod))
| n = int(eval(input()))
A = list(map(int, input().split()))
mod = 10**9+7
from collections import Counter
C = Counter(A)
for k, v in list(C.items()):
if v == 2:
t = k
flag = False
for i in range(n+1):
if not flag:
if A[i] == t:
l = i
flag = True
else:
if A[i] == t:
r = i
r = n-r
#print(l, r)
N = 10**5+50
fac = [1]*(N+1)
finv = [1]*(N+1)
for i in range(N):
fac[i+1] = fac[i] * (i+1) % mod
finv[-1] = pow(fac[-1], mod-2, mod)
for i in reversed(list(range(N))):
finv[i] = finv[i+1] * (i+1) % mod
def cmb1(n, r, mod):
if r <0 or r > n:
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
for k in range(1, n+2):
ans = cmb1(n+1, k, mod)-cmb1(l+r, k-1, mod)
print((ans%mod))
| p03674 |
#!/usr/bin/env python3
#ABC66 D
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def f(a, b):
if b == 0:
return 1
if b % 2 == 0:
d = f(a, b // 2)
return d * d % mod
if b % 2 == 1:
return (a * f(a, b - 1)) % mod
def comb(n,r):
if n - r < 0:
return 0
return fact[n] * invfact[r] * invfact[n-r] % mod
n = I()
a = LI()
cnt = [0]*(n+1)
for i in range(n+1):
if cnt[a[i]]:
a = cnt[a[i]]
b = i+1
break
else:
cnt[a[i]] = i+1
fact = [1]*(n+2)
invfact = [1]*(n+2)
for i in range(1,n+2):
fact[i] = i*fact[i-1] % mod
invfact[i] = invfact[i-1] * f(i,mod-2) % mod
for i in range(n+1):
res = 0
res = (res + comb(n+1,i+1)) % mod
res = (res - comb((a-1)+(n+1-b),i)) % mod
print(res)
| #!/usr/bin/env python3
#ABC66 D
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def comb(n,r):
if n - r < 0:
return 0
return fact[n] * invfact[r] * invfact[n-r] % mod
n = I()
a = LI()
cnt = [0]*(n+1)
for i in range(n+1):
if cnt[a[i]]:
a = cnt[a[i]]
b = i+1
break
else:
cnt[a[i]] = i+1
fact = [1]*(n+2)
invfact = [1]*(n+2)
for i in range(1,n+2):
fact[i] = i*fact[i-1] % mod
invfact[i] = invfact[i-1] * pow(i,mod-2,mod) % mod
for i in range(n+1):
res = 0
res = (res + comb(n+1,i+1)) % mod
res = (res - comb((a-1)+(n+1-b),i)) % mod
print(res)
| p03674 |
mod=10**9+7
n=int(eval(input()))
a=list(map(int,input().split()))
c=[0]*n
for i in a:c[i-1]+=1
ind=c.index(2)
x=[]
for i in range(n+1):
if a[i]==ind+1:x.append(i)
m=n+x[0]-x[1]
f=[1]
for i in range(1,n+2):f.append(f[-1]*i%mod)
def comb(n,r):return f[n]*pow(f[r],mod-2,mod)*pow(f[n-r],mod-2,mod)%mod
for k in range(1,n+2):
if k==1:print(n);continue
if k-1>m:print((comb(n+1,k)));continue
ans=comb(n+1,k)-comb(m,k-1)
print((ans%mod)) | mod=10**9+7
n=int(eval(input()))
a=list(map(int,input().split()))
c=[0]*n
for i in a:c[i-1]+=1
ind=c.index(2)
x=[]
for i in range(n+1):
if a[i]==ind+1:x.append(i)
m=n+x[0]-x[1]
ans=1
anss=1
for k in range(1,n+2):
ans=(ans*(n-k+2))%mod
ans=ans*pow(k,mod-2,mod)%mod
if k==1:print(n);continue
anss=(anss*(m-k+2))%mod
anss=anss*pow(k-1,mod-2,mod)%mod
if k-1>m:print(ans);continue
print(((ans-anss)%mod)) | p03674 |
import sys
MOD = 10 ** 9 + 7
def make_table(n=10**5+1, p=10**9+7):
fac = [None] * (n + 1)
fac[0] = 1
ifac = fac.copy()
for i in range(1, n + 1):
fac[i] = fac[i-1] * i % p
ifac[n] = pow(fac[n], p - 2, p)
for i in range(n-1, 0, -1):
ifac[i] = ifac[i+1] * (i + 1) % p
return fac, ifac
fac, ifac = make_table()
def comb_mod(n, r, mod=10**9+7):
if r < 0 or r > n:
return 0
return fac[n] * ifac[r] % mod * ifac[n-r] % mod
n, *a = map(int, sys.stdin.read().split())
def main():
appeared = [False] * (n + 1)
for i in range(n+1):
cur = a[i]
if appeared[cur]:
x1, x2 = appeared[cur], i+1
break
appeared[cur] = i+1
res = [0] * (n + 2)
for i in range(1, n+2):
res[i] += comb_mod(n+1, i)
res[i] %= MOD
x = (x1 - 1) + (n + 1 - x2)
for i in range(x+1):
res[i+1] -= comb_mod(x, i)
res[i+1] %= MOD
return res[1:]
if __name__ == '__main__':
ans = main()
print(*ans, sep='\n')
| import sys
MOD = 10 ** 9 + 7
def make_table(n=10**5+1, p=10**9+7):
fac = [None] * (n + 1)
fac[0] = 1
ifac = fac.copy()
for i in range(1, n + 1):
fac[i] = fac[i-1] * i % p
ifac[n] = pow(fac[n], p - 2, p)
for i in range(n-1, 0, -1):
ifac[i] = ifac[i+1] * (i + 1) % p
return fac, ifac
fac, ifac = make_table()
def comb_mod(n, r, mod=10**9+7):
if r < 0 or r > n:
return 0
return fac[n] * ifac[r] % mod * ifac[n-r] % mod
n, *a = map(int, sys.stdin.read().split())
def main():
appeared = [False] * (n + 1)
for i in range(n+1):
cur = a[i]
if appeared[cur]:
x1, x2 = appeared[cur], i+1
break
appeared[cur] = i+1
res = [0] * (n + 2)
for i in range(1, n+2):
res[i] += comb_mod(n+1, i)
x = (x1 - 1) + (n + 1 - x2)
for i in range(x+1):
res[i+1] -= comb_mod(x, i)
res[i+1] %= MOD
return res[1:]
if __name__ == '__main__':
ans = main()
print(*ans, sep='\n')
| p03674 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n = int(readline())
a = list(map(int, readline().split()))
dup = 0
for i in range(1, n + 2):
if a.count(i) == 2:
dup = i
first = a.index(dup)
second = a[first + 1:].index(dup) + first + 1
print(n)
p = first
q = (n + 1) - second - 1
c1 = n + 1
c2 = 1
for i in range(2, n + 2):
c1 *= (n + 1 - (i - 1))
c1 %= MOD
c1 *= pow(i, MOD - 2, MOD)
c1 %= MOD
c2 *= (p + q - (i - 2))
c2 %= MOD
c2 *= pow(i - 1, MOD - 2, MOD)
c2 %= MOD
print(((c1 - c2) % MOD))
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n = int(readline())
a = list(map(int, readline().split()))
appeared = set()
dup = 0
for x in a:
if x in appeared:
dup = x
break
else:
appeared.add(x)
first = a.index(dup)
second = a[first + 1:].index(dup) + first + 1
print(n)
p = first
q = (n + 1) - second - 1
c1 = n + 1
c2 = 1
for i in range(2, n + 2):
c1 *= (n + 1 - (i - 1))
c1 %= MOD
c1 *= pow(i, MOD - 2, MOD)
c1 %= MOD
c2 *= (p + q - (i - 2))
c2 %= MOD
c2 *= pow(i - 1, MOD - 2, MOD)
c2 %= MOD
print(((c1 - c2) % MOD))
if __name__ == '__main__':
main()
| p03674 |
n = int(eval(input()))
A= list(map(int, input().split()))
mod = int(1e9+7)
def powermod(p,n,mod):
#if n==0: return 1
if n==1: return p%mod
else: return powermod(p,n//2,mod)**2 * (p**(n%2)) %mod
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
C = i - memo[a] -1
R = len(A) - i-1
break
else:
memo[a] = i
#print(L,C,R)
_LR = [0]*(n+3)
_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n+3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0]*(n+2) #LR[k] = (L+R)C(k)
LR[0] = 1
#LDR = [0]*(n+2)
#LDDR = [0]*(n+2)
LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]
#LDCR = [0] * (n+2) #最後に*2を忘れないこと
#LDCDR = [0] * (n+2)
for k in range(1,n+2):
_LR[k] = (_LR[k-1] * (L+R+1-k)) %mod
_LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod
_k[k] = (_k[k-1] * powermod(k, mod-2, mod)) %mod
LR[k] = (_LR[k] * _k[k])%mod
# LDR[k] = LR[k-1]
# LDDR[k] = LDR[k-1]
LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]
# LDCR[k] = LCR[k-1]
# LDCDR[k] = LDCR[k-1]
#print(LR, LCR)
print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))
#print(LR)
#print(LDR)
#print(LDDR)
#print(_LCR)
#print(LCR)
#print(LDCR)
#print(LDCDR) | n = int(eval(input()))
A= list(map(int, input().split()))
mod = int(1e9+7)
def powermod(p,n,mod):
#if n==0: return 1
if n==1:
return p%mod
if n%2:
return powermod(p,n//2,mod)**2 * p %mod
else:
return powermod(p,n//2,mod)**2 %mod
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
C = i - memo[a] -1
R = len(A) - i-1
break
else:
memo[a] = i
#print(L,C,R)
_LR = [0]*(n+3)
_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n+3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0]*(n+2) #LR[k] = (L+R)C(k)
LR[0] = 1
#LDR = [0]*(n+2)
#LDDR = [0]*(n+2)
LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]
#LDCR = [0] * (n+2) #最後に*2を忘れないこと
#LDCDR = [0] * (n+2)
for k in range(1,n+2):
_LR[k] = (_LR[k-1] * (L+R+1-k)) %mod
_LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod
_k[k] = (_k[k-1] * powermod(k, mod-2, mod)) %mod
LR[k] = (_LR[k] * _k[k])%mod
# LDR[k] = LR[k-1]
# LDDR[k] = LDR[k-1]
LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]
# LDCR[k] = LCR[k-1]
# LDCDR[k] = LDCR[k-1]
#print(LR, LCR)
print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))
#print(LR)
#print(LDR)
#print(LDDR)
#print(_LCR)
#print(LCR)
#print(LDCR)
#print(LDCDR) | p03674 |
n = int(eval(input()))
A= list(map(int, input().split()))
mod = int(1e9+7)
def powermod(a, n, mod):
r = 1
while n>=1:
if n%2:
r = (r*a)%mod
a = (a*a)%mod
n = n//2
return r
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
C = i - memo[a] -1
R = len(A) - i-1
break
else:
memo[a] = i
#print(L,C,R)
_LR = [0]*(n+3)
_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n+3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0]*(n+2) #LR[k] = (L+R)C(k)
LR[0] = 1
#LDR = [0]*(n+2)
#LDDR = [0]*(n+2)
LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]
#LDCR = [0] * (n+2) #最後に*2を忘れないこと
#LDCDR = [0] * (n+2)
for k in range(1,n+2):
_LR[k] = (_LR[k-1] * (L+R+1-k)) %mod
_LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod
_k[k] = (_k[k-1] * powermod(k, mod-2, mod)) %mod
LR[k] = (_LR[k] * _k[k])%mod
# LDR[k] = LR[k-1]
# LDDR[k] = LDR[k-1]
LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]
# LDCR[k] = LCR[k-1]
# LDCDR[k] = LDCR[k-1]
#print(LR, LCR)
print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))
#print(LR)
#print(LDR)
#print(LDDR)
#print(_LCR)
#print(LCR)
#print(LDCR)
#print(LDCDR)
| n = int(eval(input()))
A= list(map(int, input().split()))
mod = int(1e9+7)
def invmod(a, mod):
if a==1:
return 1
return -invmod(mod%a, mod) * (mod//a) %mod
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
C = i - memo[a] -1
R = len(A) - i-1
break
else:
memo[a] = i
#print(L,C,R)
_LR = [0]*(n+3)
_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n+3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0]*(n+2) #LR[k] = (L+R)C(k)
LR[0] = 1
#LDR = [0]*(n+2)
#LDDR = [0]*(n+2)
LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]
#LDCR = [0] * (n+2) #最後に*2を忘れないこと
#LDCDR = [0] * (n+2)
for k in range(1,n+2):
_LR[k] = (_LR[k-1] * (L+R+1-k)) %mod
_LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod
_k[k] = (_k[k-1] * invmod(k,mod)) %mod
LR[k] = (_LR[k] * _k[k])%mod
# LDR[k] = LR[k-1]
# LDDR[k] = LDR[k-1]
LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]
# LDCR[k] = LCR[k-1]
# LDCDR[k] = LDCR[k-1]
#print(LR, LCR)
print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))
#print(LR)
#print(LDR)
#print(LDDR)
#print(_LCR)
#print(LCR)
#print(LDCR)
#print(LDCDR) | p03674 |
n = int(eval(input()))
A= list(map(int, input().split()))
mod = int(1e9+7)
def invmod(a, mod):
if a==1:
return 1
return -invmod(mod%a, mod) * (mod//a) %mod
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
C = i - memo[a] -1
R = len(A) - i-1
break
else:
memo[a] = i
#print(L,C,R)
_LR = [0]*(n+3)
_LCR = [0] * (n+3) # _LCR[k] = (L+C+R)C(k)
_k = [0] * (n+3)
_LR[0] = _LCR[0] = _k[0] = 1
LR = [0]*(n+2) #LR[k] = (L+R)C(k)
LR[0] = 1
#LDR = [0]*(n+2)
#LDDR = [0]*(n+2)
LCR = [0] * (n+2) # LCR[k] = _LCR[k] - LR[k]
#LDCR = [0] * (n+2) #最後に*2を忘れないこと
#LDCDR = [0] * (n+2)
for k in range(1,n+2):
_LR[k] = (_LR[k-1] * (L+R+1-k)) %mod
_LCR[k] = (_LCR[k-1] * (L+C+R+1-k))% mod
_k[k] = (_k[k-1] * invmod(k,mod)) %mod
LR[k] = (_LR[k] * _k[k])%mod
# LDR[k] = LR[k-1]
# LDDR[k] = LDR[k-1]
LCR[k] = (_LCR[k] * _k[k])%mod - LR[k]
# LDCR[k] = LCR[k-1]
# LDCDR[k] = LDCR[k-1]
#print(LR, LCR)
print(((LR[k] + LR[k-1] + LR[k-2] + LCR[k] + 2*LCR[k-1] + LCR[k-2])%mod))
#print(LR)
#print(LDR)
#print(LDDR)
#print(_LCR)
#print(LCR)
#print(LDCR)
#print(LDCDR) | n = int(eval(input()))
A= list(map(int, input().split()))
mod = 10**9+7
class combinationmod():
def __init__(self,MAX, mod):
self.mod =mod
self.fac=[0]*(MAX+1)
self.finv=[0]*(MAX+1)
self.inv=[0]*(MAX+1)
self.fac[0]=self.fac[1]=1
self.finv[0]=self.finv[1]=1
self.inv[1]=1
for i in range(2,MAX+1):
self.fac[i] = self.fac[i-1]*i%self.mod
self.inv[i] = (-self.inv[mod%i]*(mod//i))%self.mod
self.finv[i] = self.finv[i-1]* self.inv[i] %self.mod
def nCk(self,n,k):
if n<k or n<0 or k<0:
return 0
return self.fac[n]*(self.finv[k]*self.finv[n-k]%self.mod)%self.mod
memo={}
for i, a in enumerate(A):
if a in memo:
L = memo[a]
R = len(A) - i-1
break
else:
memo[a] = i
c = combinationmod(n+1,mod)
for k in range(1,n+2):
print(((c.nCk(n+1,k) - c.nCk(L+R,k-1))%mod))
| p03674 |
from collections import Counter
n = int(eval(input()))
A = list(map(int, input().split()))
cnt = Counter(A)
mod = 10**9 + 7
def comb(n,k,p):
"""power_funcを用いて(nCk) mod p を求める"""
from math import factorial
if n<0 or k<0 or n<k: return 0
if n==0 or k==0: return 1
a=factorial(n) %p
b=factorial(k) %p
c=factorial(n-k) %p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
"""a^b mod p を求める"""
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
return d*d %p
if b%2==1:
return (a*power_func(a,b-1,p ))%p
for key, val in list(cnt.items()):
if val == 2:
doubled_num = key
break
left = None
for i, a in enumerate(A):
if a == doubled_num:
if left == None:
left = i
else:
right = i
rest = n - right
left
for i in range(1, n+2):
print(((comb(n+1, i, mod) - comb(left + rest, i-1, mod)) % mod)) | from collections import Counter
n = int(eval(input()))
A = list(map(int, input().split()))
cnt = Counter(A)
mod = 10**9 + 7
def comb(n,k,p):
"""power_funcを用いて(nCk) mod p を求める"""
from math import factorial
if n<0 or k<0 or n<k: return 0
if n==0 or k==0: return 1
a=factorial(n) %p
b=factorial(k) %p
c=factorial(n-k) %p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
"""a^b mod p を求める"""
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
return d*d %p
if b%2==1:
return (a*power_func(a,b-1,p ))%p
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
# aの逆元(mod m)を求める。(aとmは互いに素であることが前提)
def mod_inv(a,m):
x = extgcd(a,m)[0]
return (m+x%m)%m
for key, val in list(cnt.items()):
if val == 2:
doubled_num = key
break
left = None
for i, a in enumerate(A):
if a == doubled_num:
if left == None:
left = i
else:
right = i
rest = n - right
base_numerator = n+1
base_denominator = 1
base = (base_numerator * mod_inv(base_denominator, mod)) % mod
duplicate_numerator = left + rest + 1
duplicate_denominator = 0
duplicate = 1
for i in range(n+1):
#print("base", base_numerator, base_denominator)
#print("dup", duplicate_numerator, duplicate_denominator)
#print(base, duplicate)
print(((base - duplicate) % mod))
base_numerator -= 1
base_denominator += 1
base *= base_numerator * mod_inv(base_denominator, mod)
base %= mod
duplicate_numerator -= 1
duplicate_denominator += 1
duplicate *= duplicate_numerator * mod_inv(duplicate_denominator, mod)
duplicate %= mod | p03674 |
#list_int 並べて出力 print (' '.join(map(str,ans_li)))
#list_str 並べて出力 print (' '.join(list))
# 2進数 format(10, 'b') # '1010'
# aa=[int(input()) for i in range(n)]
#for i,name in enumerate(list)
''' 二次元配列を一列ずつ
for i in ans:
print(*i)
'''
''' heapq
queue = []
heapq.heapify(queue) #heapqの作成
heapq.heappush(queue,num) #numのpush(値の追加)
pop = heapq.heappop(queue) #numのpop(最小値の出力)
pop = heapq.heappushpop(queue,num) #push -> pop
'''
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl_int(): return list(map(int, input().split()))
def inpl_str(): return list(map(int, input().split()))
def Comb(n):
gyakugen = [1]*(n+1)
fac = [1]*(n+1)
for i in range(1,n+1):
fac[i] = (fac[i-1]*i)%mod
gyakugen[n] = pow(fac[n],mod-2,mod)
for i in range(n,0,-1):
gyakugen[i-1] = gyakugen[i]*i
com = [1]*(n+1)
for i in range(1,n+1):
com[i] = (fac[n]*gyakugen[i]*gyakugen[n-i])%mod
return com
N = int(eval(input()))
aa = inpl_int()
i = 1
dd = defaultdict(int)
for i,a in enumerate(aa):
if dd[a] == 0:
dd[a] = i+1
else:
X1 = dd[a]-1
X2 = i
L,R = X1,N-X2
ALL = 1
ALL = Comb(N+1)
daburi = Comb(L+R)
for i in range(1,N+2):
if L+R+1 >= i:
print((ALL[i]-daburi[i-1]))
else:
print((ALL[i]))
| from collections import defaultdict
import sys,heapq,bisect,math,itertools,string
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
def inpl_int(): return list(map(int, input().split()))
def inpl_str(): return list(map(int, input().split()))
def Comb(n):
gyakugen = [1]*(n+1)
fac = [1]*(n+1)
for i in range(1,n+1):
fac[i] = (fac[i-1]*i)%mod
gyakugen[n] = pow(fac[n],mod-2,mod)
for i in range(n,0,-1):
gyakugen[i-1] = (gyakugen[i]*i)%mod
com = [1]*(n+1)
for i in range(1,n+1):
com[i] = (fac[n]*gyakugen[i]*gyakugen[n-i])%mod
return com
N = int(eval(input()))
aa = inpl_int()
i = 1
dd = defaultdict(int)
for i,a in enumerate(aa):
if dd[a] == 0:
dd[a] = i+1
else:
X1 = dd[a]-1
X2 = i
L,R = X1,N-X2
ALL = 1
ALL = Comb(N+1)
daburi = Comb(L+R)
for i in range(1,N+2):
if L+R+1 >= i:
print(((ALL[i]-daburi[i-1])%mod))
else:
print((ALL[i]%mod))
| p03674 |
import sys
sys.setrecursionlimit(10 ** 9)
M = 10 ** 9 + 7
cache = {}
# Combination under a prime modulo: nCk % p
def combmod(n, k, p=M):
if k > n:
return 0
if k > n - k:
k = n - k
if (n, k) in cache:
return cache[n, k]
num, den = 1, 1
for i in range(k):
num = num * (n - i) % p
den = den * (i + 1) % p
# By Fermat's little theorem,
# a^(p-1) ≡ 1 mod p
# i.e. a^(p-2) ≡ a^(-1) mod p
inv_dev = pow(den, p - 2, p)
res = num * inv_dev % p
cache[n, k] = res
return res
n = int(eval(input()))
a = list(map(int, input().split()))
assert len(a) == n + 1
b = [None] * (n + 1)
d1, d2 = -1, -1
for i in range(n + 1):
if b[a[i]] is None:
b[a[i]] = i
else:
d1 = b[a[i]]
d2 = i
break
assert d1 >= 0 and d2 >= 0 and a[d1] == a[d2]
def comb(n, k):
if k > n:
return 0
if k > n - k:
k = n - k
if k == 0:
return 1
if k == 1:
return n
if (n, k) in cache:
return cache[n, k]
res = combmod(n - 1, k) + combmod(n - 1, k - 1)
cache[n, k] = res
return res
for k in range(1, n + 2):
ans = comb(n + 1, k) - comb(n - d2 + d1, k - 1)
print((ans % M))
| import sys
input = sys.stdin.readline
M = 10 ** 9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
assert len(a) == n + 1
b = [None] * (n + 1)
d1, d2 = -1, -1
for i in range(n + 1):
if b[a[i]] is None:
b[a[i]] = i
else:
d1 = b[a[i]]
d2 = i
break
assert d1 >= 0 and d2 >= 0 and a[d1] == a[d2]
a, b, ik = n + 1, 1, 1
for k in range(1, n + 2):
ans = (a - b) % M
print(ans)
b = b * (n + 1 - d2 + d1 - k) * ik % M
ik = pow(k + 1, M - 2, M)
a = a * (n + 1 - k) * ik % M
| p03674 |
n = int(eval(input()))
a = list(map(int, input().split()))
dup=[0]*n
for num in a:
dup[num-1]+=1
if dup[num-1]>1:
break
A=-1
B=-1
for i in range(len(a)):
if a[i]==num:
if A==-1:
A=i
else:
B=i
B=n-B
def find_power(n,mod=10**9+7):
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n,mod=10**9+7):
powlist=find_power(n)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
mod = 10**9+7
NUM = (10**5)+100
p_lis=find_power(NUM,mod)
ip_lis=find_inv_power(NUM,mod)
def comb(n,r,mod=10**9+7):
if n<r:
return 0
elif n>=r:
return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)
print(n)
for k in range(2,n+2):
base=comb(n+1,k)
for i in range(k):
j=k-i-1
base-= comb(A,i) *comb(B,j)
print(base)
| n = int(eval(input()))
a = list(map(int, input().split()))
dup=[0]*n
for num in a:
dup[num-1]+=1
if dup[num-1]>1:
break
A=-1
B=-1
for i in range(len(a)):
if a[i]==num:
if A==-1:
A=i
else:
B=i
B=n-B
def find_power(n,mod=10**9+7):
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n,mod=10**9+7):
powlist=find_power(n)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
mod = 10**9+7
NUM = (10**5)+100
p_lis=find_power(NUM,mod)
ip_lis=find_inv_power(NUM,mod)
def comb(n,r,mod=10**9+7):
if n<r:
return 0
elif n>=r:
return (p_lis[n]*ip_lis[r]*ip_lis[n-r])%(mod)
print(n)
for k in range(2,n+2):
base=comb(n+1,k) - comb(A+B,k-1)
print((base%mod)) | p03674 |
from collections import Counter, defaultdict
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 100)
cntA = Counter(A)
I = [a for a, c in list(cntA.items()) if c == 2][0]
L, R = [i for i, a in enumerate(A) if a == I]
S = L + (N - R)
for i in range(1, N + 2):
if i == 1:
print(N)
continue
ans = comb.ncr(N + 1, i) - comb.ncr(S, i - 1)
print((ans % MOD))
| from collections import Counter
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 100)
cntA = Counter(A)
X = [a for a, c in cntA.items() if c == 2][0]
l, r = [i for i, a in enumerate(A) if a == X]
ans = [N]
for leng in range(2, N + 2):
M = comb.ncr(N + 1, leng)
L = l + (N - r)
D = comb.ncr(L, leng - 1)
ans.append((M - D) % MOD)
print(*ans, sep='\n')
| p03674 |
MOD = 10**9+7
def mod_pow(x, n):
if x==0: return 1
res = 1
while n > 0:
if n&1:
res = (res*x)%MOD
x = (x*x)%MOD
n >>= 1
return res
fact, invfact = [0]*(10**5+2), [0]*(10**5+2)
fact[0], invfact[0] = 1, 1
for i in range(1, 10**5+2):
fact[i] = (fact[i-1]*i)%MOD
invfact[i] = mod_pow(fact[i], MOD-2)%MOD
def comb(n, r):
if n<r or n==0 or r==0: return 0
return (((fact[n]*invfact[r])%MOD)*invfact[n-r])%MOD
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(int)
for i, ele in enumerate(a):
if d[ele] == 0:
d[ele]= i+1
else:
l = d[ele]
r = i+1
print(n)
for k in range(2, n+2):
print(((comb(n+1, k)-comb(l-1+n-r+1, k-1))%MOD)) | # Pythonの組み込み関数powを使ったバージョン
MOD = 10**9+7
fact, invfact = [0]*(10**5+2), [0]*(10**5+2)
fact[0], invfact[0] = 1, 1
for i in range(1, 10**5+2):
fact[i] = (fact[i-1]*i)%MOD
invfact[i] = pow(fact[i], MOD-2, MOD)
def mod_comb(n, r):
if n<r or n==0 or r==0: return 0
return (((fact[n]*invfact[r])%MOD)*invfact[n-r])%MOD
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(int)
for i, ele in enumerate(a):
if d[ele] == 0:
d[ele]= i+1
else:
l = d[ele]
r = i+1
print(n)
for k in range(2, n+2):
print(((mod_comb(n+1, k)-mod_comb(l-1+n-r+1, k-1))%MOD)) | p03674 |
n = int(eval(input()))
a = list(map(int, input().split()))
from collections import Counter
c = Counter(a)
for k in list(c.keys()):
if c[k] == 2:
break
l = []
for i in range(len(a)):
if a[i] == k:
l.append(i)
if len(l) == 2:
break
d = n - l[1] + l[0]
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y // 2) ** 2 % mod
else : return power(x, y // 2) ** 2 * x % mod
mod = (10 ** 9 + 7)
N1 = n + 2
factorial1 = [1]
for i in range(1, N1):
factorial1.append(factorial1[i - 1] * i % mod)
inverseFactorial1 = [0] * N1
inverseFactorial1[N1 - 1] = power(factorial1[N1 - 1], mod - 2)
for i in range(N1 - 2, -1, -1):
inverseFactorial1[i] = inverseFactorial1[i + 1] * (i + 1) % mod
def combi1(x, y):
return factorial1[x] * inverseFactorial1[y] * inverseFactorial1[x - y] % mod
for k in range(1, n + 2):
if d >= k - 1:
print(((combi1(n+1, k) - combi1(d, k-1)) % mod))
else:
print((combi1(n+1, k)))
| n = int(eval(input()))
a = list(map(int, input().split()))
from collections import Counter
c = Counter(a)
for k in list(c.keys()):
if c[k] == 2:
break
l = []
for i in range(len(a)):
if a[i] == k:
l.append(i)
if len(l) == 2:
break
d = n - l[1] + l[0]
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y // 2) ** 2 % mod
else : return power(x, y // 2) ** 2 * x % mod
mod = 10 ** 9 + 7
N = n + 2
factorial = [1]
for i in range(1, N):
factorial.append(factorial[i - 1] * i % mod)
inverseFactorial = [0] * N
inverseFactorial[N - 1] = power(factorial[N - 1], mod - 2)
for i in range(N - 2, -1, -1):
inverseFactorial[i] = inverseFactorial[i + 1] * (i + 1) % mod
def comb(x, y):
return factorial[x] * inverseFactorial[y] * inverseFactorial[x - y] % mod
for k in range(1, n + 2):
if d >= k - 1:
print(((comb(n+1, k) - comb(d, k-1)) % mod))
else:
print((comb(n+1, k)))
| p03674 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I() + 1
A = LI()
D = defaultdict(lambda:-1)
for i in range(n):
if D[A[i]] != -1:
l = D[A[i]]
r = n - i - 1
break
else:
D[A[i]] = i
fac = [1] * (n + 1)
inv = [1] * (n + 1)
i = 1
for j in range(1, n + 1):
i = i * j % mod
fac[j] = i
inv[j] = pow(i, mod - 2, mod)
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
for j in range(1, n + 1):
print(((comb(n, j) - comb(r + l, j - 1)) % mod)) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I() + 1
A = LI()
D = defaultdict(lambda:-1)
for i in range(n):
if D[A[i]] != -1:
l = D[A[i]]
r = n - i - 1
break
else:
D[A[i]] = i
fac = [1] * (n + 1)
inv = [1] * (n + 1)
for j in range(1, n + 1):
fac[j] = fac[j-1] * j % mod
inv[n] = pow(fac[n], mod-2, mod)
for j in range(n-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(n, r):
if r > n or n < 0 or r < 0:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
for j in range(1, n + 1):
print(((comb(n, j) - comb(r + l, j - 1)) % mod))
| p03674 |
# 繰り返し二乗法 (mod 有り)
def mod_rep_pow(a, n, mod=(10 ** 9 + 7)):
res = 1
while n > 0:
if n % 2 == 0:
a = a ** 2 % mod
n //= 2
else:
res = res * a % mod
n -= 1
return (res % mod)
# 繰り返し二乗法 (mod 有り) を利用して nCk を高速に返す
# mod が素数のときのみ利用可能 (フェルマーの小定理を利用しているため)
def mod_comb(n, k, mod=(10 ** 9 + 7)):
res1 = 1
for i in range(n, (n - k), -1):
res1 *= i
res1 %= mod
res2 = 1
for i in range(1, (k + 1)):
res2 *= i
res2 %= mod
return ((res1 * mod_rep_pow(res2, (mod - 2), mod)) % mod)
n = int(input().strip())
a = list(map(int, input().split()))
not_unique = sum(a) - sum([i for i in range(1, n + 1)])
b = []
for i in range(n + 1):
if a[i] == not_unique:
b.append(i)
x = n - (b[1] - b[0])
for i in range(1, n + 2):
print((mod_comb(n + 1, i) - mod_comb(x, (i - 1))))
| def mod_rep_pow(a, n, mod=(10 ** 9 + 7)):
res = 1
while 0 < n:
if n & 1:
res = (res * a) % mod
n -= 1
else:
a = (a ** 2) % mod
n //= 2
return (res % mod)
def mod_inverse(a, mod=(10 ** 9 + 7)):
return mod_rep_pow(a, (mod - 2))
def mod_comb(facts, facts_inverse, n, k, mod=(10 ** 9 + 7)):
return (facts[n] * facts_inverse[k] * facts_inverse[n - k])
n = int(input().strip())
a = list(map(int, input().split()))
not_unique = sum(a) - sum([i for i in range(1, n + 1)])
b = []
for i in range(n + 1):
if a[i] == not_unique:
b.append(i)
x = n - (b[1] - b[0])
mod = 10 ** 9 + 7
facts = [1] * (n + 2)
for i in range(0, n + 1):
facts[i + 1] = (facts[i] * (i + 1) % mod)
facts_inverse = [1] * (n + 2)
facts_inverse[n + 1] = mod_inverse(facts[n + 1])
for i in range(n + 1, 0, -1):
facts_inverse[i - 1] = (facts_inverse[i] * (i)) % mod
for i in range(1, n + 2):
if x < (i - 1):
print((mod_comb(facts, facts_inverse, (n + 1), i) % mod))
else:
print(((mod_comb(facts, facts_inverse, (n + 1), i) - (mod_comb(facts, facts_inverse, x, (i - 1)))) % mod))
| p03674 |
from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
MOD = 10**9 + 7
MAX = n + 5
fact = [1 for _ in range(MAX)]
finv = [1 for _ in range(MAX)]
for i in range(2, MAX):
fact[i] = fact[i - 1] * i % MOD
finv[i] = pow(fact[i], MOD-2, MOD)
def comb(n: int, k: int) -> int:
if n < k or n < 0 or k < 0:
return 0
return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD
d = defaultdict(list)
for i in range(n+1):
d[a[i]].append(i)
if len(d[a[i]]) == 2:
i1, i2 = sorted(d[a[i]])
m1 = i1
m2 = i2 - i1 - 1
m3 = n - i2
# print((i1, i2), m1, m2, m3)
ans = [n]
if n > 1:
ans.append(comb(m1+m2+m3, 2) + m1+m2 + m2+m3 + 1)
for k in range(3, n+1):
ansi = comb(n+1, k)
for l in range(k):
ansi -= comb(m1, l) * comb(m3, k-1-l)
ansi = (ansi + MOD) % MOD
ans.append(ansi)
ans.append(1)
for ansi in ans:
print(ansi)
| from collections import defaultdict
n = int(eval(input()))
a = list(map(int, input().split()))
MOD = 10**9 + 7
MAX = n + 5
fact = [1 for _ in range(MAX)]
finv = [1 for _ in range(MAX)]
for i in range(2, MAX):
fact[i] = fact[i - 1] * i % MOD
finv[i] = pow(fact[i], MOD-2, MOD)
def comb(n: int, k: int) -> int:
if n < k or n < 0 or k < 0:
return 0
return (fact[n] * finv[k] % MOD) * finv[n-k] % MOD
d = defaultdict(list)
for i in range(n+1):
d[a[i]].append(i)
if len(d[a[i]]) == 2:
i1, i2 = sorted(d[a[i]])
m1 = i1
m2 = i2 - i1 - 1
m3 = n - i2
# print((i1, i2), m1, m2, m3)
ans = []
for k in range(1, n+2):
ansi = comb(n+1, k) - comb(m1+m3, k-1)
ansi = (ansi + MOD) % MOD
ans.append(ansi)
for ansi in ans:
print(ansi)
| p03674 |
from math import factorial as f
from collections import Counter as co
n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
d=co(a)
keys=[k for k,v in list(d.items()) if v==2]
dbl=keys[0]
ll=[i for i,x in enumerate(a) if x==dbl]
b=ll[1]-ll[0]-1
m=n-1-b
def pf(a,b,p):
if b==0: return 1
if b%2==0:
d=pf(a,b//2,p)
return d*d%p
if b%2==1:
return (a*pf(a,b-1,p))%p
def comb(n,k,p):
if n<0 or k<0 or n<k: return 0
if n==0 or k==0: return 1
a=f(n)%p
b=f(k)%p
c=f(n-k)%p
return (a*pf(b,p-2,p)*pf(c,p-2,p))%p
for k in range(1,n+2):
print((comb(n+1,k,mod)-comb(m,k-1,mod))) | from math import factorial as f
from collections import Counter as co
n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
d=co(a)
keys=[k for k,v in list(d.items()) if v==2]
dbl=keys[0]
ll=[i for i,x in enumerate(a) if x==dbl]
b=ll[1]-ll[0]
m=n-b
def pf(x,y,p):
if y==0: return 1
if y%2==0:
d=pf(x,y//2,p)
return d*d%p
if y%2==1:
return (x*pf(x,y-1,p))%p
facl=[1]
for i in range(1,n+2):
facl.append(facl[i-1]*i%mod)
invl=[1]*(n+2)
for i in range(1,n+2):
invl[i]=pf(facl[i],mod-2,mod)
def comb(x,k,p):
if x<0 or k<0 or x<k: return 0
if x==0 or k==0: return 1
return (facl[x]*invl[k]*invl[x-k])%mod
for k in range(1,n+2):
print(((comb(n+1,k,mod)-comb(m,k-1,mod))%mod)) | p03674 |
def comb(n,k,p):
from math import factorial
if n<0 or k<0 or n<k:return 0
if n==0 or k==0:return 1
a=factorial(n)%p
b=factorial(k)%p
c=factorial(n-k)%p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
return (d*d)%p
if b%2==1:
return (a*power_func(a,b-1,p))%p
import copy
n=int(eval(input()))
a=list(map(int,input().split()))
mod=10**9+7
b=copy.deepcopy(a)
b.sort()
tmp=-1
for i in range(n):
if b[i]==b[i+1]:
tmp=b[i]
r=[]
for i in range(n+1):
if a[i]==tmp:
r.append(i)
y=abs(r[1]-r[0]-1)
for k in range(1,n+2):
ans=(comb(n-1,k,mod)+comb(n-1,k-2,mod)+comb(n-1,k-1,mod)*2-comb(n-1-y,k-1,mod))%mod
print(ans) | def comb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
n=int(eval(input()))
mod=10**9+7
for i in range( 2, n + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
import copy
a=list(map(int,input().split()))
b=copy.deepcopy(a)
b.sort()
tmp=-1
for i in range(n):
if b[i]==b[i+1]:
tmp=b[i]
r=[]
for i in range(n+1):
if a[i]==tmp:
r.append(i)
y=abs(r[1]-r[0]-1)
for k in range(1,n+2):
ans=(comb(n-1,k,mod)+comb(n-1,k-2,mod)+comb(n-1,k-1,mod)*2-comb(n-1-y,k-1,mod))%mod
print(ans) | p03674 |
# 解説を見た
class Calc:
def __init__(self, max_value, mod):
"""combination(max_value, all)"""
fact = [-1] * (max_value + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, max_value + 1):
fact[x] = x * fact[x - 1] % mod
invs = [-1] * (max_value + 1)
invs[max_value] = pow(fact[max_value], mod - 2, mod)
for x in range(max_value - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
# 逆元はこの求め方が速いらしい
self.fact = fact
self.invs = invs
self.mod = mod
def combination(self, n, r):
if n - r < r:
return self.combination(n, n - r)
if r < 0:
return 0
if r == 0:
return 1
if r == 1:
return n
return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod
def main():
MOD = 10 ** 9 + 7
N = int(eval(input()))
*A, = list(map(int, input().split()))
pos = [-1] * (N + 1)
indices = None
for i, a in enumerate(A):
if pos[a] == -1:
pos[a] = i
else:
indices = pos[a], i
break
width = indices[1] - indices[0] + 1
# 重複要素を両端に持つような区間の長さ
calc = Calc(max_value=N + 1, mod=MOD)
for k in range(1, N + 1 + 1):
res = (calc.combination(N + 1, k) - calc.combination(N + 1 - width, k - 1)) % MOD
print(res)
if __name__ == '__main__':
main()
# PxQxR
# PxRが重複
# 重複要素xの含まれる個数で場合分けをする
# xを含まない
# xを2個とも含む
# 一意
# xを1個含む場合でも、
# Qの要素を含む場合は、どっちのxを取ったか分かる
# Qの要素を含まないとき、どっちのxを取ったか分からない
# cmb(N+1,K)-cmb(PRの総和,K-1)
| def build_combination(n, mod):
def cmb(n, r):
if r < 0 or n < r:
return 0
return (((invs[r] * invs[n - r]) % mod) * fact[n]) % mod
fact = [1] * (n + 1)
for x in range(2, n + 1):
fact[x] = x * fact[x - 1] % mod
invs = [1] * (n + 1)
invs[n] = pow(fact[n], mod - 2, mod)
for x in range(n - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
return cmb
def find(a):
"""重複する数値のindexのペアを返す"""
n = len(a)
checked = [-1] * (n + 1)
for i, x in enumerate(a):
if checked[x] != -1:
return checked[x], i
else:
checked[x] = i
raise ValueError
def main():
mod = 10 ** 9 + 7
n = int(eval(input()))
*a, = list(map(int, input().split()))
cmb = build_combination(n + 1, mod)
li, ri = find(a)
for k in range(1, n + 2):
ret = (cmb(n + 1, k) - cmb(n + 1 - (ri - li + 1), k - 1)) % mod # mod忘れ
print(ret)
# for j in range(k + 1):
# ret -= cmb(li, j) * cmb(n - ri, k - j - 1)
# PxQxRのPRからk-1個とる
# PRの取り方の総和を求めるより、区間PRに含まれる総個数からk-1個選ぶ方法を考える
if __name__ == '__main__':
main()
| p03674 |
class Calc:
def __init__(self, max_value, mod):
"""combination(max_value, all)"""
fact = [-1] * (max_value + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, max_value + 1):
fact[x] = x * fact[x - 1] % mod
invs = [1] * (max_value + 1)
invs[max_value] = pow(fact[max_value], mod - 2, mod)
for x in range(max_value - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
self.fact = fact
self.invs = invs
self.mod = mod
def nCr(self, n, r):
r = min(n - r, r)
if r < 0: return 0
if r == 0: return 1
if r == 1: return n
return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod
def nHr(self, n, r):
return self.nCr(n - 1 + r, r)
def main():
MOD = 10 ** 9 + 7
N = int(input())
A = map(int, input().split())
B = [-1] * (N + 1) # はじめて出現する位置(0-ind)
d = None # 重複要素の出現位置(2点)
for i, x in enumerate(A):
if ~B[x]:
d = B[x], i
break
B[x] = i
# 重複要素L,R(d[0],d[1]),一度だけ出現する数の列X,Y,Z(|X|>=0,|Y|>=0,|Z|>=0)
# X...LY...RZ...
# 重複計上: choose(N+1,K)
# ここから重複分を差し引く
# LRを含む個数
# 0個: 重複計上なし
# 1個: (X,L,YZ)と(XY,R,Z)が一致する場合に重複計上になる==(X,L/R,Z)
# ->
# #==sum(choose(X,a)*choose(Z,K-1-a)),(0<=a<=K-1)
# 見方を変える
# Yの区間以外からK個選ぶ
# ただし,Yの区間外のうちLRから0個取るものと2個取るものを差し引く
# 残りは(X,L/R,Z)を二重計上したものなので,半分にする
# (choose(N+1-Y,K) - choose(N+1-2-Y,K) - choose(N+1-2-Y,K-2)) // 2
# 2個: 重複計上なし
calc = Calc(max_value=N + 1, mod=MOD)
ans = []
Y = d[1] - 1 - d[0]
div2 = pow(2, MOD - 2, MOD)
for k in range(1, N + 2):
t = (
calc.nCr(N + 1, k)
- (
calc.nCr(N + 1 - Y, k)
- calc.nCr(N + 1 - 2 - Y, k)
- calc.nCr(N + 1 - 2 - Y, k - 2)
) * div2 % MOD
) % MOD
ans.append(t)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| class Calc:
def __init__(self, max_value, mod):
"""combination(max_value, all)"""
fact = [-1] * (max_value + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, max_value + 1):
fact[x] = x * fact[x - 1] % mod
invs = [1] * (max_value + 1)
invs[max_value] = pow(fact[max_value], mod - 2, mod)
for x in range(max_value - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
self.fact = fact
self.invs = invs
self.mod = mod
def nCr(self, n, r):
r = min(n - r, r)
if r < 0: return 0
if r == 0: return 1
if r == 1: return n
return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod
def nHr(self, n, r):
return self.nCr(n - 1 + r, r)
def main():
MOD = 10 ** 9 + 7
N = int(input())
A = map(int, input().split())
B = [-1] * (N + 1) # はじめて出現する位置(0-ind)
d = None # 重複要素の出現位置(2点)
for i, x in enumerate(A):
if ~B[x]:
d = B[x], i
break
B[x] = i
# 重複要素L,R(d[0],d[1]),一度だけ出現する数の列X,Y,Z(|X|>=0,|Y|>=0,|Z|>=0)
# X...LY...RZ...
# 重複計上: choose(N+1,K)
# ここから重複分を差し引く
# LRを含む個数
# 0個: 重複計上なし
# 1個: (X,L,YZ)と(XY,R,Z)が一致する場合に重複計上になる==(X,L/R,Z)
# ->
# #==sum(choose(X,a)*choose(Z,K-1-a)),(0<=a<=K-1)
# 見方を変える
# Yの区間以外からK個選ぶ
# ただし,Yの区間外のうちLRから0個取るものと2個取るものを差し引く
# 残りは(X,L/R,Z)を二重計上したものなので,半分にする
# (choose(N+1-Y,K) - choose(N+1-2-Y,K) - choose(N+1-2-Y,K-2)) // 2
# <editorial>
# LRから1個,XZからK-1個取るchoose(XZ,K-1)=choose(N+1-2-Y,K-1)でよい
# 2個: 重複計上なし
calc = Calc(max_value=N + 1, mod=MOD)
ans = []
Y = d[1] - 1 - d[0]
for k in range(1, N + 2):
ans.append((calc.nCr(N + 1, k) - calc.nCr(N + 1 - 2 - Y, k - 1)) % MOD)
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p03674 |
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
def comb(n, r, mod):
if n < r:
return 0
ans = 1
for i in range(max(r, n - r) + 1, n + 1):
ans *= i
ans %= mod
for i in range(1, min(r, n - r) + 1):
ans *= pow(i, mod - 2, mod)
ans %= mod
return ans
def main():
num = int(eval(input()))
data = list(map(int, input().split()))
mod = 10 ** 9 + 7
count_data = Counter(data)
count_data = sorted(list(count_data.items()), key=lambda x: -x[1])
two_num = count_data[0][0]
flg = 0
left, mid, right = 0, 0, 0
for i in range(num + 1):
if data[i] == two_num:
flg += 1
elif flg == 0:
left += 1
elif flg == 1:
mid += 1
else:
right += 1
for now_num in range(1, num + 2):
ans = 0
if now_num == 1:
ans += num
elif now_num == 2:
ans += comb(num - 1, 2, mod)
ans += 1
ans += left + right + mid * 2
else:
ans += comb(num - 1, now_num, mod)
# print('uu', ans)
ans += comb(num - 1, now_num - 2, mod)
# kari = comb(left + right, now_num - 2, mod) - comb(left, now_num - 2, mod) - comb(right, now_num - 2, mod)
# ans -= kari
# print('uu', ans)
ans += comb(num - 1, now_num - 1, mod) * 2 - comb(left, now_num - 1, mod) - comb(right, now_num - 1, mod)
kari = comb(left + right, now_num - 1, mod) - comb(left, now_num - 1, mod) - comb(right, now_num - 1, mod)
# print(kari, 'jjjj')
ans -= kari
# print(comb(num - 1, now_num - 1, mod), comb(num - 1, now_num - 1, mod), comb(num - 1, now_num - 1, mod))
# print('uu', ans)
# print(ans, left, mid, right)
ans %= mod
print(ans)
if __name__ == '__main__':
main()
# test()
| from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
def comb(n, r, mod, bunsi):
if r > n:
return 0
ans = bunsi[n] * pow(bunsi[r], mod - 2, mod) * pow(bunsi[n - r], mod - 2, mod)
return ans
def main():
num = int(eval(input()))
data = list(map(int, input().split()))
mod = 10 ** 9 + 7
count_data = Counter(data)
count_data = sorted(list(count_data.items()), key=lambda x: -x[1])
two_num = count_data[0][0]
flg = 0
left, mid, right = 0, 0, 0
for i in range(num + 1):
if data[i] == two_num:
flg += 1
elif flg == 0:
left += 1
elif flg == 1:
mid += 1
else:
right += 1
bunsi = [0 for i in range(num + 10)]
bunsi[1] = 1
bunsi[0] = 1
for i in range(2, num + 10):
bunsi[i] = (bunsi[i - 1] * i) % mod
for now_num in range(1, num + 2):
ans = 0
if now_num == 1:
ans += num
elif now_num == 2:
ans += comb(num - 1, 2, mod, bunsi)
ans += 1
ans += left + right + mid * 2
else:
ans += comb(num - 1, now_num, mod, bunsi)
ans += comb(num - 1, now_num - 2, mod, bunsi)
ans += comb(num - 1, now_num - 1, mod, bunsi) * 2 - comb(left, now_num - 1, mod, bunsi) - comb(right, now_num - 1, mod, bunsi)
kari = comb(left + right, now_num - 1, mod, bunsi) - comb(left, now_num - 1, mod, bunsi) - comb(right, now_num - 1, mod, bunsi)
ans -= kari
ans %= mod
print(ans)
if __name__ == '__main__':
main()
# test()
| p03674 |
# -*- coding: utf-8 -*-
import sys
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
class FactInvMOD:
""" 階乗たくさん使う時用のテーブル準備 """
def __init__(self, MAX, MOD):
""" MAX：階乗に使う数値の最大以上まで作る """
MAX += 1
self.MAX = MAX
self.MOD = MOD
# 階乗テーブル
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i-1] * i % MOD
# 階乗の逆元テーブル
inverse = [1] * MAX
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
# 最後から戻っていくこのループならMAX回powするより処理が速い
inverse[i] = inverse[i+1] * (i+1) % MOD
self.fact = factorial
self.inv = inverse
def nCr(self, n, r):
""" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) """
if n < r: return 0
# 10C7 = 10C3
r = min(r, n-r)
# 分子の計算
numerator = self.fact[n]
# 分母の計算
denominator = self.inv[r] * self.inv[n-r] % self.MOD
return numerator * denominator % self.MOD
def nPr(self, n, r):
""" 順列 """
if n < r: return 0
return self.fact[n] * self.inv[n-r] % self.MOD
def nHr(self, n, r):
""" 重複組み合わせ """
# r個選ぶところにN-1個の仕切りを入れる
return self.nCr(r+n-1, r)
N = INT()
A = LIST()
# 唯一2つある値を見つける
target = 0
for k, v in list(Counter(A).items()):
if v == 2:
target = k
break
idx = A.index(target)
# 2つある値の1回目と2回目の出現位置の間にいくつ数があるか
btw = A[idx+1:].index(target)
fim = FactInvMOD(N+1, MOD)
for i in range(1, N+2):
# 部分列の総数 - 重複分
ans = fim.nCr(N+1, i) - fim.nCr(N-1-btw, i-1)
print((ans%MOD))
| # -*- coding: utf-8 -*-
import sys
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class ModTools:
""" 階乗たくさん使う時用のテーブル準備 """
def __init__(self, MAX, MOD):
""" MAX：階乗に使う数値の最大以上まで作る """
MAX += 1
self.MAX = MAX
self.MOD = MOD
# 階乗テーブル
factorial = [1] * MAX
factorial[0] = factorial[1] = 1
for i in range(2, MAX):
factorial[i] = factorial[i-1] * i % MOD
# 階乗の逆元テーブル
inverse = [1] * MAX
# powに第三引数入れると冪乗のmod付計算を高速にやってくれる
inverse[MAX-1] = pow(factorial[MAX-1], MOD-2, MOD)
for i in range(MAX-2, 0, -1):
# 最後から戻っていくこのループならMAX回powするより処理が速い
inverse[i] = inverse[i+1] * (i+1) % MOD
self.fact = factorial
self.inv = inverse
def nCr(self, n, r):
""" 組み合わせの数 (必要な階乗と逆元のテーブルを事前に作っておく) """
if n < r: return 0
# 10C7 = 10C3
r = min(r, n-r)
# 分子の計算
numerator = self.fact[n]
# 分母の計算
denominator = self.inv[r] * self.inv[n-r] % self.MOD
return numerator * denominator % self.MOD
N = INT()
A = LIST()
# 重複している値を見つけて、indexを取る
dup = 0
for k, v in list(Counter(A).items()):
if v == 2:
dup = k
break
st = []
for i, a in enumerate(A):
if a == dup:
st.append(i)
# 重複した値より外側にある要素数
M = N - (st[1] - st[0])
mt = ModTools(N+1, MOD)
for i in range(N+1):
# 全組み合わせから、重複した値の影響を受ける分を引く
ans = mt.nCr(N+1, i+1) - mt.nCr(M, i)
print((ans % MOD))
| p03674 |
class ModComb:
def __init__(self, MAX, mod=10 ** 9 + 7):
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, MAX):
fac.append(fac[i - 1] * i % mod)
inv.append(mod - inv[mod % i] * (mod // i) % mod)
finv.append(finv[i - 1] * inv[i] % mod)
self.fac, self.finv, self.mod = fac, finv, mod
def nCk(self, n, k):
if n < k or n < 0 or k < 0:
return 0
fac, finv, mod = self.fac, self.finv, self.mod
return fac[n] * (finv[k] * finv[n - k] % mod) % mod
mod = 10 ** 9 + 7
N, *A = list(map(int, open(0).read().split()))
mc = ModComb(210000, mod=mod)
used = {}
left, right = 0, 0
for i, a in enumerate(A):
if a in used:
right = i
left = used[a]
break
used[a] = i
m = left + N - right
for k in range(1, N + 2):
print(((mc.nCk(N + 1, k) - mc.nCk(m, k - 1)) % mod))
| class ModComb:
def __init__(self, MAX, mod=10 ** 9 + 7):
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
for i in range(2, MAX):
fac.append(fac[i - 1] * i % mod)
inv.append(mod - inv[mod % i] * (mod // i) % mod)
finv.append(finv[i - 1] * inv[i] % mod)
self.fac, self.finv, self.mod = fac, finv, mod
def nCk(self, n, k):
if n < k or n < 0 or k < 0:
return 0
fac, finv, mod = self.fac, self.finv, self.mod
return fac[n] * (finv[k] * finv[n - k] % mod) % mod
mod = 10 ** 9 + 7
N, *A = list(map(int, open(0).read().split()))
mc = ModComb(10 ** 5 + 5, mod=mod)
used = {}
left, right = 0, 0
for i, a in enumerate(A):
if a in used:
right = i
left = used[a]
break
used[a] = i
m = left + N - right
for k in range(1, N + 2):
print(((mc.nCk(N + 1, k) - mc.nCk(m, k - 1)) % mod))
| p03674 |
N = int(eval(input()))
A = [int(i) for i in input().split()]
mod = 7 + 10 ** 9
def Pow(i, n):
if n == 0:
return 1
else:
ans = Pow(i * i % mod, n//2)
if n % 2 == 1:
ans *= i
ans %= mod
return ans
Nfact = [1]
NfactRev = []
for i in range(1, N+2):
Nfact.append((Nfact[i-1] * (i)) % mod)
if A.count(i) == 2:
Double = [A.index(i), A[::-1].index(i)]
NfactRev.append(Pow(Nfact[N+1], mod-2))
for i in range(1, N+1):
NfactRev.append(NfactRev[i-1] * (N+2-i) % mod)
NfactRev.append(1)
doublearray = Double[0] + Double[1]
for i in range(1, N+2):
whole = Nfact[N+1] * NfactRev[-(N+2-i)] * NfactRev[-(i+1)] % mod
if i <= doublearray+1:
double = Nfact[doublearray] * NfactRev[-(doublearray-i+2)] * NfactRev[-i] % mod
else:
double = 0
print((whole - double)) | def Pow(i, n):
if n == 0:
return 1
else:
ans = Pow(i * i % mod, n//2)
if n % 2 == 1:
ans *= i
ans %= mod
return ans
N = int(eval(input()))
A = [int(i) for i in input().split()]
mod = 7 + 10 ** 9
num = [-1 for i in range(N)]
for i, a in enumerate(A):
if num[a-1] == -1:
num[a-1] = i
else:
Double = [num[a-1], i]
Nfact = [1]
for i in range(1, N+2):
Nfact.append((Nfact[i-1] * (i)) % mod)
NfactRev = [Pow(Nfact[N+1], mod-2)]
for i in range(1, N+1):
NfactRev.append(NfactRev[i-1] * (N+2-i) % mod)
NfactRev.append(1)
NfactRev.reverse()
doublearray = N + 1 - (Double[1] - Double[0])
for i in range(1, N+2):
whole = Nfact[N+1] * NfactRev[N+1-i] * NfactRev[i] % mod
if i <= doublearray:
double = Nfact[doublearray-1] * NfactRev[doublearray-i] * NfactRev[i-1] % mod
else:
double = 0
print(((whole - double) % mod)) | p03674 |
import sys
from math import factorial
def main():
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
used = set()
first = 0
second = 0
for i in range(N+1):
if A[i] in used:
second = i
first = A.index(A[i])
else:
used.add(A[i])
factrial = [1] * (N+2)
for k in range(1, N+2):
factrial[k] = (factrial[k-1] * k) % MOD
fact_inv = [1] * (N+2)
fact_inv[N+1] = pow(factrial[N+1], MOD - 2, MOD)
for k in range(N, -1, -1):
fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD
def comb(n, r, MOD):
if n < 0 or r < 0 or n < r:
return 0
else:
return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD
for i in range(1, N+2):
ans = comb(N+1, i, MOD)
for j in range(i):
m_f = first
r_f = j
m_b = N - second
r_b = i - (j + 1)
ans -= comb(m_f, r_f, MOD) * comb(m_b, r_b, MOD)
print((int(ans) % MOD))
if __name__ == '__main__':
main()
| import sys
def main():
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
used = set()
first = 0
second = 0
for i in range(N+1):
if A[i] in used:
second = i
first = A.index(A[i])
else:
used.add(A[i])
factrial = [1] * (N+2)
for k in range(1, N+2):
factrial[k] = (factrial[k-1] * k) % MOD
fact_inv = [1] * (N+2)
fact_inv[N+1] = pow(factrial[N+1], MOD - 2, MOD)
for k in range(N, -1, -1):
fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD
def comb(n, r, MOD):
if n < 0 or r < 0 or n < r:
return 0
else:
return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD
m = first + (N - second)
for i in range(1, N+2):
ans = comb(N+1, i, MOD) - comb(m, i-1, MOD)
print((int(ans) % MOD))
if __name__ == '__main__':
main()
| p03674 |
import sys
stdin = sys.stdin
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
# nの逆元のリスト
def inv_mod(n:int, mod:int) -> list:
inv = [0,1]
for i in range(2,n+1):
inv.append(mod - ((mod//i)*inv[mod%i]) % mod)
return inv
# nの階乗のリスト
def fact(n:int, mod:int) -> list:
fac = [1,1]
res = 1
for i in range(2,n+1):
res = res*i%mod
fac.append(res)
return fac
# nの階乗の逆元のリスト
def fact_inv(n:int, inv:list, mod:int) -> list:
facInv = [1,1]
for i in range(2,n+1):
facInv.append(facInv[i-1]*inv[i] % mod)
return facInv
# 二項係数
def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:
if not (0<=r and r<=n):
return 0
return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod
from collections import Counter
MOD = 10**9+7
n = ni()
a = list(li())
# 被っている数の後にある数の個数を把握
cnt = Counter(a)
db = 0
for k,v in list(cnt.items()):
if v == 2:
db = k
front = a.index(db)
back = a[::-1].index(db)
# 二項係数の準備
inv = inv_mod(n+1,MOD)
fac = fact(n+1, MOD)
facInv = fact_inv(n+1,inv,MOD)
# 出力
for k in range(1, n+2):
ans = nCr(n+1,k,MOD,fac,facInv)
for i in range(k):
temp = nCr(front,i,MOD,fac,facInv) * nCr(back,k-1-i,MOD,fac,facInv)
temp %= MOD
ans -= temp
if ans<0:
ans += MOD
print(ans) | import sys
stdin = sys.stdin
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
# nの逆元のリスト
def inv_mod(n:int, mod:int) -> list:
inv = [0,1]
for i in range(2,n+1):
inv.append(mod - ((mod//i)*inv[mod%i]) % mod)
return inv
# nの階乗のリスト
def fact(n:int, mod:int) -> list:
fac = [1,1]
res = 1
for i in range(2,n+1):
res = res*i%mod
fac.append(res)
return fac
# nの階乗の逆元のリスト
def fact_inv(n:int, inv:list, mod:int) -> list:
facInv = [1,1]
for i in range(2,n+1):
facInv.append(facInv[i-1]*inv[i] % mod)
return facInv
# 二項係数
def nCr(n:int, r:int, mod:int, fac:list, facInv:list) -> int:
if not (0<=r and r<=n):
return 0
return ((fac[n]*facInv[r]) % mod) * facInv[n-r] % mod
from collections import Counter
MOD = 10**9+7
n = ni()
a = list(li())
# 被っている数の後にある数の個数を把握
cnt = Counter(a)
db = 0
for k,v in list(cnt.items()):
if v == 2:
db = k
front = a.index(db)
back = a[::-1].index(db)
# 二項係数の準備
inv = inv_mod(n+1,MOD)
fac = fact(n+1, MOD)
facInv = fact_inv(n+1,inv,MOD)
# 出力
for k in range(1, n+2):
ans = nCr(n+1,k,MOD,fac,facInv) - nCr(front+back,k-1,MOD,fac,facInv)
if ans < 0:
ans += MOD
print(ans) | p03674 |
from functools import reduce
def nCr(N,a,mod):
if a == 0:return 1
num = reduce(lambda x,y:x * y % mod,list(range(N,N-a,-1)))
den = reduce(lambda x,y:x * y % mod,list(range(1,a+1)))
return num * pow(den,mod-2,mod)%mod
def nHr(n,a,mod):
return nCr(n-1+a,n-1,mod)
mod = 10 ** 9 + 7
n = int(eval(input()))
lis = list(map(int,input().split()))
li = [-1] * n
for i in range(n+1):
if li[lis[i]-1] != -1:
left = li[lis[i]-1]+1
right = i+1
break
else:li[lis[i]-1] = i
for k in range(1,n+2):
# print(nCr(n+1,k,mod),nCr(left+n-right,k-1,mod))
print((nCr(n+1,k,mod)-nCr(left+n-right,k-1,mod)))
| def cmb(N, r, mod):
if ( r<0 or r>N ):
return 0
r = min(r, N-r)
return g1[N] * g2[r] * g2[N-r] % mod
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
mod = 10 ** 9 + 7
n = int(eval(input()))
lis = list(map(int,input().split()))
li = [-1] * n
for i in range( 2, n + 2 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
for i in range(n+1):
if li[lis[i]-1] != -1:
left = li[lis[i]-1]+1
right = i+1
break
else:li[lis[i]-1] = i
for k in range(1,n+2):
# print(nCr(n+1,k,mod),nCr(left+n-right,k-1,mod))
ans = cmb(n+1,k,mod)-cmb(left+n-right,k-1,mod)
if ans < 0:
ans += mod
print(ans) | p03674 |
def comb(k,r):
"""kCpを求める"""
if k<0 or r<0 or r>k: return 0
elif k==0 or r==0: return 1
else:
return (X[k]*Y[r]*Y[k-r])
def power_func(a,b,p):
"""a^b mod p を求める"""
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
return d*d %p
if b%2==1:
return (a*power_func(a,b-1,p ))%p
n = int(eval(input()))
a = list(map(int,input().split()))
p=10**9+7
ans=0
X=[1] #階乗テーブル
for i in range(1,n+2):
X+=[ (X[-1]*i) %p ]
Y=[1]*(n+2) #階乗の逆元テーブル
Y[n+1]=power_func(X[n+1],p-2,p)
for i in range(n,-1,-1):
Y[i]=Y[i+1]*(i+1) %p
#ダブりをみつける
check = [0]*n
for i in range(n+1):
if check[a[i]-1]==1: dub = a[i]
else: check[a[i]-1] = 1
indexes = [i for i, x in enumerate(a) if x == dub]
ind1, ind2 = indexes[0], indexes[1]
for i in range(1,n+2):
ans = comb(n+1, i)
if ind1 + n -ind2 +1 >= i:
for j in range(i):
ans -= comb(ind1, j)* comb(n-ind2,i-j-1)
print((ans%p)) | def comb(k,r):
"""kCpを求める"""
if k<0 or r<0 or r>k: return 0
elif k==0 or r==0: return 1
else:
return (X[k]*Y[r]*Y[k-r])
def power_func(a,b,p):
"""a^b mod p を求める"""
if b==0: return 1
if b%2==0:
d=power_func(a,b//2,p)
return d*d %p
if b%2==1:
return (a*power_func(a,b-1,p ))%p
n = int(eval(input()))
a = list(map(int,input().split()))
p=10**9+7
ans=0
X=[1] #階乗テーブル
for i in range(1,n+2):
X+=[ (X[-1]*i) %p ]
Y=[1]*(n+2) #階乗の逆元テーブル
Y[n+1]=power_func(X[n+1],p-2,p)
for i in range(n,-1,-1):
Y[i]=Y[i+1]*(i+1) %p
#ダブりをみつける
check = [0]*n
for i in range(n+1):
if check[a[i]-1]==1: dub = a[i]
else: check[a[i]-1] = 1
indexes = [i for i, x in enumerate(a) if x == dub]
ind1, ind2 = indexes[0], indexes[1]
for i in range(1,n+2):
ans = comb(n+1, i)
if ind1 + n -ind2 +1 >= i:
ans -= comb(ind1 + n -ind2, i-1)
print((ans%p)) | p03674 |
from collections import Counter
n,*a = list(map(int,open(0).read().split()))
dbl = Counter(a).most_common()[0][0]
l,r = [i for i,j in enumerate(a) if j==dbl]
const = n+l-r
m = n + 1
mod = 10**9+7
fac = [1]*(m+1)
inv = [1]*(m+1)
for i in range(1,m+1):
fac[i] = fac[i-1] * i % mod
inv[-1] = pow(fac[-1], mod - 2, mod)
for i in range(m-1, -1, -1):
inv[i] = inv[i+1] * (i+1) % mod
def cmb(n,r):
if n<r:return 0
return fac[n] * inv[n-r] * inv[r] % mod
for k in range(1,n+2):
print(((cmb(n+1,k)-cmb(const,k-1)) % mod)) | def main():
n,*a = list(map(int,open(0).read().split()))
dbl = sum(a)-n*(n+1)//2
l,r = [i for i,j in enumerate(a) if j==dbl]
const = n+l-r
m = n + 1
mod = 10**9+7
fac = [1]*(m+1)
inv = [1]*(m+1)
for i in range(1,m+1):
fac[i] = fac[i-1] * i % mod
inv[-1] = pow(fac[-1], mod - 2, mod)
for i in range(m-1, -1, -1):
inv[i] = inv[i+1] * (i+1) % mod
def cmb(n,r):
if n<r:return 0
return fac[n] * inv[n-r] * inv[r] % mod
for k in range(1,n+2):
print(((cmb(n+1,k)-cmb(const,k-1)) % mod))
if __name__=="__main__":main() | p03674 |
n=int(eval(input()))
a=list(map(int,input().split()))
mod=pow(10,9)+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, n + 2 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
# 二つあるやつはどの場所にあるか検索
f=[-1]*(n+1)
l,r=0,0
for i in range(n):
ai=a[i]
if f[ai]==-1:
f[ai]=i
else:
l=f[ai]
r=n-i
break
for k in range(1,n+2):
a=cmb(n+1,k,mod)
for i in range(k+1):
a-=cmb(l,i,mod)*cmb(r,k-i-1,mod)
print(a)
| n=int(eval(input()))
a=list(map(int,input().split()))
mod=pow(10,9)+7
#ans=[int(input()) for _ in range(n+1)]
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, n + 2 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
# 二つあるやつの左の方の左にl個、右のやつの右のほうにr個数字がある
f=[-1]*(n+1)
l,r=0,0
for i in range(n+1):
ai=a[i]
if f[ai]==-1:
f[ai]=i
else:
l=f[ai]
r=n-i
break
for k in range(1,n+2):
a=cmb(n+1,k,mod)
if l+r>=k-1:
a-=cmb(l+r,k-1,mod)
#print(a==ans[k-1],a,ans[k-1])
print((a%mod)) | p03674 |
n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
N = 100000
#逆元テーブル
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
#階乗計算
kai = [1, 1]
rev_kai = [1, inv_t[1]]
for i in range(2, N):
kai.append(kai[-1] * i % mod)
rev_kai.append(rev_kai[-1] * inv_t[i] % mod)
# コンビネーション計算
def cmb(n, r):
if n < r or n < 0 or r < 0:
return 0
else:
return kai[n] * rev_kai[r] * rev_kai[n-r] % mod
d = {}
n1 = 0
n2 = 0
n3 = 0
for i, ai in enumerate(a):
if ai not in d:
d[ai] = i
else:
n1 = d[ai]
n2 = i - d[ai] - 1
n3 = n - i - 1
break
for i in range(1, n+2):
ans = 0
# Xを選ばない
ans += cmb(n-1, i) # 0
# Xを2回選ぶ
ans += cmb(n-1, i-2) # 2
# Xを1回選ぶ
ans += cmb(n-1-n2, i-1) #
for j in range(1, n2+1):
ans += 2 * cmb(n2, j) * cmb(n-n2-1, i-j-1) % mod
ans %= mod
print((ans % mod))
| n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
N = 100000
#逆元テーブル
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
#階乗計算
kai = [1, 1]
rev_kai = [1, inv_t[1]]
for i in range(2, N):
kai.append(kai[-1] * i % mod)
rev_kai.append(rev_kai[-1] * inv_t[i] % mod)
# コンビネーション計算
def cmb(n, r):
if n < r or n < 0 or r < 0:
return 0
else:
return kai[n] * rev_kai[r] * rev_kai[n-r] % mod
d = {}
# n1個 X n2個 X n3個
n1 = 0
n2 = 0
n3 = 0
for i, ai in enumerate(a):
if ai not in d:
d[ai] = i
else:
n1 = d[ai]
n2 = i - d[ai] - 1
n3 = n - i
break
for i in range(1, n+2):
ans = 0
# Xを選ばない
ans += cmb(n-1, i)
# Xを2回選ぶ
ans += cmb(n-1, i-2)
# Xを1回選ぶ かつ Xの間からは選ばない
ans += cmb(n-1-n2, i-1)
# Xを1回選ぶ かつ Xの間から一つ以上選ぶ
if i >= 2 and i <= n:
ans += 2 * (cmb(n2+n1+n3, i-1) - cmb(n1+n3, i-1))
print((ans % mod))
| p03674 |
def comb(n,k,p):
from math import factorial
if n<0 or k<0 or n<k: return 0
if n==0 or k==0: return 1
a,b,c = factorial(n)%p,factorial(k)%p,factorial(n-k)%p
return (a*power_func(b,p-2,p)*power_func(c,p-2,p))%p
def power_func(a,b,p):
if b==0: return 1
elif b%2==0:
d = power_func(a,b//2,p)
return d**2 %p
elif b%2==1: return (a*power_func(a,b-1,p))%p
from collections import Counter
n = int(eval(input()))
a = [int(i) for i in input().split()]
twice = Counter(a).most_common(1)[0][0]
x,y = (i for i,j in enumerate(a) if j == twice)
num,y = 1,n-y
for i in range(1,x+y+2):
ans = comb(n+1,i,10**9+7)
for j in range(max(0,i-y-1),min(i,x+1)):
ans -= comb(x,j,10**9+7)*comb(y,i-j-1,10**9+7)
print(ans)
for i in range(x+y+2,n+2): print((comb(n+1,i,10**9+7))) | def comb(n,k):
if n<k or n==0: return 0
elif k==0: return 1
else: return f[n]*p[k]*p[n-k]%(10**9+7)
from collections import Counter
n = int(eval(input()))
print(n)
a = [int(i) for i in input().split()]
twice = Counter(a).most_common(1)[0][0]
x,y = (i for i,j in enumerate(a) if j == twice)
num,y,f,p = 1,n-y,[1],[1]
for i in range(1,n+2):
f.append(f[-1]*i%(10**9+7))
p.append(pow(f[-1],10**9+5,10**9+7))
for i in range(2,x+y+2): print(((comb(n+1,i)-comb(x+y,i-1))%(10**9+7)))
for i in range(x+y+2,n+2): print((comb(n+1,i))) | p03674 |
from collections import Counter
U = 10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
n = int(eval(input()))
A = list(map(int, input().split()))
x = Counter(A).most_common()[0][0]
left = A.index(x)
right = A[::-1].index(x)
print(n)
for k in range(2, n+2):
ans = comb(n+1, k) - comb(left+right, k-1)
ans %= MOD
print(ans) | from collections import Counter
U = 10**5+1
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
n = int(eval(input()))
A = list(map(int, input().split()))
x = Counter(A).most_common()[0][0]
left = A.index(x)
right = A[::-1].index(x)
for k in range(1, n+2):
ans = comb(n+1, k) - comb(left+right, k-1)
ans %= MOD
print(ans)
| p03674 |
from collections import Counter
N = int(input())
src = list(map(int,input().split()))
ctr = Counter(src)
most = ctr.most_common(1)[0][0]
i1 = src.index(most)
i2 = src[i1+1:].index(most) + i1+1
d = i2 - i1
MOD = 10**9+7
def mul(a,b):
return (a*b) % MOD
def pow(a,n): # a^n
ret = 1
mag = a
while n > 0:
if n & 1:
ret = mul(ret, mag)
mag = mul(mag, mag)
n >>= 1
return ret
def inv(a):
return pow(a, MOD-2)
fac = [1]
fac_inv = [1]
for n in range (1,N+3):
f = mul(fac[n-1], n)
fac.append(f)
fac_inv.append(inv(f))
def ncr(n,r):
return mul(mul(fac[n], fac_inv[n-r]), fac_inv[r])
anss = []
for r in range(1,N+2):
anss.append(ncr(N+1,r))
n = N-d
for r in range(n+1):
anss[r] -= ncr(n,r)
anss[r] %= MOD
print(*anss, sep='\n')
| from collections import Counter
N = int(input())
src = list(map(int,input().split()))
ctr = Counter(src)
doub = ctr.most_common()[0][0]
i1 = src.index(doub)
i2 = src[::-1].index(doub)
doub_len = (i1+i2+1)
MOD = 10**9+7
fac = [1,1] + [0]*N
finv = [1,1] + [0]*N
inv = [0,1] + [0]*N
for i in range(2,N+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = []
for i in range(1,N+2):
ans.append(ncr(N+1,i))
for i in range(doub_len):
ans[i] -= ncr(doub_len-1, i)
ans[i] %= MOD
print(*ans,sep='\n')
| p03674 |
from collections import Counter
N = int(input())
src = list(map(int,input().split()))
ctr = Counter(src)
doub = ctr.most_common()[0][0]
i1 = src.index(doub)
i2 = src[::-1].index(doub)
doub_len = (i1+i2+1)
MOD = 10**9+7
fac = [1,1] + [0]*N
finv = [1,1] + [0]*N
inv = [0,1] + [0]*N
for i in range(2,N+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = []
for i in range(1,N+2):
ans.append(ncr(N+1,i))
for i in range(doub_len):
ans[i] -= ncr(doub_len-1, i)
ans[i] %= MOD
print(*ans,sep='\n')
| N = int(input())
A = list(map(int,input().split()))
MOD = 10**9+7
from collections import Counter
ctr = Counter(A)
d = ctr.most_common(1)[0][0]
x = A.index(d)
y = x+1 + A[x+1:].index(d)
f = x + N-y
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = []
for i in range(1,N+2):
ans.append((comb(N+1,i) - comb(f,i-1)) % MOD)
print(*ans, sep='\n')
| p03674 |
def comb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
MOD = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
appeared = set()
dup_right = 0
dup = 0
for i, x in enumerate(a):
if x in appeared:
dup_right = n - i
dup = x
break
appeared.add(x)
dup_left = 0
for i, x in enumerate(a):
if x == dup:
dup_left = i
break
for k in range(1, n + 2):
print(((comb(n + 1, k, MOD) - comb(dup_right + dup_left, k - 1, MOD) + MOD) % MOD))
| def comb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 # 出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
MOD = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
appeared = set()
dup_right = 0
dup = 0
for i, x in enumerate(a):
if x in appeared:
dup_right = n - i
dup = x
break
appeared.add(x)
dup_left = 0
for i, x in enumerate(a):
if x == dup:
dup_left = i
break
for k in range(1, n + 2):
print(((comb(n + 1, k, MOD) - comb(dup_right + dup_left, k - 1, MOD)) % MOD))
| p03674 |
n = int(eval(input()))
a = list(input().split())
if n == 1:
print((1))
print((1))
exit()
MOD = 10 ** 9 + 7
b = sorted(a)
for i in range(n):
if b[i] == b[i + 1]:
d = b[i]
break
first = a.index(d)
for i in range(first + 1, n + 1):
if a[i] == d:
second = i
w = n + first - second
c = [0 for _ in range(n + 2)]
d = [0 for _ in range(n + 2)]
L = 1
H = 1
for i in range(1, n + 2):
L *= i
H *= n + 2 - i
c[i] = L
d[i] = H
e = [0 for _ in range(w + 1)]
temp = 1
for i in range(1, w + 1):
temp *= w + 1 - i
e[i] = temp
def ncmb(k):
return d[k] // c[k]
def wcmb(k):
if k > w or k <= 0:
return 0
elif k == w:
return 1
else:
return e[k] // c[k]
print(n)
for k in range(2, n + 2):
ans = ncmb(k) - wcmb(k-1)
print((ans % MOD))
| n = int(eval(input()))
a = list(input().split())
if n == 1:
print((1))
print((1))
exit()
MOD = 10 ** 9 + 7
b = sorted(a)
for i in range(n):
if b[i] == b[i + 1]:
d = b[i]
break
first = a.index(d)
for i in range(first + 1, n + 1):
if a[i] == d:
second = i
w = n + first - second
print(n)
x = n + 1
y = 1
z = 1
for _ in range(n):
x *= n + 1 - z
x //= z + 1
if z <= w:
y *= w + 1 - z
y //= z
else:
y = 0
print(((x - y) % MOD))
z += 1
| p03674 |
n = int(eval(input()))
a = list(input().split())
if n == 1:
print((1))
print((1))
exit()
MOD = 10 ** 9 + 7
b = sorted(a)
for i in range(n):
if b[i] == b[i + 1]:
d = b[i]
break
first = a.index(d)
for i in range(first + 1, n + 1):
if a[i] == d:
second = i
w = n + first - second
print(n)
x = n + 1
y = 1
z = 1
for _ in range(n):
x *= n + 1 - z
x //= z + 1
if z <= w:
y *= w + 1 - z
y //= z
else:
y = 0
print(((x - y) % MOD))
z += 1
| n = int(eval(input()))
a = list(map(int, input().split()))
class ModInv:
def __init__(self, size, MOD):
self.inv = [0] * (size + 1)
self.inv[1] = 1
for i in range(2, size + 1):
self.inv[i] = (-(MOD // i) * self.inv[MOD%i]) % MOD
if n == 1:
print((1))
print((1))
exit()
MOD = 10 ** 9 + 7
b = sorted(a)
for i in range(n):
if b[i] == b[i + 1]:
break
first = a.index(b[i])
for i in range(first + 1, n + 1):
if a[i] == a[first]:
second = i
w = n + first - second
inv = ModInv(n + 1, MOD)
c = [1] * (n + 2)
d = [1] * (n + 2)
for i in range(n + 1):
d[i + 1] = (d[i] * inv.inv[i + 1]) % MOD
for i in range(n + 1):
c[i + 1] = (c[i] * (i + 1)) % MOD
print(n)
for k in range(2, n + 2):
ans = (((c[n+1] * d[n+1-k]) % MOD) * d[k]) % MOD
if w >= k - 1:
ans -= (((c[w] * d[w-k+1]) % MOD) * d[k-1]) % MOD
print(( ans % MOD ))
| p03674 |
from collections import defaultdict
n = int(eval(input())) + 1
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
# 1を一つだけ選ぶやつは重複する可能性
d = defaultdict(int)
left = right = 0
for i in range(n):
if d[a[i]] > 0:
right = i
left = a.index(a[i])
break
d[a[i]] += 1
fac = [1] * (n + 1)
for i in range(1, n + 1):
fac[i] = fac[i - 1] * i % mod
def inv(x):
return pow(x, mod - 2, mod)
def c(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n] * inv(fac[n - k] * fac[k] % mod) % mod
left_len = left
right_len = n - right - 1
print((n - 1))
for i in range(2, n + 1):
ans = c(n, i) - (c(left_len + 1 + right_len, i) -
c(left_len + right_len, i))
print((ans % mod))
| n = int(eval(input())) + 1
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
# 1を一つだけ選ぶやつは重複する可能性
d = [False] * (n + 1)
left = right = 0
for i in range(n):
if d[a[i]]:
right = i
left = a.index(a[i])
break
d[a[i]] = True
fac = [1] * (n + 1)
for i in range(1, n + 1):
fac[i] = fac[i - 1] * i % mod
def inv(x):
return pow(x, mod - 2, mod)
def c(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n] * inv(fac[n - k] * fac[k] % mod) % mod
left_len = left
right_len = n - right - 1
print((n - 1))
for i in range(2, n + 1):
ans = c(n, i) - c(left_len + right_len, i - 1)
print((ans % mod))
| p03674 |
N = int(eval(input()))
A = [int(_) for _ in input().split()]
mod = 10**9+7
memo=[0]*(N+2)
def comb(x, y):
if x == N-1 and memo[y] > 0:
return memo[y]
elif y > x:
return 0
elif y * 2 > x:
y = x - y
result = 1
for j in range(1, y + 1):
result *= (x + j - y) * pow(j, mod - 2, mod)
result %= mod
if x == N-1:
memo[y] = result
return result
dupl = sum(A)-N*(N+1)//2
ds = []
for _ in range(N+1):
if A[_] == dupl:
ds += [_]
i, j = ds
print(N)
for k in range(2, N+2):
print(((comb(N-1, k)+comb(N-1, k-2)+2*comb(N-1, k-1)-comb(N-j+i, k-1)) % mod))
| N = int(eval(input()))
A = [int(_) for _ in input().split()]
mod = 10**9 + 7
f = [1] * (N + 2)
fi = [1] * (N + 2)
for i in range(2, N + 2):
f[i] = i * f[i - 1]
f[i] %= mod
for i in range(2, N + 2):
fi[i] = fi[i - 1] * pow(i, mod - 2, mod)
fi[i] %= mod
def comb(n, r):
if 0 <= n and 0 <= r and 0 <= n - r:
return (f[n] * fi[r] * fi[n - r]) % mod
else:
return 0
b = set()
for a in A:
if a in b:
break
b.add(a)
c = []
for i in range(N + 1):
if A[i] == a:
c += [i]
i, j = c
for x in range(1, N + 2):
print(((comb(N + 1, x) - (comb(N - j + i, x - 1))) % mod))
| p03674 |
#11
n = int(eval(input()))
a = list(map(int, input().split()))
flag = [a.count(a[i])-1 for i in range(n+1) ]
p = flag.index(1) + list(reversed(flag)).index(1)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
mod = 10**9 + 7
for i in range( 2, n + 2 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def combination(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
for i in range(n+1):
if ( p>=i ):
c = combination(n+1, i+1) - combination(p, i)
else:
c = combination(n+1, i+1)
print(( int(c) )) |
MOD = 10**9+7
n = int(eval(input()))
la = list(map(int,input().split()))
L = [-1]*(n+1)
l = 0
for i in range(n+1):
a = la[i]
if L[a] == -1:
L[a] = i
else:
l = i - L[a] - 1
break
MAX = n
factorial = [1, 1]
inverse = [0, 1]
inverse_factorial = [1, 1]
for i in range(2,MAX+1):
factorial.append( (factorial[-1]*i)%MOD )
inverse.append( (-inverse[MOD%i]*(MOD//i))%MOD )
inverse_factorial.append( (inverse_factorial[-1]*inverse[-1])%MOD )
def C_MOD(n, k):
if k < 0 or k > n:
return 0
k = min(k,n-k)
return factorial[n] * inverse_factorial[k] * inverse_factorial[n-k] % MOD
print(n)
#print((2*C_MOD(n-1,1)-C_MOD(n-1-l,1)+C_MOD(n-1,2)+1)%MOD)
for i in range(2,n+1):
if n > l+1:
print(((2*C_MOD(n-1,i-1)-C_MOD(n-1-l,i-1)+C_MOD(n-1,i)+C_MOD(n-1,i-2))%MOD))
else:
print(((2*C_MOD(n-1,i-1)+C_MOD(n-1,i)+C_MOD(n-1,i-2))%MOD))
print((1)) | p03674 |
n=int(eval(input()))
l=list(map(int,input().split()))
cnt=[0 for i in range(n+1)]
mod=10**9+7
fact=[1]*(n+2)
inv=[1]*(n+2)
for i in range(2,n+2):
fact[i]=i*fact[i-1]%mod
inv[-1]=pow(fact[-1],mod-2,mod)
for i in range(n+1,1,-1):
inv[i-1]=inv[i]*i%mod
def comb(x,y):return fact[x]*inv[y]%mod*inv[x-y]%mod if x>=y>=0 else 0
for i in range(n+1):
if cnt[l[i]]:
r=cnt[l[i]]+n-i;break
cnt[l[i]]+=i
else:r=n-cnt[l[0]]
for i in range(1,n+2):
print(((comb(n+1,i)-comb(r,i-1))%mod)) | n=int(eval(input()))
l=list(map(int,input().split()))
memo={}
for i in range(n+1):
if l[i]in memo:
g=l[i]
x,y=memo[g],i
break
memo[l[i]]=i
mod=10**9+7
fact=[1]*(n+1+1)
inv=[1]*(n+1+1)
for i in range(2,n+1+1):
fact[i]=i*fact[i-1]%mod
inv[-1]=pow(fact[-1],mod-2,mod)
for i in range(n+1,1,-1):
inv[i-1]=inv[i]*i%mod
def comb(x,y):return fact[x]*inv[y]%mod*inv[x-y]%mod if x>=y>=0 else 0
for i in range(1,n+2):print(((comb(n+1,i)-comb(x+n-y,i-1))%mod)) | p03674 |
def combination_modp(n, r, p): # nCr modpを求める
r = min(n-r, r)
result = 1
for i in range(n, n-r, -1):
result *= i
result %=p
for i in range(1, r+1):
result *= pow(i,p-2,p)
result %= p
return result
n = int(eval(input()))
a = list(map(int,input().split()))
search = [-1 for i in range(n)]
l,r = -1,-1
for i,x in enumerate(a):
if search[x-1] == -1:
search[x-1] = i
else:
l = search[x-1]
r = i
#print(l,r)
p = 10**9 + 7
for i in range(1,n+2):
if l+n-r+1 >= i:
ans = combination_modp(n+1,i,p)-combination_modp(l+n-r,i-1,p)
else:
ans = combination_modp(n+1,i,p)
print((ans%p)) | n = int(eval(input()))
a = list(map(int,input().split()))
search = [-1 for i in range(n)]
l,r = -1,-1
for i,x in enumerate(a):
if search[x-1] == -1:
search[x-1] = i
else:
l = search[x-1]
r = i
#print(l,r)
p = 10**9 + 7
#前計算
comb1 = [0 for _ in range(n+1)]
comb1[0] = n+1
x = n+1
for i in range(1,n+1):
x = (x*(n-i+1))%p
x = (x*pow(i+1,p-2,p))%p
comb1[i] = x
comb2 = [0 for _ in range(n+1)]
comb2[0] = 1
x = 1
for i in range(1,l+n-r+1):
x = (x*(n+l-r-i+1))%p
x = (x*pow(i,p-2,p))%p
comb2[i] = x
for i in range(n+1):
ans = comb1[i]-comb2[i]
print((ans%p)) | p03674 |
from collections import Counter
n, *a = list(map(int, open(0).read().split()))
n += 1
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
mod = 10 ** 9 + 7
N = n
# 元テーブル
g1 = [0] * (N + 1)
g1[0] = 1
g1[1] = 1
# 逆元テーブル
g2 = [0] * (N + 1)
g2[0] = 1
g2[1] = 1
# 逆元テーブル計算用テーブル
inverse = [0] * (N + 1)
inverse[0] = 0
inverse[1] = 1
for i in range(2, N + 1):
g1[i] = (g1[i - 1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod // i)) % mod
g2[i] = (g2[i - 1] * inverse[i]) % mod
d = Counter(a).most_common(1)[0][0]
lr = [i for i, e in enumerate(a) if e == d]
l = lr[1] - lr[0] + 1
answer = [(cmb(n, i, mod) - cmb(n - l, i - 1, mod)) % mod for i in range(1, n + 1)]
print(('\n'.join(map(str, answer)))) | from collections import Counter
n, *a = list(map(int, open(0).read().split()))
n += 1
def cmb(n, r, mod=10 ** 9 + 7):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
def make_table(n, mod=10 ** 9 + 7):
mod = mod
N = n
# 元テーブル
g1 = [0] * (N + 1)
g1[0] = 1
g1[1] = 1
# 逆元テーブル
g2 = [0] * (N + 1)
g2[0] = 1
g2[1] = 1
# 逆元テーブル計算用テーブル
inverse = [0] * (N + 1)
inverse[0] = 0
inverse[1] = 1
for i in range(2, N + 1):
g1[i] = (g1[i - 1] * i) % mod
inverse[i] = (-inverse[mod % i] * (mod // i)) % mod
g2[i] = (g2[i - 1] * inverse[i]) % mod
return g1, g2, inverse
d = Counter(a).most_common(1)[0][0]
lr = [i for i, e in enumerate(a) if e == d]
l = lr[1] - lr[0] + 1
g1, g2, inverse = make_table(n)
MOD = 10 ** 9 + 7
answer = [(cmb(n, i) - cmb(n - l, i - 1)) % MOD for i in range(1, n + 1)]
print(('\n'.join(map(str, answer)))) | p03674 |
#!/usr/bin/env python3
import sys
from collections import Counter
INF = float("inf")
MOD = 1000000007 # type: int
def cmb(n, r):
r = min(r, n-r)
if r < 0 or r > n:
return 0
if r == 0:
return 1
if r == 1:
return n
numer = [n - r + k + 1 for k in range(r)]
denom = [k + 1 for k in range(r)]
for p in range(2, r+1):
pivot = denom[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1, r, p):
numer[k - offset] /= pivot
denom[k] /= pivot
result = 1
for k in range(r):
if numer[k] > 1:
result *= int(numer[k])
return result
def solve(n: int, a: "List[int]"):
(m, _), = Counter(a).most_common(1)
left = a.index(m)
right = a.index(m, left+1)
for i in range(1, n+2):
print(((cmb(n+1, i)-cmb(n-right+left, i-1)) % MOD))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(n+1)] # type: "List[int]"
solve(n, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from collections import Counter
INF = float("inf")
MOD = 1000000007 # type: int
class Combination(object):
def __init__(self, N, mod):
self.N = N
self.MOD = mod
self.fac = [0] * (N+1)
self.finv = [0] * (N+1)
self.inv = [0] * (N+1)
self.cmb_init()
def cmb_init(self):
self.fac[0] = 1
self.fac[1] = 1
self.finv[0] = 1
self.finv[1] = 1
self.inv[1] = 1
for i in range(2, self.N+1):
self.fac[i] = self.fac[i-1]*i % self.MOD
self.inv[i] = -self.inv[self.MOD % i]*(self.MOD//i) % self.MOD
self.finv[i] = self.finv[i-1]*self.inv[i] % self.MOD
def __call__(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return self.fac[n] * (self.finv[k]*self.finv[n-k] % self.MOD) % self.MOD
def solve(n: int, a: "List[int]"):
(m, _), = Counter(a).most_common(1)
left = a.index(m)
right = a.index(m, left+1)
cmb = Combination(n+1, MOD)
for i in range(1, n+2):
print(((cmb(n+1, i)-cmb(n-right+left, i-1)) % MOD))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
n = int(next(tokens)) # type: int
a = [int(next(tokens)) for _ in range(n+1)] # type: "List[int]"
solve(n, a)
if __name__ == '__main__':
main()
| p03674 |
def d_11(N, A): # N:整数の種類, A:数列
M = 10**9 + 7 # 求めた解の剰余をこれで取る
# 重複した数のインデックスを求める
from collections import Counter
c = Counter(A).most_common(n=1)[0][0] # 重複した整数の値を取得
index = [i for i, x in enumerate(A) if x == c] # 重複した整数のインデックス
l = index[0] + 1
r = index[1] + 1
# フェルマーの小定理を用いてコンビネーションを効率よく計算
factrial = [1] * (N + 2) # 0~N+1までの階乗のテーブルを作る
for k in range(1, N + 2):
factrial[k] = (factrial[k - 1] * k) % M
fact_inv = [1] * (N + 2)
fact_inv[N + 1] = pow(factrial[N + 1], M - 2, M)
for k in range(N, -1, -1):
fact_inv[k] = (fact_inv[k + 1] * (k + 1)) % M
def nCr(n, r, M):
if n < 0 or r < 0 or n < r:
return 0
else:
return (factrial[n] * fact_inv[r] * fact_inv[n - r]) % M
ans = ''
for k in range(1, N + 2):
ans += '{}\n'.format((nCr(N + 1, k, M) -
nCr((l - 1) + (N + 1 - r), k - 1, M)) % M)
return ans[:-1]
N = int(eval(input()))
A = [int(i) for i in input().split()]
print((d_11(N, A))) | def d_11(MOD=10**9 + 7):
from collections import Counter
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
N = int(eval(input()))
A = [int(i) for i in input().split()]
# 重複した数のインデックスを求める
c = Counter(A).most_common(n=1)[0][0] # 重複した整数の値を取得
index = [i for i, x in enumerate(A) if x == c] # 重複した整数のインデックス
left = index[0] + 1
right = index[1] + 1
comb = Combination(N + 1).combination
ans = [(comb(N + 1, k) - comb(N - (right - left), k - 1)) % MOD for k in range(1, N + 2)]
return '\n'.join(map(str, ans))
print((d_11())) | p03674 |
def d_11(MOD=10**9 + 7):
from collections import Counter
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
N = int(eval(input()))
A = [int(i) for i in input().split()]
# 重複した数のインデックスを求める
c = Counter(A).most_common(n=1)[0][0] # 重複した整数の値を取得
index = [i for i, x in enumerate(A) if x == c] # 重複した整数のインデックス
left = index[0] + 1
right = index[1] + 1
comb = Combination(N + 1).combination
ans = [(comb(N + 1, k) - comb(N - (right - left), k - 1)) % MOD for k in range(1, N + 2)]
return '\n'.join(map(str, ans))
print((d_11())) | def d_11(MOD=10**9 + 7):
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ["mod", "factorial", "inverse"]
def __init__(self, max_n: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_n + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_n, 0, -1):
inv_append(inv[-1] * i % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
N = int(eval(input()))
A = [int(i) for i in input().split()]
# 重複した数のインデックスを求める
appeared = set()
for k, a in enumerate(A):
if a in appeared:
left, right = A.index(a), k
break
appeared.add(a)
c = Combination(N + 1).combination
ans = [(c(N + 1, k) - c(N - (right - left), k - 1)) % MOD for k in range(1, N + 2)]
return '\n'.join(map(str, ans))
print((d_11())) | p03674 |
# ABC143C - Slimes
from itertools import groupby
def main():
N = int(eval(input()))
S = input().rstrip()
ans = len(tuple(groupby(S)))
print(ans)
if __name__ == "__main__":
main() | def main():
N = int(eval(input()))
S = input().rstrip()
S += "."
ans, cur = 0, S[0]
for s in S[1:]:
if s != cur:
ans += 1
cur = s
print(ans)
if __name__ == "__main__":
main() | p02887 |
f=input;f()
import itertools as it
print((len(list(it.groupby(f()))))) | f=input;n=int(f());s=f()
print((1+sum(s[i]!=s[i-1] for i in range(1,n)))) | p02887 |
# 2019-11-19 10:28:31(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def main():
n, s = sys.stdin.read().split()
n = int(n)
count = 1
for i in range(n-1):
if s[i+1] != s[i]:
count += 1
print(count)
if __name__ == "__main__":
main()
| import sys
n, s = sys.stdin.read().split()
def main():
cnt = 0
prev = '$'
for c in s:
if c == prev: continue
cnt += 1
prev = c
print(cnt)
if __name__ == '__main__':
main() | p02887 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
s = str(input().rstrip('\n'))
cnt = 0
for i in range(1, n):
if s[i] != s[i-1]:
cnt += 1
print((cnt+1))
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = int(readline())
s = str(readline().rstrip().decode('utf-8'))
cnt = 0
for i in range(1, n):
if s[i] != s[i-1]:
cnt += 1
print((cnt + 1))
if __name__ == '__main__':
solve()
| p02887 |
from itertools import groupby
def main():
S = open(0).read().split()[1]
print((len(list(groupby(S)))))
main()
| from itertools import groupby
def main():
S = open(0).read().split()[1]
print((sum(1 for x in groupby(S))))
main()
| p02887 |
n = int(eval(input()))
s = input().rstrip()
def rle(s):
import itertools
return list([(x[0], len(list(x[1]))) for x in itertools.groupby(s)])
print((len(rle(s)))) | import itertools
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
n = ri()
s = rs()
print((len(list(itertools.groupby(s))))) | p02887 |
N = int(eval(input()))
S = input().strip()
after = S[0]
for i in range(1, N):
if S[i] != S[i-1]:
after += S[i]
print((len(after)))
| N = int(eval(input()))
S = input().strip()
after = [S[0]]
for i in range(1, N):
if S[i] != S[i-1]:
after.append(S[i])
print((len(after)))
| p02887 |
def gcd(a, b):
while a != b:
if a > b :
a -= b
else:
b -= a
return a
N, X=list(map(int, input().split()))
print((3*(N - gcd(N, X))))
| def gcd(a, b):
while a != b:
if a == 0:
return b
elif b == 0:
return a
if a > b :
a %= b
else:
b %= a
return a
N, X=list(map(int, input().split()))
print((3*(N - gcd(N, X))))
| p04048 |
N,X = list(map(int,input().split()))
x = X
y = N-X
res = N
while 1:
if x==y:
res += x
break
if x > y:
x,y = y,x
res += x*2
y -= x
print(res) | N,X = list(map(int,input().split()))
x = X
y = N-X
if x<y:
x,y = y,x
res = N
while y>0:
x,y = y,x
m = x*(y//x)
res += m*2
y -= m
res -= x
print(res) | p04048 |
n,x = list(map(int,input().split()))
ans = n
e = n-x
count = 0
while True:
if x%e == 0:
ans += x//e*(e*2)-e
break
else:
ans += (x//e)*e*2
x,e = e,x%e
count += 1
print(ans) | n,x = list(map(int,input().split()))
ans = n
e = n-x
while e > 0:
if x%e == 0:
ans += x//e*(e*2)-e
else:
ans += (x//e)*e*2
x,e = e,x%e
print(ans) | p04048 |
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N, K = list(map(int, sys.stdin.buffer.readline().split()))
a = K
b = N - K
c = 0
d = min(a, b)
while not a == b == c:
a, b, c = sorted([a, b, c])
if b == c and (b - a) % d == 0:
a = b
elif a == b:
a += d
else:
d = b - a
a += d * 2
print((a + b + c))
| import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
N, K = list(map(int, sys.stdin.buffer.readline().split()))
a = K
b = N - K
c = 0
d = min(a, b)
while not a == b == c:
a, b, c = sorted([a, b, c])
if a != b:
d = b - a
cnt = (c - b) // d
b += d * cnt
a += d * cnt + d
print((a + b + c))
| p04048 |
n, x = list(map(int, input().split(' ')))
ans = n
c = [x, n-x]
while (c[0] != c[1]):
ans += 2 * min(c)
c = [min(c), max(c)-min(c)]
print((ans+c[0]))
| def sub(a, b):
if (a%b == 0):
return a//b-1
return a//b
def mod(a, b):
if a%b==0:
return b
return a%b
n, x = list(map(int, input().split(' ')))
ans = n
c = [x, n-x]
while (c[0] != c[1]):
c = [min(c), max(c)]
ans += 2*sub(c[1], c[0])*c[0]
c[1] = mod(c[1], c[0])
print((ans+c[0]))
| p04048 |
N, X = list(map(int, input().split(" ")))
e_long = max(X, N-X)
e_short = N - e_long
total = N
while e_long != e_short and e_long > 0 and e_short > 0:
total += e_short * 2
e_long -= e_short
if e_short > e_long:
tmp = e_long
e_long = e_short
e_short = tmp
total += e_short
print(total) | import sys
input = sys.stdin.readline
def main():
N, X = list(map(int, input().split()))
ans = N
min_ = min(X, N-X)
max_ = max(X, N-X)
while min_ != 0:
# print(max_, min_)
ans += (max_ // min_) * 2 * min_
tmp = max_ % min_
max_ = min_
min_ = tmp
ans -= max_
print(ans)
if __name__ == "__main__":
main() | p04048 |
N,X=list(map(int,input().split()))
A=N
X,N = sorted((X,N-X))
while N != X:
A += 2*X
X,N=sorted((X,N-X))
print((A+X)) | N,X=list(map(int,input().split()))
A=N
X,N = sorted((X,N-X))
while N != X and X != 0:
if N%X == 0:
A += 2*(N//X-1)*X
X,N=X,X
else:
A += 2*(N//X)*X
X,N=sorted((X,N%X))
print((A+X)) | p04048 |
# -*- coding: utf-8 -*-
import sys
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, X = MAP()
print(((N-gcd(N, X))*3))
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, X = MAP()
# 最初のN以外は、平行四辺形を小さくしていくと考える
def rec(a, b):
a, b = min(a, b), max(a, b)
if a == 0:
# 最後に割り切れた時は半分でいいので減らす
return -b
# 同じだけ小さくする所はまとめてやる
return a*2*(b//a) + rec(a, b%a)
print((N+rec(X, N-X)))
| p04048 |
n, x = list(map(int, input().split()))
def func(a, b):
res = 0
while b > 0:
c, d = divmod(a, b)
res += 2 * b * c
a = b
b = d
return res - a
print((n + func(x, n-x))) | n, x = list(map(int, input().split()))
def func(a, b):
if a < b:
a, b = b, a
res = 0
while b > 0:
c, d = divmod(a, b)
res += 2 * b * c
a = b
b = d
return res - a
print((n + func(x, n-x))) | p04048 |
n, x = list(map(int,input().split()))
if n % 2 == 0 and n//2 == x:
print((3 * x))
exit()
if x > n // 2:
x = n - x
xx = x
yy = n - x
ans = n
i = 0
f = False
while True:
if yy >= xx:
ans += 2 * xx
yy -= xx
if yy == 0:
ans -= xx
f = True
break
if xx > yy:
ans += yy * 2
xx -= yy
if xx == 0:
ans -= yy
f = True
break
print(ans)
| n, x = list(map(int,input().split()))
if n % 2 == 0 and n//2 == x:
print((3 * x))
exit()
if x > n // 2:
x = n - x
xx = x
yy = n - x
ans = n
i = 0
while True:
if yy >= xx:
ans += 2 * (yy // xx) * xx
yy %= xx
if yy == 0:
ans -= xx
break
if yy < xx:
tmp = xx
xx = yy
yy = tmp
print(ans) | p04048 |
n, x = list(map(int, input().split()))
def func(a, b):
if a < b:
if b%a == 0:
return (b//a*2 - 1)*a
else:
q, mod = divmod(b,a)
return 2*q*a + func(a, mod)
elif a > b:
if a%b == 0:
return (a//b*2 - 1)*b
else:
q, mod = divmod(a,b)
return 2*q*b + func(mod, b)
else:
return a
if x == n/2:
print((3*x))
else:
print((x+(n-x)+func(x,n-x))) | # coding:utf-8
def inpl(): return list(map(int, input().split()))
n, x = inpl()
def func(a, b):
if a < b:
a, b = b, a
if a == b:
return a
else:
if a % b == 0:
return (a // b * 2 - 1) * b
else:
q, mod = divmod(a, b)
return 2 * q * b + func(b, mod)
# return 2*b + func(a-b, b)#再帰回数が10000を超えるとエラー(20000000001, 4)など
if x == n / 2:
print((3 * x))
else:
print((n + func(x, n - x)))
| p04048 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, x = list(map(int, input().split()))
ans = 0
ans += n
l1, l2 = min(n - x, x), max(n - x, x)
#while True:
# if l1 == l2:
# ans += l1
# break
# else:
# ans += (l1 * 2)
# l1, l2 = min(l1, l2 -l1), max(l1, l2 - l1)
while True:
if l2 % l1 == 0:
ans += (l1 * ((l2 // l1) * 2 - 1))
break
else:
ans += (l1 * 2)
l1, l2 = min(l1, l2 -l1), max(l1, l2 - l1)
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, x = list(map(int, input().split()))
ans = 0
ans += n
l1, l2 = min(n - x, x), max(n - x, x)
#while True:
# if l1 == l2:
# ans += l1
# break
# else:
# ans += (l1 * 2)
# l1, l2 = min(l1, l2 -l1), max(l1, l2 - l1)
#while True:
# if l2 % l1 == 0:
# ans += (l1 * ((l2 // l1) * 2 - 1))
# break
# else:
# ans += (l1 * 2)
# l1, l2 = min(l1, l2 -l1), max(l1, l2 - l1)
while True:
if l2 % l1 == 0:
ans += (l1 * ((l2 // l1) * 2 - 1))
break
else:
ans += (l1 * 2) * (l2 // l1)
l1, l2 = l2 % l1, l1
print(ans)
| p04048 |
import sys
import heapq as hp
class Edge:
def __init__(self, end, cost):
self.to = end
self.cost = cost
class Dijkstra:
def __init__(self, V):
self._node = V
self._graph = [[] for i in range(self._node)]
self._inf = sys.maxsize
self.dist = [self._inf for i in range(self._node)]
def add_edge(self, st, ed, cost):
self._graph[st].append(Edge(ed, cost))
def solve(self, s):
que = []
self.dist[s] = 0
hp.heappush(que, (0, s))
while que:
cur_cost, cur_vertex = hp.heappop(que)
if self.dist[cur_vertex] < cur_cost:
continue
for e in self._graph[cur_vertex]:
if cur_cost + e.cost < self.dist[e.to]:
self.dist[e.to] = cur_cost + e.cost
hp.heappush(que, (self.dist[e.to], e.to))
if __name__ == '__main__':
V, E, r = list(map(int, input().split()))
dk = Dijkstra(V)
for i in range(E):
s, t, d = list(map(int, input().split()))
dk.add_edge(s, t, d)
dk.solve(r)
for value in dk.dist:
if value == sys.maxsize:
print("INF")
else:
print(value)
| import sys
from heapq import heappush, heappop
class Dijkstra:
class Edge:
def __init__(self, end, cost):
self.to = end
self.cost = cost
def __init__(self, V):
self._node = V
self._graph = [[] for i in range(self._node)]
self.inf = 10 ** 10
self.dist = [self.inf for i in range(self._node)]
def add_edge(self, st, ed, cs):
self._graph[st].append(self.Edge(ed, cs))
def solve(self, start):
que = []
self.dist[start] = 0
heappush(que, (0, start))
while que:
cur_cost, cur_vertex = heappop(que)
if self.dist[cur_vertex] < cur_cost:
continue
for e in self._graph[cur_vertex]:
if cur_cost + e.cost < self.dist[e.to]:
self.dist[e.to] = cur_cost + e.cost
heappush(que, (self.dist[e.to], e.to))
if __name__ == '__main__':
V, E, r = list(map(int, sys.stdin.readline().split()))
dk = Dijkstra(V)
for i in range(E):
s, t, d = list(map(int, sys.stdin.readline().split()))
dk.add_edge(s, t, d)
dk.solve(r)
for value in dk.dist:
if value == dk.inf:
sys.stdout.writelines("INF\n")
else:
sys.stdout.writelines("%d\n" % value)
| p02361 |
import sys
import queue
class Dijkstra:
class Edge:
def __init__(self, end, cost):
self.to = end
self.cost = cost
def __init__(self, node_size, inf):
self._node = node_size
self._graph = [[] for _ in range(self._node)]
self.inf = inf
self.dist = [self.inf for _ in range(self._node)]
def add_edge(self, st, ed, cs):
self._graph[st].append(self.Edge(ed, cs))
def solve(self, start):
que = queue.PriorityQueue()
self.dist[start] = 0
que.put((0, start))
while not que.empty():
cur_cost, cur_vertex = que.get()
if self.dist[cur_vertex] < cur_cost:
continue
for e in self._graph[cur_vertex]:
if self.dist[e.to] > cur_cost + e.cost:
self.dist[e.to] = cur_cost + e.cost
que.put((self.dist[e.to], e.to))
if __name__ == '__main__':
V, E, r = list(map(int, sys.stdin.readline().split()))
dk = Dijkstra(V, 10 ** 10)
for i in range(E):
s, t, d = list(map(int, sys.stdin.readline().split()))
dk.add_edge(s, t, d)
dk.solve(r)
for value in dk.dist:
if value == dk.inf:
print("INF")
else:
print(value)
| import sys
from heapq import heappush, heappop
class Dijkstra:
class Edge:
def __init__(self, end, cost):
self.to = end
self.cost = cost
def __init__(self, node_size, inf):
self._node = node_size
self._graph = [[] for _ in range(self._node)]
self.inf = inf
self.dist = [self.inf for _ in range(self._node)]
def add_edge(self, st, ed, cs):
self._graph[st].append(self.Edge(ed, cs))
def solve(self, start):
que = []
self.dist[start] = 0
heappush(que, (0, start))
while que:
cur_cost, cur_vertex = heappop(que)
if self.dist[cur_vertex] < cur_cost:
continue
for e in self._graph[cur_vertex]:
if self.dist[e.to] > cur_cost + e.cost:
self.dist[e.to] = cur_cost + e.cost
heappush(que, (self.dist[e.to], e.to))
if __name__ == '__main__':
V, E, r = list(map(int, sys.stdin.readline().split()))
dk = Dijkstra(V, 10 ** 10)
for i in range(E):
s, t, d = list(map(int, sys.stdin.readline().split()))
dk.add_edge(s, t, d)
dk.solve(r)
for value in dk.dist:
if value == dk.inf:
sys.stdout.write("INF\n")
else:
sys.stdout.write("%s\n" % value)
| p02361 |
import sys
import heapq
def dfs(u,s,target, vs):
vs[u] = 1
if(u == target):
global h
heapq.heappush(h,s)
return
for j in range(e):
if(e_1[j] == u):
if(vs[e_2[j]] != 1):
count = s + e_w[j]
print((s,e_2[j],vs))
dfs(e_2[j],count,target,vs[0:])
v,e,r=list(map(int, input().split()));
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = list(map(int, input().split()));
v_q=[];
INF = 9999999999999999999
d = [INF for i in range(v)]
d[r] = 0
heapq.heappush(v_q,(0,r))
while(len(v_q) != 0):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
for j in range(e):
if(u == e_1[j]):
alt = cost+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print((d[i]))
else:
print("INF")
| import sys
import heapq
v,e,r=list(map(int, input().split()));
e_1=[0]*e;
e_2=[0]*e;
e_w=[0]*e;
for i in range(e):
e_1[i], e_2[i], e_w[i] = list(map(int, input().split()));
v_q=[];
INF = 9999999999999999999
d = [INF for i in range(v)]
d[r] = 0
heapq.heappush(v_q,(0,r))
while(len(v_q) != 0):
cost,u = heapq.heappop(v_q)
if(cost > d[u]):
continue
for j in range(e):
if(u == e_1[j]):
alt = cost+e_w[j]
if(d[e_2[j]] > alt):
d[e_2[j]] = alt
heapq.heappush(v_q,(alt,e_2[j]))
for i in range(v):
if(d[i] != INF):
print((d[i]))
else:
print("INF")
| p02361 |
from heapq import heappush, heappop
V, E, r = list(map(int, input().split()))
edges = [[] for _ in [None]*V]
vertices = [10**10]*V
vertices[r] = 0
for _ in [None]*E:
s, t, d = list(map(int, input().split()))
edges[s].append((t,d))
q = [(0, r)]
while q:
cost, v = heappop(q)
for dest, _cost in edges[v]:
newcost = cost + _cost
if vertices[dest] > newcost:
vertices[dest] = newcost
heappush(q, (newcost, dest))
print(("\n".join([str(n) if n!=10**10 else "INF" for n in vertices]))) | from heapq import heappush, heappop
V, E, r = list(map(int, input().split()))
inf = 10**10
edges = [[] for _ in [None]*V]
vertices = [inf]*V
vertices[r] = 0
for _ in [None]*E:
s, t, d = list(map(int, input().split()))
edges[s].append((t, d))
q = [(0, r)]
rem = V-1
while q and rem > 0:
cost, v = heappop(q)
if vertices[v] < cost:
continue
rem -= 1
for dest, _cost in edges[v]:
newcost = cost + _cost
if vertices[dest] > newcost:
vertices[dest] = newcost
heappush(q, (newcost, dest))
print(("\n".join([str(n) if n!=inf else "INF" for n in vertices]))) | p02361 |
from heapq import heappush, heappop
V, E, r = list(map(int, input().split()))
inf = 10**10
edges = [[] for _ in [None]*V]
vertices = [inf]*V
vertices[r] = 0
for _ in [None]*E:
s, t, d = list(map(int, input().split()))
edges[s].append((t, d))
q = [(0, r)]
rem = V-1
while q:
cost, v = heappop(q)
if vertices[v] < cost:
continue
for dest, _cost in edges[v]:
newcost = cost + _cost
if vertices[dest] > newcost:
vertices[dest] = newcost
heappush(q, (newcost, dest))
rem -= 1
if rem == 0:
break
print(("\n".join([str(n) if n!=inf else "INF" for n in vertices]))) | import sys
from heapq import heappush, heappop
readline = sys.stdin.readline
V, E, r = list(map(int, readline().split()))
inf = 10**10
edges = [[] for _ in [None]*V]
vertices = [inf]*V
vertices[r] = 0
for _ in [None]*E:
s, t, d = list(map(int, readline().split()))
edges[s].append((t, d))
q = [(0, r)]
rem = V-1
while q and rem:
cost, v = heappop(q)
if vertices[v] < cost:
continue
rem -= 1
for dest, _cost in edges[v]:
newcost = cost + _cost
if vertices[dest] > newcost:
vertices[dest] = newcost
heappush(q, (newcost, dest))
print(("\n".join([str(n) if n!=inf else "INF" for n in vertices]))) | p02361 |
from heapq import heappush, heappop
V, E, r = list(map(int, input().split()))
g = [[] for i in range(V)]
for i in range(E):
s, t, d = list(map(int, input().split()))
g[s].append((t, d))
INF = 10**10
dist = [INF]*V
que = [(0,r)]
dist[r] = 0
while que:
c, v = heappop(que)
if dist[v] < c:
continue
for t, cost in g[v]:
if dist[v] + cost < dist[t]:
dist[t] = dist[v] + cost
heappush(que, (dist[t], t))
for i in range(V):
print(dist[i] if dist[i]<INF else "INF") | class RadixHeap:
__slots__ = ["data", "last", "siz", "used"]
# (max_key - min_key) <= C
def __init__(self, N, C):
self.data = [[] for i in range(C.bit_length() + 1)]
self.last = self.siz = 0
self.used = [0]*N
def push(self, x, key):
#assert self.last <= x
self.siz += 1
self.data[(x ^ self.last).bit_length()].append((x, key))
def pop(self):
data = self.data
used = self.used
#assert self.siz > 0
if not data[0]:
i = 1
while not data[i]:
i += 1
d = data[i]
new_last, new_key = min(d)
used[new_key] = 1
for val in d:
x, key = val
if used[key]:
self.siz -= 1
continue
data[(x ^ new_last).bit_length()].append(val)
self.last = new_last
data[i] = []
else:
new_last, new_key = data[0].pop()
used[new_key] = 1
self.siz -= 1
return new_last, new_key
def __len__(self):
return self.siz
import sys
readline = sys.stdin.readline
write = sys.stdout.write
N, M, s = list(map(int, readline().split()))
G = [[] for i in range(N)]
for i in range(M):
a, b, c = list(map(int, readline().split()))
G[a].append((b, c))
INF = 10**18
def dijkstra(N, G, s):
que = RadixHeap(N, 10**9 + 1)
dist = [INF]*N
dist[s] = 0
que.push(0, s)
while que:
cost, v = que.pop()
if dist[v] < cost:
continue
for w, c in G[v]:
if cost + c < dist[w]:
dist[w] = r = cost + c
que.push(r, w)
return dist
dist = dijkstra(N, G, s)
for c in dist:
write("INF\n" if c == INF else "%d\n" % c)
| p02361 |
from collections import defaultdict
from heapq import heappush, heappop
def main():
#Read stdin
fl = input().split(" ")
V = int(fl[0])
E = int(fl[1])
R = int(fl[2])
#Adjacency list
G = defaultdict(list)
for i in range(int(E)):
s, t, w = [int(x) for x in input().split(" ")]
G[s].append((t,w))
#initialized
d = {}
INF = float('inf')
#INF = 10001
for i in range(V):
d[i] = INF
d[R] = 0
q = [R]
while q:
u = heappop(q)
for v in G[u]:
if d[v[0]] > d[u] + v[1]:
d[v[0]] = d[u] + v[1]
heappush(q, v[0])
for k in list(d.keys()):
if d[k] == float('inf'):
print("INF")
else:
print((d[k]))
if __name__ == '__main__':
main() |
from collections import defaultdict
from heapq import heappush, heappop
def main():
#Read stdin
fl = input().split(" ")
V = int(fl[0])
E = int(fl[1])
R = int(fl[2])
#Adjacency list
G = defaultdict(list)
for i in range(int(E)):
s, t, w = [int(x) for x in input().split(" ")]
G[s].append((t,w))
#initialized
d = {}
INF = float('inf')
#INF = 10001
for i in range(V):
d[i] = INF
d[R] = 0
q = [R]
while q:
#u = heappop(q)
u = q.pop(0)
for v in G[u]:
if d[v[0]] > d[u] + v[1]:
d[v[0]] = d[u] + v[1]
#heappush(q, v[0])
q.append(v[0])
for k in list(d.keys()):
if d[k] == float('inf'):
print("INF")
else:
print((d[k]))
if __name__ == '__main__':
main() | p02361 |
#!usr/bin/env python3
from collections import defaultdict
def main():
fl = input().split(" ")
V = int(fl[0])
E = int(fl[1])
R = int(fl[2])
#Adjacency list
G = defaultdict(dict)
for i in range(int(E)):
s, t, w = [int(x) for x in input().split(" ")]
G[s][t] = w
#initialized
d = {}
INF = float('inf')
#INF = 10001
for i in range(V):
d[i] = INF
d[R] = 0
q = [R]
while q:
u = q.pop(0)
for v in list(G[u].keys()):
if d[v] > d[u] + G[u][v]:
d[v] = d[u] + G[u][v]
q.append(v)
for k in range(V):
if d[k] == float('inf'):
print("INF")
else:
print((d[k]))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict
def main():
#Read stdin
fl = input().split(" ")
V = int(fl[0])
E = int(fl[1])
R = int(fl[2])
#Adjacency list
G = defaultdict(list)
for i in range(int(E)):
s, t, w = [int(x) for x in input().split(" ")]
G[s].append((t,w))
#initialized
d = {}
INF = float('inf')
#INF = 10001
for i in range(V):
d[i] = INF
d[R] = 0
q = [R]
while q:
u = q.pop(0)
for v in G[u]:
if d[v[0]] > d[u] + v[1]:
d[v[0]] = d[u] + v[1]
q.append(v[0])
for k in range(V):
if d[k] == float('inf'):
print("INF")
else:
print((d[k]))
if __name__ == '__main__':
main() | p02361 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.