input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import sys
input = sys.stdin.readline
mod=10**9+7
n,m=list(map(int,input().split()))
A=[]
for i in range(m):
a=int(eval(input()))
A.append(a)
S=[0]*(n+1)
S[0]=1
if 1 not in A:
S[1]=1
for i in range(2,n+1):
if i in A:
S[i]=0
else:
S[i]=(S[i-1]+S[i-2])%mod
print((S[n]%mod))
|
import sys
input = sys.stdin.readline
mod=10**9+7
n,m=list(map(int,input().split()))
A=set()
for i in range(m):
A.add(int(eval(input())))
S=[0]*(n+1)
S[0]=1
if 1 not in A:
S[1]=1
for i in range(2,n+1):
if i in A:
S[i]=0
else:
S[i]=(S[i-1]+S[i-2])%mod
print((S[n]%mod))
|
p03013
|
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
broken_floors = [int(eval(input())) for _ in range(M)]
dp = [0]*(N+2)
dp[1] = 1
for i in range(1, N+1):
if i not in broken_floors:
dp[i+1] = (dp[i] + dp[i-1]) % MOD
print((dp[-1]))
|
import sys
input = sys.stdin.readline
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
broken_floors = set(int(eval(input())) for _ in range(M))
dp = [0]*(N+2)
dp[1] = 1
for i in range(1, N+1):
if i not in broken_floors:
dp[i+1] = (dp[i] + dp[i-1]) % MOD
print((dp[-1]))
|
p03013
|
N, M = list(map(int, input().split()))
A_ = [int(eval(input())) for _ in range(M)]
A = [0] * (N+3)
for a in A_:
A[a] = 1
dp = [0] * (N+3)
dp[0] = 1
mod = 10**9+7
for i in range(1, N+1):
if A[i-1] == 0:
dp[i] += dp[i-1]
if A[i-2] == 0:
dp[i] += dp[i-2]
dp[i] %= mod
print((dp[N]))
|
n,m=list(map(int,input().split()))
dp=[0]*(n+3)
a=[int(eval(input())) for i in range(m)]
mod=10**9+7
for i in range(m):
dp[a[i]]=-1
dp[0]=1
if dp[1]!=-1:
dp[1]+=dp[0]
for i in range(n+1):
if dp[i+2]==-1:
continue
if dp[i]!=-1:
dp[i+2]+=dp[i]
if dp[i+1]!=-1:
dp[i+2]+=dp[i+1]
dp[i+2]%=mod
print((dp[n]%mod))
|
p03013
|
n,m=list(map(int,input().split()))
dp=[0]*(n+3)
a=[int(eval(input())) for i in range(m)]
mod=10**9+7
for i in range(m):
dp[a[i]]=-1
dp[0]=1
if dp[1]!=-1:
dp[1]+=dp[0]
for i in range(n+1):
if dp[i+2]==-1:
continue
if dp[i]!=-1:
dp[i+2]+=dp[i]
if dp[i+1]!=-1:
dp[i+2]+=dp[i+1]
dp[i+2]%=mod
print((dp[n]%mod))
|
n,m = list(map(int,input().split()))
a = []
stairs = [0]*(n+2)
for _ in range(m):
a = int(eval(input()))
stairs[a] = 1
mod = 10**9 + 7
dp = [0]*(n+2)
dp[0] = 1
for i in range(n):
if i <= 1:
if stairs[i+1] == 0:
dp[i+1] += dp[i]
dp[i+1] %= mod
stairs[i+1] = 1
if stairs[i+2] == 0:
dp[i+2] += dp[i+1]+dp[i]
dp[i+2] %= mod
stairs[i+2] = 1
print((dp[n]%mod))
|
p03013
|
# DP
N, M = list(map(int, input().split()))
broken = [int(eval(input())) for _ in range(M)]
MOD = 10**9+7
dp = [0 for i in range(N+2)]
dp[N] = 1
for i in reversed(list(range(N))):
if i in broken:
continue
dp[i] = (dp[i+1] + dp[i+2]) % MOD
print((dp[0]))
|
# DP
N, M = list(map(int, input().split()))
broken = set([int(eval(input())) for _ in range(M)])
MOD = 10**9+7
dp = [0 for i in range(N+2)]
dp[N] = 1
for i in reversed(list(range(N))):
if i in broken:
continue
dp[i] = (dp[i+1] + dp[i+2]) % MOD
print((dp[0]))
|
p03013
|
# DP
N, M = list(map(int, input().split()))
broken = set([int(eval(input())) for _ in range(M)])
MOD = 10**9+7
dp = [0 for i in range(N+2)]
dp[N] = 1
for i in reversed(list(range(N))):
if i in broken:
continue
dp[i] = (dp[i+1] + dp[i+2]) % MOD
print((dp[0]))
|
# DP
N, M = list(map(int, input().split()))
broken = set([int(eval(input())) for _ in range(M)])
MOD = 10**9+7
dp = [0 for i in range(N+2)]
dp[N] = 1
for i in reversed(list(range(N))):
if i in broken:
continue
dp[i] = dp[i+1] + dp[i+2]
dp[i] %= MOD
print((dp[0]))
|
p03013
|
n,m=list(map(int,input().split()))
al=[int(eval(input())) for i in range(m)]
mod=1000000007
ansl=[0,1]
for i in range(1,n+1):
if i in al:
ansl.append(0)
else:
ansl.append((ansl[-2]+ansl[-1])%mod)
print((ansl[-1]%mod))
|
n,m=list(map(int,input().split()))
al=set([int(eval(input())) for i in range(m)])
mod=1000000007
ansl=[0,1]
for i in range(1,n+1):
if i in al:
ansl.append(0)
else:
ansl.append((ansl[-2]+ansl[-1])%mod)
print((ansl[-1]%mod))
|
p03013
|
MOD = 10**9 + 7
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = []
for _ in range(m):
a.append(int(eval(input())))
# i段目にたどり着く方法
dp = [0] * (n + 1)
dp[0] = 1
dp[1] = 1 if 1 not in a else 0
for i in range(2, n+1):
dp[i] = (dp[i-1] + dp[i-2]) % MOD if i not in a else 0
print((dp[-1]))
|
MOD = 10**9 + 7
import sys
input = sys.stdin.readline
n, m = list(map(int, input().split()))
a = [0] * (n + 1)
for _ in range(m):
a[int(eval(input()))] = 1
# i段目にたどり着く方法
dp = [0] * (n + 1)
dp[0] = 1
dp[1] = 1 if a[1] == 0 else 0
for i in range(2, n+1):
dp[i] = (dp[i-1] + dp[i-2]) % MOD if a[i] == 0 else 0
print((dp[-1]))
|
p03013
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
dan = [0]*(n+1)
dan[0] = 1
for i in range(1,n+1):
if i not in a:
dan[i] += dan[i-1]
if i >= 2:
dan[i] += dan[i-2]
print((dan[n]%(10**9+7)))
|
n, m = list(map(int, input().split()))
li = [True]*(n+1)
for i in range(m):
a = int(eval(input()))
li[a] = False
dan = [0]*(n+1)
dan[0] = 1
for j in range(1,n+1):
if li[j]:
dan[j] += dan[j-1]
if j >= 2:
dan[j] += dan[j-2]
print((dan[n]%(10**9+7)))
|
p03013
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
def nCr(n, r):
r = min(r, n-r)
num, den = 1, 1
for i in range(r):
num *= (n-i)
den *= (i+1)
return num // den % mod
lv = 0
a.append(n+1)
ans = 1
for v in a:
vr = v-1 - lv
if vr < 0:
print((0))
exit()
r = 0
for i in range(vr+(-vr//2)+1):
r += nCr(vr-i, i)
ans = (ans * r) % mod
lv = v+1
print(ans)
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
mod = 10**9+7
a.append(float('INF'))
a = a[::-1]
dp = [0] * (n+1)
dp[0] = 1
if a[-1] != 1:
dp[1] = 1
else:
a.pop()
for i in range(2, n+1):
if i == a[-1]:
a.pop()
continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
print((dp[n]))
|
p03013
|
import sys
max_num = 1000000007
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(eval(input())) for i in range(M)]
current_step, prev_step, two_prev_step = 0, 1, 0
for i in sorted(list(range(N)), reverse=True):
if i in A:
prev_step, two_prev_step = 0, prev_step
continue
current_step = prev_step + two_prev_step
prev_step, two_prev_step = current_step, prev_step
print((current_step % max_num))
|
import sys
max_num = 1000000007
input = sys.stdin.readline
N, M = list(map(int, input().split()))
A = [int(eval(input())) for i in range(M)]
stairs = [1] * (N+1)
for i in A:
stairs[i] = 0
for i in range(1, N):
if stairs[i+1] != 0:
stairs[i+1] = stairs[i] + stairs[i-1]
print((stairs[N] % max_num))
|
p03013
|
n,m=list(map(int,input().split()))
a=[]
mod=1000000007
for _ in range(m):
a.append(int(eval(input())))
a=set(a)
ans=[1]+[0]*(n)
for i in range(1,n+1):
if i in a:
ans[i]=0
else:
ans[i]=(ans[i-1]+ans[i-2])%mod
print((ans[n]))
|
n,m=list(map(int,input().split()))
a=set([int(eval(input())) for _ in range(m)])
dp=[1]+[0 for _ in range(n)]
mod=1000000007
for i in range(1,n+1):
if i in a:
dp[i]=0
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[-1]))
|
p03013
|
import sys
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
mod = 10 ** 9 + 7
if N == 1:
print((1))
sys.exit()
B = ['.'] * (N + 1)
for a in A:
B[a] = '#'
dp = [0] * (N + 1)
if B[1] == '.' and B[2] == '.':
dp[1] = 1
dp[2] = 2
elif B[1] == '#' and B[2] == '.':
dp[2] = 1
elif B[1] == '.' and B[2] == '#':
dp[1] = 1
for i in range(3, N + 1):
if B[i] == '.':
dp[i] = (dp[i - 2] + dp[i - 1]) % mod
print((dp[N]))
|
import sys
n, m = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(m)]
mod = 1000000007
if n == 1:
print((1))
sys.exit()
B = ['.'] * (n + 1)
for a in A:
B[a] = '#'
dp = [0] * (n + 1)
if B[1] == '.' and B[2] == '.':
dp[1] = 1
dp[2] = 2
elif B[1] == '#' and B[2] == '.':
dp[2] = 1
elif B[1] == '.' and B[2] == '#':
dp[1] = 1
for i in range(3, n + 1):
if B[i] == '.':
dp[i] = (dp[i - 2] + dp[i - 1]) % mod
print((dp[-1]))
|
p03013
|
# -*- coding: utf-8 -*-
def main():
N,M = list(map(int,input().split()))
A = [int(eval(input())) for _ in range(M)]
MOD = 1000000007
ans = [1]
ans.append(0) if 1 in A else ans.append(1)
for i in range(2,N+1):
ans.append(0)
if i in A:
continue
ans[i] += (ans[i-1] + ans[i-2])
print((ans[N] % MOD))
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
def main():
N,M = list(map(int,input().split()))
A = set([int(eval(input())) for _ in range(M)])
MOD = 1000000007
ans = [1]
ans.append(0) if 1 in A else ans.append(1)
for i in range(2,N+1):
ans.append(0)
if i in A:
continue
ans[i] += (ans[i-1] + ans[i-2])
print((ans[N] % MOD))
if __name__ == '__main__':
main()
|
p03013
|
n, m = [int(i) for i in input().split()]
a = [-1] + [int(eval(input())) for _ in range(m)] + [n+1]
fib_l = [-1] * (n+3)
def make_fib(n):
fib_l[0] = fib_l[1] = 1
for i in range(2, n):
fib_l[i] = fib_l[i-1] + fib_l[i-2]
make_fib(n+3)
ret = 1
for i in range(m+1):
t = a[i+1] - a[i] - 2
if t < 0:
ret = 0
break
ret *= fib_l[t]
print((ret % 1000000007))
|
from sys import stdin
n, m = [int(i) for i in stdin.readline().rstrip().split()]
a = [-1] + [int(stdin.readline()) for _ in range(m)] + [n+1]
fib_l = [-1] * (n+3)
def make_fib(n):
fib_l[0] = fib_l[1] = 1
for i in range(2, n):
fib_l[i] = fib_l[i-1] + fib_l[i-2]
make_fib(n+3)
ret = 1
for i in range(m+1):
t = a[i+1] - a[i] - 2
if t < 0:
ret = 0
break
ret *= fib_l[t]
print((ret % 1000000007))
|
p03013
|
n,m = list(map(int,input().split()))
A = list()
for i in range(m):
a = int(eval(input()))
A.append(a)
dp = [0]*(n+1)
dp[0] = 1
if 1 not in A:
dp[1] = 1
for i in range(2,n+1):
if i not in A:
dp[i] = dp[i-2] + dp[i-1]
dp[i] = dp[i]%1000000007
print((dp[-1]%1000000007))
|
n,m = list(map(int,input().split()))
A = list()
for i in range(m):
a = int(eval(input()))
A.append(a)
dp = [0]*(n+1)
dp[0] = 1
if 1 in A:
del A[0]
else:
dp[1] = 1
for i in range(2,n+1):
if len(A) != 0:
if i != A[0]:
dp[i] = dp[i-2] + dp[i-1]
dp[i] = dp[i]%1000000007
else:
del A[0]
else:
dp[i] = dp[i-2] + dp[i-1]
dp[i] = dp[i]%1000000007
print((dp[-1]%1000000007))
|
p03013
|
Num = 10 ** 9 + 7
N, M = list(map(int, input().split()))
danger = []
for i in range(M):
danger.append(int(eval(input())))
l = [1, 1]
for i in range(1, N):
if i in danger:
l[1] = 0
l = [l[1] % Num, l[0] + l[1]]
if l == [0, 0]:
break
if N in danger:
l[1] = 0
print((l[1] % Num))
|
Num = 10 ** 9 + 7
N, M = list(map(int, input().split()))
danger = -1
if M != 0:
danger = int(eval(input()))
count = 1
l = [1, 1]
for i in range(1, N):
if i == danger:
l[1] = 0
if count < M:
danger = int(eval(input()))
count += 1
l = [l[1] % Num, l[0] + l[1]]
if l == [0, 0]:
break
if N == danger:
l[1] = 0
print((l[1] % Num))
|
p03013
|
from sys import stdin
n,m = [int(x) for x in stdin.readline().rstrip().split()]
if m != 0:
lin = [int(stdin.readline().rstrip()) for _ in range(m)]
else:
lin = [-1]
dp = [-1]*(n+1)
dp[0] = 1
if lin[0] == 1:
dp[1] = 0
else:
dp[1] = 1
for i in range(2,n+1):
if i in lin:
dp[i] = 0
else:
dp[i] = dp[i-1] + dp[i-2]
print((dp[n]%(10**9+7)))
|
from sys import stdin
n,m = [int(x) for x in stdin.readline().rstrip().split()]
lin = [0]*(n+1)
if m != 0:
for i in range(m):
lin[int(stdin.readline().rstrip())] = -1
dp = [-1]*(n+1)
dp[0] = 1
if lin[1] == -1:
dp[1] = 0
else:
dp[1] = 1
for i in range(2,n+1):
if lin[i] == -1:
dp[i] = 0
else:
dp[i] = dp[i-1] + dp[i-2]
print((dp[n]%(10**9+7)))
|
p03013
|
from sys import stdin
import bisect
n,m = [int(x) for x in stdin.readline().rstrip().split()]
if m == 0:
li = [0]
else:
li = [int(stdin.readline().rstrip()) for _ in range(m)]
dp = [-1]*(n+1)
dp[0] = 1
if li[0] == 1:
dp[1] = 0
else:
dp[1] = 1
for i in range(2,n+1):
if li[bisect.bisect_right(li,i)-1] == i:
dp[i] = 0
else:
dp[i] = dp[i-1] + dp[i-2]
print((dp[n]%(10**9+7)))
|
n,m = list(map(int,input().split()))
a = [int(eval(input())) for _ in range(m)]
now = 0
point = 1
mod = 10**9+7
def fib(n,mod):
a, b = 1, 1
for _ in range(n):
a, b = b %mod, (a + b)%mod
return a%mod
for i in range(1,m):
if a[i-1]+1 == a[i]:
print((0))
exit()
for i in a:
point *= fib((i-1-now),mod)
point %= mod
now = i+1
if now == n:
break
point *= fib(n-now,mod)
point %= mod
print(point)
|
p03013
|
import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r)*math.factorial(r))
n,m=[int(i) for i in input().split()]
a1=[int(eval(input())) for i in range(m)]
a1.append(n+1)
c1=1
a2=0
for i in a1:
a3=i-1-a2
c2=0
for j in range(a3//2+1):
c2+=combinations_count(a3-j,j)
c1=(c1*c2)%(1000000007)
a2=i+1
if c1==0:
break
print(c1)
|
#フィボナッチ数列か…
#c問題も解けないのか…
#典型問題なんだろうな
#踏めない段の分は除いて考えれば良い
n,m=input().split()
n,m=int(n),int(m)
ax=[1]*(n+1)
for i in range(m):
ax[int(eval(input()))]=0
bx=[1,1]
for i in range(2,n+1):
if ax[i-1]==1:
f1=bx[i-1]
else:
f1=0
if ax[i-2]==1:
f2=bx[i-2]
else:
f2=0
bx.append((f1+f2)%(10**9+7))
print((bx[n]))
|
p03013
|
# import bisect
# import copy
# import fractions
# import math
# import numpy as np
# from collections import Counter, deque
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
def resolve():
N, M = list(map(int,input().split()))
A = [int(eval(input())) for _ in range(M)]
dp = [0]*(N+1)
dp[0]=1
for i in range(N):
if not i+1 in A:
dp[i + 1] = (dp[i]+dp[i+1])%(10**9+7)
if i < N - 1 and not i+2 in A:
dp[i + 2] = (dp[i]+dp[i+2])%(10**9+7)
print((dp[N]%(10**9+7)))
resolve()
|
# import bisect
# import copy
# import fractions
# import math
# import numpy as np
# from collections import Counter, deque
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
def resolve():
N,M=list(map(int,input().split()))
A=[int(eval(input())) for i in range(M)]
dp=[1]*(N+1)
for i in A:
dp[i]=0
for i in range(2,N+1):
dp[i]=(dp[i-1]+dp[i-2])%(10**9+7)*dp[i]
print((dp[N]))
resolve()
|
p03013
|
mod = 10**9 + 7
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
is_broken = [1] * (n+1)
for i in range(n):
if i in a:
is_broken[i] = 0
step = [i for i in range(n+1)]
step[0] = 1
for i in range(n):
if i - 1 >= 0:
step[i+1] = step[i] * is_broken[i] + step[i-1] * is_broken[i-1]
else:
step[i+1] = step[i] * is_broken[i]
step[i+1] %= mod
print((step[n]))
|
mod = 10**9 + 7
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
is_broken = [1] * (n+1)
for i in range(m):
is_broken[a[i]] = 0
step = [i for i in range(n+1)]
step[0] = 1
for i in range(n):
if i - 1 >= 0:
step[i+1] = step[i] * is_broken[i] + step[i-1] * is_broken[i-1]
else:
step[i+1] = step[i] * is_broken[i]
step[i+1] %= mod
print((step[n]))
|
p03013
|
n,m=list(map(int,input().split()))
A=[int(eval(input())) for i in range(m)]
mod=10**9+7
flag=1
S=[0 for i in range(n+3)]
S[0]=1
SET=set(A)
for i in range(n):
if i in SET:
S[i]=0
if i+1 in SET:
flag=0
S[i+1]+=S[i]
S[i+2]+=S[i]
print((S[n]%mod if flag==1 else 0))
#配る方で解いてみた。
|
import sys
input=sys.stdin.buffer.readline
n,m=list(map(int,input().split()))
mod=10**9+7
dp=[0]*(n+1)
for _ in range(m):
a=int(eval(input()))
dp[a]=-1
dp[0]=1
for i in range(n):
if dp[i]>=0:
if i+1<=n:
if dp[i+1]>=0:
dp[i+1]+=dp[i]
dp[i+1]%=mod
if i+2<=n:
if dp[i+2]>=0:
dp[i+2]+=dp[i]
dp[i+2]%=mod
print((dp[n] if dp[n]>0 else 0))
|
p03013
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = [0]*M
mod = 10**9+7
for i in range(M):
a[i] = int(eval(input()))
DP = [0]*(N+1)
DP[0] = 1
if 1 in a:
DP[1] = 0
else:
DP[1] = 1
for i in range(2, N+1):
if(i not in a):
DP[i] = (DP[i-1]+DP[i-2])%mod
print((DP[-1]))
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = [0]*M
mod = 10**9+7
for i in range(M):
a[i] = int(eval(input()))
a = set(a)
DP = [0]*(N+1)
DP[0] = 1
if 1 in a:
DP[1] = 0
else:
DP[1] = 1
for i in range(2, N+1):
if(i not in a):
DP[i] = (DP[i-1]+DP[i-2])%mod
print((DP[-1]))
|
p03013
|
mod=10**9+7
N,M=list(map(int,input().split()))
A=[int(eval(input())) for m in range(M)]
L=[1 for n in range(N+1)]
for a in A:
L[a]=0
Block=[0,1]
for n in range(1,N+1):
if L[n]==1:
Block=Block[1:]+[sum(Block)%mod]
else:
Block=Block[1:]+[0]
print((Block[-1]))
|
mod=10**9+7
N,M=list(map(int,input().split()))
A=[int(eval(input())) for m in range(M)]
L=[1 for n in range(N+1)]
for a in A:
L[a]=0
Block=[0,1]
for n in range(1,N+1):
if L[n]:
Block=Block[1:]+[sum(Block)%mod]
else:
Block=Block[1:]+[0]
print((Block[-1]))
|
p03013
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for i in range(m)]
mod = 10**9+7
dp = [0] * (n+1)
dp[0] = 1
for i in range(1,n+1):
if i in a:
continue
else:
dp[i] = (dp[i-1] + dp[i-2]) % mod
print((dp[-1]))
|
n,m = list(map(int,input().split()))
mod = 10**9+7
a = set()
for i in range(m):
s = int(eval(input()))
a.add(s)
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1):
if i in a:
continue
dp[i] = (dp[i-1] + dp[i-2]) % mod
print((dp[-1]))
|
p03013
|
import sys
S = sys.stdin.readline().strip()
T = sys.stdin.readline().strip()
ls = len(S)
lt = len(T)
match = 0
for i in range(ls - lt + 1):
tmp = 0
for j in range(lt):
if S[i+j] == T[j]:
tmp += 1
match = max(match, tmp)
print((lt - match))
|
import sys
input = sys.stdin.readline
S = input().strip()
T = input().strip()
ans = float("inf")
ls = len(S)
lt = len(T)
for i in range(ls - lt + 1):
tmp = 0
for j in range(lt):
if S[i+j] != T[j]:
tmp += 1
ans = min(ans, tmp)
print(ans)
|
p02571
|
import sys
import math
#https://atcoder.jp/contests/agc008/submissions/15248942
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
S = input()
T = input()
ans = 0
for i in range(len(S)):
for j in range(i+1,len(S)+1):
if (j-i) == len(T):
match = 0
for k,l in enumerate(range(i,j)):
if S[l] == T[k]:
match += 1
ans = max(ans,match)
print(len(T)-ans)
|
import sys
import math
#https://atcoder.jp/contests/agc008/submissions/15248942
sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))
S = input()
T = input()
ans = 1e9
for si in range(len(S)):
if si+len(T) > len(S):
break
cnt = 0
for i in range(len(T)):
if S[si+i] != T[i]:
cnt += 1
ans = min(ans,cnt)
print(ans)
|
p02571
|
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()) #空白なし
S = LS2()
T = LS2()
a = len(S)
b = len(T)
ans = 10000
for i in range(a-b+1):
x = 0
for j in range(b):
if S[i+j] != T[j]:
x += 1
ans = min(ans,x)
print(ans)
|
import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S,T = LS2(),LS2()
a,b = len(S),len(T)
ans = 1000
for i in range(a-b+1):
x = 0
for j in range(b):
if S[i+j] != T[j]:
x += 1
ans = min(ans,x)
print(ans)
|
p02571
|
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()) #空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s-t+1):
count = 0
for j in range(t):
if T[j] != S[i+j]:
count += 1
ans = min(ans,count)
print(ans)
|
import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s-t+1):
count = 0
for j in range(t):
if T[j] != S[i+j]:
count += 1
ans = min(ans,count)
print(ans)
|
p02571
|
from sys import stdin
import re
from itertools import combinations
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
S = _in[0] # type:str
T = _in[1] # type:str
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
ans = 0
if T in S:
ans = 0
else:
for i in range(len(T)):
ans = i + 1
index = [j for j in range(len(T))]
comb = list(combinations(index, i+1))
for _comb in comb:
t = list(T)
for _i in _comb:
t[_i] = r'(\w)'
t = r''.join(t)
if re.search(t, S):
break
else:
continue
break
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
|
from sys import stdin
def main():
_in = [_.rstrip() for _ in stdin.readlines()]
S = _in[0] # type:str
T = _in[1] # type:str
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
ans = float('inf')
S_ = list(S)
T_ = list(T)
for i in range(len(S_)-len(T_)+1):
s_ = S_[i:i+len(T_)]
cnt = 0
for a,b in zip(s_, T_):
if a == b:
pass
else:
cnt += 1
ans = min(ans, cnt)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
print(ans)
if __name__ == "__main__":
main()
|
p02571
|
s,t=open(0)
print((min(sum(x!=y for x,y in zip(s[i:],t[:-1]))for i in range(len(s)-len(t)+1))))
|
s,(*t,_)=open(0)
print((min(sum(x!=y for x,y in zip(s[i:],t))for i in range(len(s)-len(t)))))
|
p02571
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = list(map(int, v_detail))
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, disc, scc_stack, in_scc_stack):
global timer
disc[current] = low[current] = timer
timer += 1
in_scc_stack[current] = True
scc_stack.append(current)
current_scc_set = set()
for adj in adj_table[current]:
if isinf(disc[adj]):
Tarjan(adj, low, disc, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], disc[adj])
scc_candidate = -1
if disc[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
current_scc_set.add(scc_candidate)
in_scc_stack[scc_candidate] = False
init_scc_sets_list.append(current_scc_set)
return None
def scc():
disc = [float('inf')] * vertices
low = [float('inf')] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if isinf(disc[v]):
Tarjan(v, low, disc, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve():
for question in q_list:
flag = False
ele1, ele2 = list(map(int, question))
for each in scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:edges + 1]]
q_num = int(_input[edges + 1])
q_list = [x.split() for x in _input[edges + 2:]]
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc()
solve()
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = list(map(int, v_detail))
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, dfn, scc_stack, in_scc_stack):
global timer
dfn[current] = low[current] = timer
timer += 1
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if isinf(dfn[adj]):
Tarjan(adj, low, dfn, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], dfn[adj])
scc_candidate = -1
if dfn[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
in_scc_stack[scc_candidate] = False
current_scc_set.add(scc_candidate)
init_scc_sets_list.append(current_scc_set)
return None
def scc_cluster():
dfn = [float('inf')] * vertices
low = [float('inf')] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if isinf(dfn[v]):
Tarjan(v, low, dfn, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve(_scc_sets_list):
for question in q_list:
flag = False
ele1, ele2 = list(map(int, question))
for each in _scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:edges + 1]]
q_num = int(_input[edges + 1])
q_list = [x.split() for x in _input[edges + 2:]]
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc_cluster()
solve(scc_sets_list)
|
p02368
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = list(map(int, v_detail))
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, dfn, scc_stack, in_scc_stack):
global timer
dfn[current] = low[current] = timer
timer += 1
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if not in_scc_stack[adj]:
Tarjan(adj, low, dfn, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
else:
low[current] = min(low[current], dfn[adj])
scc_candidate = -1
if dfn[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
in_scc_stack[scc_candidate] = False
current_scc_set.add(scc_candidate)
init_scc_sets_list.append(current_scc_set)
return None
def scc_cluster():
dfn = [float('inf')] * vertices
low = [float('inf')] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if not in_scc_stack[v]:
Tarjan(v, low, dfn, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve(_scc_sets_list):
for question in q_list:
flag = False
ele1, ele2 = list(map(int, question))
for each in _scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:edges + 1]]
q_num = int(_input[edges + 1])
q_list = [x.split() for x in _input[edges + 2:]]
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc_cluster()
solve(scc_sets_list)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = list(map(int, v_detail))
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, dfn, scc_stack, in_scc_stack):
global timer
dfn[current] = low[current] = timer
timer += 1
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if isinf(low[adj]):
Tarjan(adj, low, dfn, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], dfn[adj])
scc_candidate = -1
if dfn[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
in_scc_stack[scc_candidate] = False
current_scc_set.add(scc_candidate)
init_scc_sets_list.append(current_scc_set)
return None
def scc_cluster():
dfn = [float('inf')] * vertices
low = [float('inf')] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if isinf(low[v]):
Tarjan(v, low, dfn, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve(_scc_sets_list):
for question in q_list:
flag = False
ele1, ele2 = list(map(int, question))
for each in _scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:edges + 1]]
q_num = int(_input[edges + 1])
q_list = [x.split() for x in _input[edges + 2:]]
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc_cluster()
solve(scc_sets_list)
|
p02368
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def dfs_Tarjan(current, low, dfn, scc_stack, in_scc_stack):
global timer
dfn[current] = low[current] = timer
timer += 1
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if isinf(dfn[adj]):
dfs_Tarjan(adj, low, dfn, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], dfn[adj])
scc_candidate = -1
if dfn[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
in_scc_stack[scc_candidate] = False
current_scc_set.add(scc_candidate)
scc_clusters.append(current_scc_set)
return None
def scc_init():
dfn = [float('inf')] * v_num
low = [float('inf')] * v_num
scc_stack = list()
in_scc_stack = [False] * v_num
for v in range(v_num):
if isinf(dfn[v]):
dfs_Tarjan(v, low, dfn, scc_stack, in_scc_stack)
return scc_clusters
if __name__ == '__main__':
_input = sys.stdin.readlines()
v_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:e_num + 1]]
q_num = int(_input[e_num + 1])
queries = [x.split() for x in _input[e_num + 2:]]
adj_table = tuple([] for _ in range(v_num))
for v_info in edges:
source, target = list(map(int, v_info))
adj_table[source].append(target)
# adj_table = generate_adj_table(edges)
timer = 0
scc_clusters = []
# generate scc_clusters
scc_init()
for query in queries:
flag = False
q1, q2 = list(map(int, query))
for each in scc_clusters:
if (q1 in each) and (q2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
5 6
0 1
1 0
1 2
2 4
4 3
3 2
4
0 1
0 3
2 3
3 4
output:
1
0
1
1
"""
import sys
from math import isinf
sys.setrecursionlimit(int(1e5))
def generate_adj_table(_v_info):
for v_detail in _v_info:
v_from, v_to = list(map(int, v_detail))
init_adj_table[v_from].append(v_to)
return init_adj_table
def Tarjan(current, low, dfn, scc_stack, in_scc_stack):
global timer
dfn[current] = low[current] = timer
timer += 1
scc_stack.append(current)
in_scc_stack[current] = True
current_scc_set = set()
for adj in adj_table[current]:
if isinf(dfn[adj]):
Tarjan(adj, low, dfn, scc_stack, in_scc_stack)
low[current] = min(low[current], low[adj])
elif in_scc_stack[adj]:
low[current] = min(low[current], dfn[adj])
scc_candidate = -1
if dfn[current] == low[current]:
while scc_candidate != current:
scc_candidate = scc_stack.pop()
in_scc_stack[scc_candidate] = False
current_scc_set.add(scc_candidate)
init_scc_sets_list.append(current_scc_set)
return None
def scc_cluster():
dfn = [float('inf')] * vertices
low = [float('inf')] * vertices
scc_stack = list()
in_scc_stack = [False] * vertices
for v in range(vertices):
if isinf(dfn[v]):
Tarjan(v, low, dfn, scc_stack, in_scc_stack)
return init_scc_sets_list
def solve(_scc_sets_list):
for question in q_list:
flag = False
ele1, ele2 = list(map(int, question))
for each in _scc_sets_list:
if (ele1 in each) and (ele2 in each):
flag = True
break
if flag:
print('1')
else:
print('0')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:edges + 1]]
q_num = int(_input[edges + 1])
q_list = [x.split() for x in _input[edges + 2:]]
init_adj_table = tuple([] for _ in range(vertices))
adj_table = generate_adj_table(v_info)
timer = 0
init_scc_sets_list = []
scc_sets_list = scc_cluster()
solve(scc_sets_list)
|
p02368
|
# Acceptance of input
import sys
file_input = sys.stdin
V, E = list(map(int, file_input.readline().split()))
adj = [[] for i in range(V)]
for i in range(E):
s, t = list(map(int, file_input.readline().split()))
adj[s].append(t)
# dfs path detect
import collections
def isConnected(u, v):
path = collections.deque()
path.append(u)
notVisited = [True] * V
notVisited[u] = False
while path:
e = path[-1]
for n in adj[e]:
if n == v:
return True
elif notVisited[n]:
path.append(n)
notVisited[n] = False
if e == path[-1]:
path.pop()
return False
def isStronglyConnected(u, v):
if isConnected(u, v) and isConnected(v, u):
print((1))
else:
print((0))
# Output
Q = file_input.readline()
for line in file_input:
u, v = list(map(int, line.split()))
isStronglyConnected(u, v)
|
# Acceptance of input
import sys
file_input = sys.stdin
V, E = list(map(int, file_input.readline().split()))
adj = [[] for i in range(V)]
for i in range(E):
s, t = list(map(int, file_input.readline().split()))
adj[s].append(t)
# Tarjan's strongly connected components algorithm
import collections
sys.setrecursionlimit(100000)
S = collections.deque()
indices = [None] * V
lowlink = [None] * V
onStack = [False] * V
index = 0
scc_id = [None] * V
def strong_connect(v):
global index
indices[v] = index
lowlink[v] = index
index += 1
S.append(v)
onStack[v] = True
for w in adj[v]:
if indices[w] == None:
strong_connect(w)
lowlink[v] = min(lowlink[v], lowlink[w])
elif onStack[w]:
lowlink[v] = min(lowlink[v], indices[w])
if lowlink[v] == indices[v]:
while S:
w = S.pop()
onStack[w] = False
scc_id[w] = v
if w == v:
break
for v in range(V):
if not indices[v]:
strong_connect(v)
# Output
Q = file_input.readline()
for line in file_input:
u, v = list(map(int, line.split()))
if scc_id[u] == scc_id[v]:
print((1))
else:
print((0))
|
p02368
|
def solve():
N, M = list(map(int, input().split()))
edges = [[] for _ in [0]*N]
r_edges = [[] for _ in [0]*N]
for _ in [0]*M:
a, b = list(map(int, input().split()))
edges[a].append(b)
r_edges[b].append(a)
c = get_strongly_connected_components(edges, r_edges)
group = [0]*N
for i in range(len(c)):
for v in c[i]:
group[v] = i
result = []
append = result.append
for _ in [0]*int(eval(input())):
a, b = list(map(int, input().split()))
append("1" if group[a] == group[b] else "0")
print(("\n".join(result)))
def get_strongly_connected_components(edges, r_edges):
import sys
sys.setrecursionlimit(10**7)
v_count = len(edges)
order = [0]*v_count
k = 1
def get_order(v):
order[v] = 1
nonlocal k
for dest in edges[v]:
if order[dest] == 0:
get_order(dest)
order[v] = k
k += 1
def get_components(v):
order[v] = 0
return [v] + [_v for dest in r_edges[v] if order[dest] > 0 for _v in get_components(dest)]
[None for v in range(v_count) if order[v] == 0 and get_order(v)]
return [get_components(v) for v, _ in sorted(enumerate(order), key=lambda x: x[1], reverse=True) if order[v] > 0]
if __name__ == "__main__":
solve()
|
def solve():
N, M = list(map(int, input().split()))
edges = [[] for _ in [0]*N]
r_edges = [[] for _ in [0]*N]
for _ in [0]*M:
a, b = list(map(int, input().split()))
edges[a].append(b)
r_edges[b].append(a)
c = get_strongly_connected_components(edges, r_edges)
group = [0]*N
for i in range(len(c)):
for v in c[i]:
group[v] = i
result = []
append = result.append
for _ in [0]*int(eval(input())):
a, b = list(map(int, input().split()))
append("1" if group[a] == group[b] else "0")
print(("\n".join(result)))
def get_strongly_connected_components(edges, r_edges):
import sys
sys.setrecursionlimit(10**7)
v_count = len(edges)
order = [0]*v_count
k = [1]
def get_order(v):
order[v] = 1
for dest in edges[v]:
if order[dest] == 0:
get_order(dest)
order[v] = k[0]
k[0] += 1
def get_components(v):
order[v] = 0
return [v] + [_v for dest in r_edges[v] if order[dest] > 0 for _v in get_components(dest)]
[None for v in range(v_count) if order[v] == 0 and get_order(v)]
return [get_components(v) for v, _ in sorted(enumerate(order), key=lambda x: x[1], reverse=True) if order[v] > 0]
if __name__ == "__main__":
solve()
|
p02368
|
def solve():
N, M = list(map(int, input().split()))
edges = [[] for _ in [0]*N]
r_edges = [[] for _ in [0]*N]
for _ in [0]*M:
a, b = list(map(int, input().split()))
edges[a].append(b)
r_edges[b].append(a)
c = kosaraju(edges, r_edges)
group = [0]*N
for i in range(len(c)):
for v in c[i]:
group[v] = i
result = []
append = result.append
for _ in [0]*int(eval(input())):
a, b = list(map(int, input().split()))
append("1" if group[a] == group[b] else "0")
print(("\n".join(result)))
def kosaraju(edges, reverse_edges):
import sys
sys.setrecursionlimit(10**7)
v_count = len(edges)
order = [0]*v_count
k = [1]
def get_order(v):
order[v] = 1
for dest in (_v for _v in edges[v] if order[_v] == 0):
get_order(dest)
order[v] = k[0]
k[0] += 1
def get_components(v):
order[v] = 0
return [v] + [_v for dest in reverse_edges[v] if order[dest] > 0 for _v in get_components(dest)]
for v in (_v for _v in range(v_count) if order[_v] == 0):
get_order(v)
return [get_components(v) for v, _ in sorted(enumerate(order), key=lambda x: x[1], reverse=True) if order[v] > 0]
if __name__ == "__main__":
solve()
|
def solve():
N, M = list(map(int, input().split()))
edges = [[] for _ in [0]*N]
r_edges = [[] for _ in [0]*N]
for _ in [0]*M:
a, b = list(map(int, input().split()))
edges[a].append(b)
r_edges[b].append(a)
c = kosaraju(edges, r_edges)
group = [0]*N
for i in range(len(c)):
for v in c[i]:
group[v] = i
result = []
append = result.append
for _ in [0]*int(eval(input())):
a, b = list(map(int, input().split()))
append("1" if group[a] == group[b] else "0")
print(("\n".join(result)))
def kosaraju(edges, reverse_edges):
import sys
sys.setrecursionlimit(10**7)
v_count = len(edges)
order = [0]*v_count
k = [1]
def get_order(v):
order[v] = 1
[None for dest in edges[v] if order[dest] == 0 and get_order(dest)]
order[v] = k[0]
k[0] += 1
def get_components(v):
order[v] = 0
return [v] + [_v for dest in reverse_edges[v] if order[dest] > 0 for _v in get_components(dest)]
[None for v in range(v_count) if order[v] == 0 and get_order(v)]
return [get_components(v) for v, _ in sorted(enumerate(order), key=lambda x: x[1], reverse=True) if order[v] > 0]
if __name__ == "__main__":
solve()
|
p02368
|
"""
強連結成分分解
"""
import sys
sys.setrecursionlimit(1000000)
def dfs(v, visited, edges, order):
visited[v] = True
for to in edges[v]:
if not visited[to]:
dfs(to, visited, edges, order)
order.append(v)
def search_strongly_connection(v, visited, reverse_edges, parent):
visited[v] = True
for to in reverse_edges[v]:
if not visited[to]:
parent[to] = v
search_strongly_connection(to, visited, reverse_edges, parent)
def find(parent, x):
if parent[x] == x:
return x
tmp = find(parent, parent[x])
parent[x] = tmp
return tmp
v_num , e_num = list(map(int, input().split()))
edges = [[] for _ in range(v_num)]
reverse_edges = [[] for _ in range(v_num)]
for _ in range(e_num):
s, t = list(map(int, input().split()))
edges[s].append(t)
reverse_edges[t].append(s)
order = []
visited = [False] * v_num
for v in range(v_num):
if not visited[v]:
dfs(v, visited, edges, order)
order.reverse()
visited = [False] * v_num
parent = [i for i in range(v_num)]
for v in order:
if not visited[v]:
search_strongly_connection(v, visited, reverse_edges, parent)
q_num = int(eval(input()))
for _ in range(q_num):
u, v = list(map(int, input().split()))
if find(parent, u) == find(parent, v):
print((1))
else:
print((0))
|
"""
強連結成分分解
"""
import sys
sys.setrecursionlimit(1000000)
def dfs(v, visited, edges, order):
visited[v] = True
for to in edges[v]:
if not visited[to]:
dfs(to, visited, edges, order)
order.append(v)
def search_strongly_connection(v, visited, reverse_edges, parent, num):
visited[v] = True
for to in reverse_edges[v]:
if not visited[to]:
parent[to] = num
search_strongly_connection(to, visited, reverse_edges, parent, num)
v_num , e_num = list(map(int, input().split()))
edges = [[] for _ in range(v_num)]
reverse_edges = [[] for _ in range(v_num)]
for _ in range(e_num):
s, t = list(map(int, input().split()))
edges[s].append(t)
reverse_edges[t].append(s)
order = []
visited = [False] * v_num
for v in range(v_num):
if not visited[v]:
dfs(v, visited, edges, order)
order.reverse()
visited = [False] * v_num
parent = [i for i in range(v_num)]
for v in order:
num = v
if not visited[v]:
search_strongly_connection(v, visited, reverse_edges, parent, num)
q_num = int(eval(input()))
for _ in range(q_num):
u, v = list(map(int, input().split()))
if parent[u] == parent[v]:
print((1))
else:
print((0))
|
p02368
|
import sys
sys.setrecursionlimit(10001)
def dfs(u, g, stack):
visited[u] = True
for v in g[u]:
if not visited[v]:
dfs(v, g, stack)
stack.append(u)
return stack
nv, ne = list(map(int, input().split(' ')))
adj, tps = ([[] for _ in range(nv)] for _ in range(2))
for _ in range(ne):
s, t = list(map(int, input().split(' ')))
adj[s].append(t)
tps[t].append(s)
visited = [False] * nv
stack = []
for i in range(nv):
if not visited[i]:
stack = dfs(i, adj, stack)
visited = [False] * nv
comps = []
while stack:
i = stack.pop()
if not visited[i]:
comp = dfs(i, tps, [])
comps.append(comp)
nv = int(eval(input()))
for _ in range(nv):
u, v = list(map(int, input().split(' ')))
ans = 0
for comp in comps:
if u in comp and v in comp:
ans = 1
print(ans)
|
import sys
sys.setrecursionlimit(10001)
def dfs(u, g, stack):
visited[u] = True
for v in g[u]:
if not visited[v]:
dfs(v, g, stack)
stack.append(u)
return stack
nv, ne = list(map(int, input().split(' ')))
adj, tps = ([[] for _ in range(nv)] for _ in range(2))
for _ in range(ne):
s, t = list(map(int, input().split(' ')))
adj[s].append(t)
tps[t].append(s)
visited = [False] * nv
stack = []
for i in range(nv):
if not visited[i]:
stack = dfs(i, adj, stack)
visited = [False] * nv
comp_is = {}
while stack:
i = stack.pop()
if not visited[i]:
comp = dfs(i, tps, [])
for v in comp:
comp_is[v] = i
nv = int(eval(input()))
for _ in range(nv):
u, v = list(map(int, input().split(' ')))
if comp_is[u] == comp_is[v]: print((1))
else: print((0))
|
p02368
|
N = int(eval(input()))
from math import sqrt
#N mod K = 0 or 1 となるk をさがす
#K = Nの約数 or N-1 の約数
def divisor(num):
max_num = int(sqrt(num))
divisor_list = []
for i in range(1, max_num + 1):
if num % i == 0:
if i != 1:
divisor_list.append(i)
divisor_list.append(num//i)
sorted_divisor_list = sorted(divisor_list)
return sorted_divisor_list
K_1 = divisor(N-1)
K_2 = divisor(N)
Ks = set(K_1 + K_2)
count = 0
for k in Ks:
temp = N
while temp % k == 0:
temp //= k
if temp == 1 or temp % k == 1:
count += 1
ans = count
print(ans)
|
N = int(eval(input()))
from math import sqrt
#N mod K = 0 or 1 となるk をさがす
#K = Nの約数 or N-1 の約数
def divisor(num):
max_num = int(sqrt(num))
divisor_list = []
for i in range(1, max_num + 1):
if num % i == 0:
if i != 1:
divisor_list.append(i)
if num // i != 1:
divisor_list.append(num//i)
#sorted_divisor_list = sorted(divisor_list)
return divisor_list
K_1 = divisor(N-1)
K_2 = divisor(N)
K_3 = []
count = 0
for k in K_2:
temp = N
while temp % k == 0:
temp //= k
if temp == 1 or temp % k == 1:
count += 1
K_3.append(k)
kk = K_1 + K_3
ans = len(set(kk))
print(ans)
|
p02722
|
N = int(eval(input()))
from math import sqrt
#N mod K = 0 or 1 となるk をさがす
#K = Nの約数 or N-1 の約数
def divisor(num):
max_num = int(sqrt(num))
divisor_list = []
for i in range(1, max_num + 1):
if num % i == 0:
if i != 1:
divisor_list.append(i)
if num // i != 1:
divisor_list.append(num//i)
#sorted_divisor_list = sorted(divisor_list)
return divisor_list
K_1 = divisor(N-1)
K_2 = divisor(N)
K_3 = []
count = 0
for k in K_2:
temp = N
while temp % k == 0:
temp //= k
if temp == 1 or temp % k == 1:
count += 1
K_3.append(k)
kk = K_1 + K_3
ans = len(set(kk))
print(ans)
|
N = int(eval(input()))
from math import sqrt
def divisor(num):
max_num = int(sqrt(num))
divisor_list = []
for i in range(1, max_num + 1):
if num % i == 0:
divisor_list.append(i)
divisor_list.append(num//i)
return divisor_list
K0 = divisor(N)
K1 = divisor(N-1)
S = set(K1)
S.remove(1)
for k in K0:
tmp = N
if k == 1:
continue
while tmp % k == 0 and tmp >= k:
tmp //= k
if tmp % k == 1:
S.add(k)
print((len(S)))
|
p02722
|
N = int(eval(input()))
def solve(num):
ret = set()
p = 1
while p * p <= num:
if num % p == 0:
ret.add(p)
ret.add(num // p)
p += 1
return ret
s1 = solve(N)
s2 = solve(N-1)
# 1は答えに入らないので抜いた
ans = len(s2) - 1
for n in s1:
if n == 1:
continue
tmp = N
while tmp % n == 0:
tmp = tmp // n
if tmp % n == 1:
ans += 1
print(ans)
|
N = int(eval(input()))
"""
愚直にやると、Kを2～Nの範囲で全部調べて数え上げる。N <= 10**12 なので間に合わない。
たとえば N=100だと、
[2, 3, 4, 9, 10, 11, 33, 99, 100]
が条件を満たす数字になる。
割り算を行わないとき、明らかに N % K = 1 になる
これは、「NをKで割ったら、１あまる」であるから、「N-1をKでわったら割り切れる」ともいえる。
なので、割り算が起こらないものは、N-1の約数。
割り算が起こるやつは、割れるだけ割った後、余りを調べればよい。
"""
def solve(n):
i = 1
ret = set()
while i * i <= n:
if n % i == 0:
ret.add(i)
ret.add(n // i)
i += 1
return ret
div_N_sub_1 = solve(N-1)
div_N = solve(N)
ans = len(div_N_sub_1) - 1
for i in div_N:
if i == 1:
continue
tmp = N
while tmp % i == 0:
tmp //= i
if tmp % i == 1:
ans += 1
print(ans)
|
p02722
|
n = int(eval(input()))
def check(n, k):
while n % k == 0:
n = n // k
if n >= k:
n = n - k * (n // k)
return n
def count(n):
total = 0
cands = set([n, n-1])
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
cands.add(i)
cands.add(n // i)
for i in range(2, int(n ** 0.5) + 1):
if (n-1) % i == 0:
cands.add(i)
cands.add((n - 1) // i)
for k in cands:
if check(n, k) == 1:
total += 1
return total
print((count(n)))
|
n = int(eval(input()))
def check(n, k):
while n % k == 0:
n = n // k
if n >= k:
n = n - k * (n // k)
return n
def count(n):
total = 0
cands = set([n, n-1])
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
cands.add(i)
cands.add(n // i)
for i in range(2, int(n ** 0.5) + 1):
if (n-1) % i == 0:
cands.add(i)
cands.add((n - 1) // i)
for k in cands:
if k == 1:
continue
if check(n, k) == 1:
total += 1
return total
print((count(n)))
|
p02722
|
N=int(eval(input()))
k=2
ans=1
factors=[]
i=1
while i*i<N-1:
if (N-1)%i==0:
ans+=1
i+=1
while k*k<=N:
n=0
while pow(k,n)<=N:
if (N-pow(k,n))%(pow(k,n+1))==0:
ans+=1
break
n+=1
k+=1
print(ans)
|
n=int(eval(input()))
ans=set()
ans.add(n)
i=2
x = 1
while x * x <= n-1 :
if (n-1) % x == 0:
ans.add(x)
ans.add((n-1)//x)
x += 1
while i*i<=n:
t=n
while t%i==0:
t/=i
if t%i==1:
ans.add(i)
i+=1
print((len(ans)-1))
|
p02722
|
def make_div(n):
divs = []
for i in range(1, int(n**0.5)+1):
if n%i==0:
divs.append(i)
if i!=n//i:
divs.append(n//i)
divs.sort()
return divs
N = int(eval(input()))
d = make_div(N)
d = d[1:]
s = set()
for di in d:
N2 = N
while N2%di==0:
N2 //= di
if (N2-1)%di==0:
s.add(di)
d = make_div(N-1)
d = d[1:]
for di in d:
s.add(di)
print((len(s)))
|
def make_divs(n):
divs = []
for i in range(1, int(n**0.5)+1):
if n%i==0:
divs.append(i)
if i!=n//i:
divs.append(n//i)
return divs
N = int(eval(input()))
divs = make_divs(N)
ans = 0
for d in divs:
if d==1:
continue
N2 = N
while N2%d==0:
N2 //= d
if (N2-1)%d==0:
ans += 1
divs = make_divs(N-1)
ans += len(divs)-1
print(ans)
|
p02722
|
N = int(eval(input()))
divisor = set([N, N - 1])
x = N
for i in range(2, int(x ** 0.5) + 1):
z = x
while z % i == 0:
z //= i
if z % i == 1:
divisor.add(i)
if i == x // i:
continue
z = x
while z % (x // i) == 0:
z //= (x // i)
if z % (x // i) == 1:
divisor.add((x // i))
x = N - 1
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
divisor.add(i)
divisor.add(x // i)
print((len(divisor) if N > 2 else 1))
|
N = int(eval(input()))
def calc_divisor(x):
divisor = []
for i in range(1, int(x ** 0.5) + 1):
if x % i == 0:
if i != 1:
divisor.append(i)
if i != x // i:
divisor.append(x // i)
return divisor
cand = len(calc_divisor(N - 1))
divisor_n = calc_divisor(N)
for v in divisor_n:
x = N
while x % v == 0:
x //= v
if x % v == 1:
cand += 1
print(cand)
|
p02722
|
N = int(eval(input()))
if N == 2:
print((1))
exit()
if N == 3:
print((2))
exit()
ans = []
for n in range(1, int(N ** 0.5) + 1):
if (N - 1) % n == 0:
ans.append(n)
ans.append((N - 1) // n)
for k in range(2, int(N ** 0.5) + 1):
x = N
while x % k == 0:
x //= k
if 1 in (x % k - k, x % k):
ans.append(k)
print((len(set(ans))))
|
N = int(eval(input()))
ans = []
for n in range(1, int(N ** 0.5) + 1):
if (N - 1) % n == 0:
ans.append(n)
ans.append((N - 1) // n)
for k in range(2, int(N ** 0.5) + 1):
if N % k != 0:
continue
x = N
while x % k == 0:
x //= k
if x % k == 1:
ans.append(k)
print((len(set(ans))))
|
p02722
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
n = int(eval(input()))
i = 2
cnt = 1
check = 0
# for i in range(2, n + 1):
# m = n
# while m % i == 0:
# m //= i
# m %= i
# if m == 1:
# print(i)
# cnt += 1
# print(cnt)
# print()
# print()
out = [n]
while i < n: #割ってひく
m = n
if i - m / i > 2:
break
while m % i == 0:
check = 1
m //= i
if (m % i == 1 and check):
out.append(i)
cnt += 1
i += 1
i = 2
while i * i <= n: #割ってひく
m = n
while m % i == 0:
m //= i
if m == 1:
out.append(i)
i += 1
out += make_divisors(n - 1)
print((len(set(out)) - 1))
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
n = int(eval(input()))
out = make_divisors(n)
ans = []
for i in out:
if i == 1:
continue
m = n
while m % i == 0:
m //= i
if m == 1 or m % i == 1:
ans.append(i)
ans += make_divisors(n - 1)
# print(set(out))
print((len(set(ans)) - 1))
|
p02722
|
def MI():return list(map(int,input().split()))
def LI():return list(MI())
# n,k,c=MI()
# s=input()
"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
n=int(eval(input()))
l=[]
yakusuu=(make_divisors(n-1))
for k in range(2,min(10**6,n)+1):
NN=int(n)
while NN>=k:
if NN%k==0:
NN=NN//k
else:
NN=NN%k
if NN==1:
l+=k,
ll=(l+yakusuu+[n])
print((len(set(ll))))
|
def MI():return list(map(int,input().split()))
def LI():return list(MI())
def factorization(n):
arr=[]
temp=n
for i in range(2,int(n**0.5)+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp//=i
arr.append([i,cnt])
if temp!=1:arr.append([temp,1])
if arr==[]:arr.append([n,1])
return arr
def make_divisors(n):
divisors=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
divisors.append(i)
if i!=n//i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
n=int(eval(input()))
l=[]
for k in make_divisors(n):
NN=int(n)
while NN>=k:
if NN%k==0:
NN=NN//k
else:
NN=NN%k
if NN==1:l+=k,
ll=(l+make_divisors(n-1))
print((len(ll)))
|
p02722
|
N=int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
s=len(make_divisors(N-1))
for i in range(1,len(make_divisors(N))):
q=N
p=make_divisors(N)[i]
while True:
if q%p==0:
q/=p
else:
break
if (q-1)%p==0:
s+=1
print((s-1))
|
N=int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
s=len(make_divisors(N-1))
p=make_divisors(N)
for i in range(1,len(p)):
q=N
while True:
if q%p[i]==0:
q/=p[i]
else:
break
if (q-1)%p[i]==0:
s+=1
print((s-1))
|
p02722
|
N = int(eval(input()))
cnt = 2 if N > 2 else 1
ret = []
for i in range(2, int(N**0.5)+1):
if N % i == 0:
k = N//i
while k % i == 0:
k //= i
if k % i == 1:
cnt += 1
if N // i != i:
j = N // i
k = i
while k % j == 0:
k //= j
if k % j == 1:
cnt += 1
M = N - 1
for i in range(2, int((M)**0.5)+1):
if M % i == 0:
cnt += 1
if M // i != i:
cnt += 1
print(cnt)
|
N = int(eval(input()))
def divisor(N):
ret = []
for i in range(1, int(N**0.5)+1):
if N % i == 0:
ret.append(i)
if N // i != i:
ret.append(N//i)
return ret
div_N = divisor(N)
div_N_1 = divisor(N-1)
ans = 0
for k in div_N[1:]:
n = N
while n % k == 0:
n //= k
if n % k == 1:
ans += 1
ans += len(div_N_1) - 1
print(ans)
|
p02722
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort() #小さい順位欲しいとき
return divisors
## [[2, 3], [3, 1]]
## 24 = 2^3 * 3^1
n=int(eval(input()))
a=make_divisors(n)
cnt=0
use=set()
for k in a[1:]:
t=n
while t%k==0:
t//=k
if t%k==1:
use.add(k)
b=make_divisors(n-1)
for i in b[1:]:
use.add(i)
print((len(use)))
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort() #小さい順位欲しいとき
return divisors
n=int(eval(input()))
a=make_divisors(n)[1:]
ans=0
for i in a:
k=n
while k%i==0:
k//=i
if k%i==1:
ans+=1
ans+=len(make_divisors(n-1))-1
print(ans)
|
p02722
|
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
N = int(eval(input()))
divsN = make_divisors(N)
divsN2 = make_divisors(N-1)
divsN.pop(0)
ans = len(divsN2)-1
for div in divsN:
n = N+1-1
while True:
if n%div != 0 or n==1:
break
n //= div
if n%div == 1:
ans += 1
print(ans)
|
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
N = int(eval(input()))
divsN = make_divisors(N)
divsN2 = make_divisors(N-1)
divsN.pop(0)
ans = len(divsN2)-1
for div in divsN:
n = N
while True:
if n%div != 0 or n==1:
break
n //= div
if n%div == 1:
ans += 1
print(ans)
|
p02722
|
def check(i):
tot=k
while(tot%i==0):
tot//=i
if(tot%i==1):
setl.add(i)
import math
k=int(eval(input()))
if(k==2):
print((1))
exit()
setl = set()
setl.add(k); setl.add(k-1)
for x in range(2,int(math.sqrt(k))+1):
check(x)
check(k//x)
print((len(setl)))
|
def check(i):
tot=k
pw=0
while(tot%i==0):
tot//=i
pw+=1
if(tot%i==1):
other = tot//i
if(pw==0 and other>=2 and other<=k):
setl.add(other)
setl.add(i)
import math
k=int(eval(input()))
if(k==2):
print((1))
exit()
setl = set()
setl.add(k); setl.add(k-1)
for x in range(2,int(math.sqrt(k))+1):
check(x)
# check(k//x)
print((len(setl)))
|
p02722
|
import sys
from math import sqrt, floor
def divisors(n):
res = set()
for i in range(1, floor(sqrt(n)) + 1):
if n % i == 0:
res.add(i)
res.add(n // i)
return res
n = int(sys.stdin.readline().rstrip())
def main():
res = divisors(n - 1)
cnt = len(res) - 1 + 1
for i in range(2, floor(sqrt(n)) + 1):
if i in res: continue
m = n
while m % i == 0:
m //= i
if (m - 1) % i == 0:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
import sys
from math import sqrt, floor
def divisors(n):
res = set()
for i in range(1, floor(sqrt(n)) + 1):
if n % i == 0:
res.add(i)
res.add(n // i)
return res - set([1])
n = int(sys.stdin.readline().rstrip())
def main():
res = divisors(n - 1)
cnt = len(res)
for i in divisors(n):
if i in res: continue
m = n
while m % i == 0:
m //= i
if (m - 1) % i == 0:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
p02722
|
import sys
from math import sqrt, floor
def divisors(n):
res = set()
for i in range(1, floor(sqrt(n)) + 1):
if n % i == 0:
res.add(i)
res.add(n // i)
return res - set([1])
n = int(sys.stdin.readline().rstrip())
def main():
res = divisors(n - 1)
cnt = len(res)
for i in divisors(n):
if i in res: continue
m = n
while m % i == 0:
m //= i
if (m - 1) % i == 0:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
import sys
from math import sqrt, floor
def divisors(n):
res = set()
for i in range(1, floor(sqrt(n)) + 1):
if not n % i:
res.add(i)
res.add(n // i)
return res - set([1])
n = int(sys.stdin.readline().rstrip())
def main():
res = divisors(n - 1)
cnt = len(res)
for i in divisors(n):
m = n
while not m % i:
m //= i
if (m - 1) % i == 0:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
p02722
|
import math
def make_divisors(n):
divisors = []
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def main():
n = int(eval(input()))
r = len(make_divisors(n-1)) - 1
d = make_divisors(n)
for i in d:
if i == 1:
continue
if i == 2:
r += 1
continue
t = n
while True:
if t % i == 0:
t = t // i
else:
t = t - i
if t == 1:
r += 1
break
if t <= 0:
break
return r
print((main()))
|
import math
def make_divisors(n):
divisors = []
for i in range(1, int(math.sqrt(n))+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def main():
n = int(eval(input()))
r = len(make_divisors(n-1)) - 1
d = make_divisors(n)
for i in d:
if i == 1:
continue
if i == 2:
r += 1
continue
t = n
while t % i == 0:
t = t // i
t = t % i
if t == 1:
r += 1
return r
print((main()))
|
p02722
|
N = int(eval(input()))
def isOk(k):
n = N
while n % k == 0:
n //= k
return n % k == 1
if N <= 10**6:
ans = 0
for i in range(2, N + 1):
if isOk(i):
ans += 1
print(ans)
exit()
ans = 0
V = set()
for i in range(2, int(N**0.5) + 10):
if isOk(i):
ans += 1
V.add(i)
# 約数の全列挙
def divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort(reverse=True) # ソート
return divisors
divN = divisors(N - 1)
ans += len([d for d in divN if not d in V])
print(ans)
|
N = int(eval(input()))
def isOk(k):
n = N
while n % k == 0:
n //= k
return n % k == 1
# 約数の全列挙
def divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort(reverse=True) # ソート
return divisors
divN = divisors(N)
divN1 = divisors(N - 1)
ans = len([0 for d in divN if d > 1 and isOk(d)]) + len([0 for d in divN1 if d > 1 and isOk(d)])
print(ans)
|
p02722
|
import math
def prime(x):
L = []
last = math.floor(x ** 0.5)
for i in range(1, last + 1):
if x % i == 0:
L.append(i)
if x // i != i:
L.append(x // i)
return L
N = int(eval(input()))
if N == 2:
print((1))
exit()
L = prime(N - 1)
ans = len(L) - 1
D = prime(N)
for i in D:
if i == 1: continue
t = N
while (t / i == t // i):
t //= i
t -= 1
if t / i == t // i:
ans += 1
print(ans)
|
import math
def prime(x):
p = {}
last = math.floor(x ** 0.5)
if x % 2 == 0:
cnt = 1
x //= 2
while x & 1 == 0:
x //= 2
cnt += 1
p[2] = cnt
for i in range(3, last + 1, 2):
if x % i == 0:
x //= i
cnt = 1
while x % i == 0:
cnt += 1
x //= i
p[i] = cnt
if x != 1:
p[x] = 1
return p
N = int(eval(input()))
P = prime(N - 1)
if N == 2:
print((1))
exit()
ans = 1
for i in list(P.keys()):
ans *= P[i] + 1
ans -= 1
P = prime(N)
D = [1]
for i in list(P.keys()):
L = len(D)
n = i
for j in range(P[i]):
for k in range(L):
D.append(D[k] * n)
n *= i
for i in D:
if i == 1: continue
t = N
while (t / i == t // i):
t //= i
t -= 1
if t / i == t // i:
ans += 1
print(ans)
|
p02722
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n = int(eval(input()))
nl = make_divisors(n)
nl_p = make_divisors(n+1)
nl_m = make_divisors(n-1)
l = sorted(list(set(nl + nl_p+nl_m)))
ans = 0
for i in range(1, len(l)-1):
p = n
k = l[i]
while p > k:
if p%k == 0:
p = p//k
else:
if (p-1)%k == 0:
p = 1
break
p = p - k
if p == 1:
ans += 1
print((ans+1))
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n = int(eval(input()))
nl = make_divisors(n)
nl_m = make_divisors(n-1)
l = sorted(list(set(nl + nl_m)))
ans = 0
for i in range(1, len(l)-1):
p = n
k = l[i]
while p%k == 0:
p = p // k
if p%k == 1:
ans += 1
print((ans+1))
|
p02722
|
def main():
from collections import Counter as ct
def soinsuu(a):
yy, j = [], 2
y = yy.append
while(a > 1):
for i in range(j, int(a**0.5)+1):
if a % i == 0:
y(i)
a, j = a//i, i
break
else:
y(a)
break
return ct(yy)
def soinsuu2(a):
s = {1}
for i, j in list(a.items()):
s2 = set()
for k in range(1, j+1):
for l in s:
s2.add(l*pow(i, k))
s |= s2
s.remove(1)
return s
n = int(eval(input()))
ans = 0
s = soinsuu(n)
s2 = soinsuu2(s)
for i in s2:
m = n
while m % i == 0:
m //= i
m -= 1
if m % i == 0:
ans += 1
n -= 1
ans2 = 1
for i in list(soinsuu(n).values()):
ans2 *= i+1
ans2 -= 1
print((ans+ans2))
main()
|
def main():
from collections import Counter as ct
def soinsuu(a):
yy, j = [], 2
y = yy.append
while(a > 1):
for i in range(j, int(a**0.5)+1):
if a % i == 0:
y(i)
a, j = a//i, i
break
else:
y(a)
break
return ct(yy)
def yakusuu(a):
s = {1}
for i, j in list(a.items()):
s |= {l*i**k for l in s for k in range(1, j+1)}
s.remove(1)
return s
n = int(eval(input()))
ans = 1
for i in list(soinsuu(n-1).values()):
ans *= i+1
ans -= 1
for i in yakusuu(soinsuu(n)):
m = n
while m % i == 0:
m //= i
m -= 1
if m % i == 0:
ans += 1
print(ans)
main()
|
p02722
|
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: list(map(int, stdin.readline().split()))
nl = lambda: list(map(int, stdin.readline().split()))
def divisor(n):
ass = []
for i in range(1, int(n**0.5)+1):
if n%i == 0:
ass.append(i)
ass.append(n//i)
return ass
n = ni()
p = divisor(n)
s = set()
for k in p:
nk = n // k
for t in divisor(nk - 1):
s.add(t*k)
ans = 0
s.remove(1)
s.add(n)
for t in s:
m = n
while m % t == 0:
m //= t
if m % t == 1:
ans += 1
print(ans)
|
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: list(map(int, stdin.readline().split()))
nl = lambda: list(map(int, stdin.readline().split()))
def divisor(n):
ass = []
for i in range(1, int(n**0.5)+1):
if n%i == 0:
ass.append(i)
ass.append(n//i)
return ass
n = ni()
p = divisor(n)
q = divisor(n-1)
s = set()
ans = 0
for x in p + q:
m = n
if x == 1: continue
while m % x == 0:
m //= x
if m % x == 1:
s.add(x)
print((len(s)))
|
p02722
|
N=int(eval(input()))
DN={N}
k=2
while(k*k<=N):
if N%k==0:
DN.add(k)
DN.add(N//k)
k+=1
DN1={N-1}
k=2
while(k*k<=(N-1)):
if (N-1)%k==0:
DN1.add(k)
DN1.add((N-1)//k)
k+=1
DN=sorted(list(DN))
DN1=sorted(list(DN1))
#print(DN)
#print(DN1)
ans=set()
for K in DN:
tmp=N
while(tmp>=K):
if tmp%K==0:
tmp//=K
else:
tmp%=K
if tmp==1:
ans.add(K)
for K in DN1:
tmp=N
while(tmp>=K):
if tmp%K==0:
tmp//=K
else:
tmp%=K
if tmp==1:
ans.add(K)
#print(ans)
print((len(ans)))
|
N=int(eval(input()))
if N==2:
print((1))
exit()
DN={N}
k=2
while(k*k<=N):
if N%k==0:
DN.add(k)
DN.add(N//k)
k+=1
DN1={N-1}
k=2
while(k*k<=(N-1)):
if (N-1)%k==0:
DN1.add(k)
DN1.add((N-1)//k)
k+=1
DN1=len(DN1)
#print(DN)
#print(DN1)
ans=0
for K in DN:
tmp=N
while(tmp>=K):
if tmp%K==0:
tmp//=K
else:
tmp%=K
if tmp==1:
ans+=1
#print(ans)
print((DN1+ans))
|
p02722
|
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
def make_divisors(n): # nの約数を列挙、1を除く
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
d1 = make_divisors(N-1)
answer = len(d1)
d2 = make_divisors(N)
for x in d2:
M = N
while M%x == 0:
M //= x
if M%x == 1:
answer += 1
print(answer)
|
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
# 候補はNかN-1の約数
answer = 0
def make_divisors(n): # nの約数を列挙
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
cand = make_divisors(N) + make_divisors(N-1)
for x in cand:
M = N
while M % x == 0:
M //= x
r = M % x
if r == 1:
answer += 1
print(answer)
|
p02722
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n = int(eval(input()))
l = make_divisors(n)
ans = make_divisors(n-1)
for i in l:
m=n
if i==1:
continue
else:
while(m%i==0):
m//=i
if m==1:
ans.append(i)
else:
if i in make_divisors(m-1):
ans.append(i)
ans=set(ans)
print((len(ans)-1))
|
def main():
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
n = int(eval(input()))
l = make_divisors(n)
ans = make_divisors(n-1)
for i in l:
m=n
if i==1:
continue
else:
while(m%i==0):
m//=i
if m==1:
ans.append(i)
else:
if i in make_divisors(m-1):
ans.append(i)
ans=set(ans)
print((len(ans)-1))
if __name__ == "__main__":
main()
|
p02722
|
N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
L = len(make_divisors(N))
ans = 0
for i in range(1,L):
t = N
while t%(make_divisors(N)[i]) == 0:
t = t//make_divisors(N)[i]
if t%make_divisors(N)[i] == 1:
ans = ans + 1
print((ans + len(make_divisors(N-1)) -1))
|
N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
L = len(make_divisors(N))
A = make_divisors(N)
ans = 0
for i in range(1,L):
t = N
while t%(A[i]) == 0:
t = t//A[i]
if t%A[i] == 1:
ans = ans + 1
print((ans + len(make_divisors(N-1)) -1))
|
p02722
|
N = int(eval(input()))
originalN = 0 +N
if N == 2:
print((1))
exit()
ans = 0
primenum = [2]
count = [0 for _ in range(int(N**0.5)+2)]
for k in range(3, len(count), 2):
if count[k] == 0:
primenum.append(k)
for j in range(k, len(count), k):
count[j] = 1
def factorization(n):
lis = []
k = 0
while primenum[k] <= n:
if n%primenum[k] == 0:
c = 0
while n%primenum[k] == 0:
n //= primenum[k]
c += 1
lis.append([primenum[k], c])
else:
k += 1
if k > len(primenum)-1:
break
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
#print(factorization(N-1))
ans1 = 1
for k in range(len(list1)):
ans1*= list1[k][1]+1
ans1 -= 1
ans += ans1
#print(ans1)
def operation(K):
N = originalN
while N%K == 0:
N //= K
if N%K == 1:
return True
else:
return False
list2 = factorization(N)
#print(list2)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
#print(factorlist)
ans2 = 1
for item in factorlist:
if operation(item):
#print(item)
ans2 +=1
ans += ans2
#print(ans2)
print(ans)
|
N = int(eval(input()))
originalN = 0 +N
if N == 2:
print((1))
exit()
ans = 0
"""
primenum = [2]
count = [0 for _ in range(int(N**0.5)+2)]
for k in range(3, len(count), 2):
if count[k] == 0:
primenum.append(k)
for j in range(k, len(count), k):
count[j] = 1
def factorization(n):
lis = []
k = 0
while primenum[k] <= n:
if n%primenum[k] == 0:
c = 0
while n%primenum[k] == 0:
n //= primenum[k]
c += 1
lis.append([primenum[k], c])
else:
k += 1
if k > len(primenum)-1:
break
if n > 1:
lis.append([n, 1])
return lis
"""
def factorization(n):
lis = []
if n % 2 == 0:
c = 0
while n%2 == 0:
n //= 2
c += 1
lis.append([2, c])
k = 3
while k*k <= n:
if n%k == 0:
c = 0
while n%k == 0:
n //= k
c += 1
lis.append([k, c])
else:
k += 2
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
#print(factorization(N-1))
ans1 = 1
for k in range(len(list1)):
ans1*= list1[k][1]+1
ans1 -= 1
ans += ans1
#print(ans1)
def operation(K):
N = originalN
while N%K == 0:
N //= K
if N%K == 1:
return True
else:
return False
list2 = factorization(N)
#print(list2)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
#print(factorlist)
ans2 = 1
for item in factorlist:
if operation(item):
#print(item)
ans2 +=1
ans += ans2
#print(ans2)
print(ans)
|
p02722
|
N = int(eval(input()))
originalN = 0 +N
if N == 2:
print((1))
exit()
ans = 0
"""
primenum = [2]
count = [0 for _ in range(int(N**0.5)+2)]
for k in range(3, len(count), 2):
if count[k] == 0:
primenum.append(k)
for j in range(k, len(count), k):
count[j] = 1
def factorization(n):
lis = []
k = 0
while primenum[k] <= n:
if n%primenum[k] == 0:
c = 0
while n%primenum[k] == 0:
n //= primenum[k]
c += 1
lis.append([primenum[k], c])
else:
k += 1
if k > len(primenum)-1:
break
if n > 1:
lis.append([n, 1])
return lis
"""
def factorization(n):
lis = []
if n % 2 == 0:
c = 0
while n%2 == 0:
n //= 2
c += 1
lis.append([2, c])
k = 3
while k*k <= n:
if n%k == 0:
c = 0
while n%k == 0:
n //= k
c += 1
lis.append([k, c])
else:
k += 2
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
#print(factorization(N-1))
ans1 = 1
for k in range(len(list1)):
ans1*= list1[k][1]+1
ans1 -= 1
ans += ans1
#print(ans1)
def operation(K):
N = originalN
while N%K == 0:
N //= K
if N%K == 1:
return True
else:
return False
list2 = factorization(N)
#print(list2)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
#print(factorlist)
ans2 = 1
for item in factorlist:
if operation(item):
#print(item)
ans2 +=1
ans += ans2
#print(ans2)
print(ans)
|
N = int(eval(input()))
if N == 2:
print((1))
exit()
ans = 0
def factorization(n):
lis = []
if n % 2 == 0:
c = 0
while n%2 == 0:
n //= 2
c += 1
lis.append([2, c])
k = 3
while k*k <= n:
if n%k == 0:
c = 0
while n%k == 0:
n //= k
c += 1
lis.append([k, c])
else:
k += 2
if n > 1:
lis.append([n, 1])
return lis
list1 = factorization(N-1)
ans1 = 1
for k in range(len(list1)):
ans1 *= list1[k][1]+1
ans += ans1-1
def operation(K):
n = N
while n%K == 0:
n //= K
if n%K == 1:
return True
else:
return False
list2 = factorization(N)
factorlist = [1]
for l in range(len(list2)):
list3 = []
for j in range(list2[l][1]):
for k in range(len(factorlist)):
list3.append(factorlist[k]*list2[l][0]**(j+1))
factorlist += list3
factorlist = factorlist[1:-1]
ans += 1
for item in factorlist:
if operation(item):
ans +=1
print(ans)
|
p02722
|
import sys
sys.setrecursionlimit(10 ** 6)
n = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
ansl = list(set(make_divisors(n-1)))
ansl.remove(1)
import sys
sys.setrecursionlimit(10 ** 6)
def check(i, k):
if i == 1:
return True
if i < 1:
return False
if i % k == 0:
return check(i // k, k)
else:
return check(i - k, k)
ansl2 = []
for i in make_divisors(n):
if i == 1:
continue
elif i == 2:
ansl.append(2)
elif check(n, i):
ansl2.append(i)
print((len(set(ansl + ansl2))))
|
n = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
ansl = make_divisors(n-1)
ansl.remove(1)
for i in make_divisors(n):
if i == 1:
continue
k = n
while k:
if k % i == 0:
k //= i
else:
if k % i == 1:
ansl.append(i)
break
print((len(set(ansl))))
|
p02722
|
import sys,math,copy,queue,itertools,bisect
NI = lambda : int(sys.stdin.readline())
INF = 10**18
N = NI()
if N == 2:
print((1))
exit (0)
ans = 0
max_b = int(math.log(N,2))
for x in range(2,int(math.sqrt(N-1))+1):
if (N-1) % x == 0:
if (N-1) == x**2:
ans += 1
else:
ans += 2
for x in range(1, int(math.sqrt(N)) + 1):
if N % x == 0:
for b in range(1,max_b+1):
k = round(x**(1/b))
if k**b == x and k > 1:
if (N//x-1) % k == 0:
ans += 1
if x**2 != N:
x = N // x
k = round(x ** (1 / b))
if k ** b == x and k > 1:
if (N // x - 1) % k == 0:
ans += 1
print((ans+1))
|
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
NI = lambda : int(sys.stdin.readline())
N = NI()
max_i = int(math.log2(N))
div = []
for i in range(1,int(math.sqrt(N))+1):
if N % i == 0:
div.append((i,N//i)); div.append((N//i,i))
ans = 0
for a,b in div:
if a == 1:
for i in range(1,int(math.sqrt(b-1))+1):
if (b-1) % i == 0:
p = 2 - (i*i == b-1) - (i == 1)
ans += p
else:
for i in range(1,max_i+1):
c = round(math.pow(a,1/i))
if c ** i == a:
if b % c == 1: ans += 1
print(ans)
if __name__ == '__main__':
main()
|
p02722
|
N = int(eval(input()))
sqrt_N = int(N ** 0.5) + 1
dividers_for_N = [N]
ans_list = [N - 1]
for i in range(2, sqrt_N + 1):
if (N - 1) % i == 0:
ans_list.append(i)
ans_list.append((N - 1) // i)
if N % i == 0:
dividers_for_N.append(i)
dividers_for_N.append(N // i)
for i in dividers_for_N:
num = N
while num % i == 0:
num //= i
if num % i == 1:
ans_list.append(i)
ans = len(set(ans_list))
print(ans)
|
N = int(eval(input()))
sqrt_N = int(N ** 0.5)
dividers_for_N = set()
ans_set = set()
for i in range(1, sqrt_N + 1):
if (N - 1) % i == 0:
ans_set.add(i)
ans_set.add((N - 1) // i)
if N % i == 0:
dividers_for_N.add(i)
dividers_for_N.add(N // i)
dividers_for_N -= {1}
ans_set -= {1}
for i in dividers_for_N:
num = N
while num % i == 0:
num //= i
if num % i == 1:
ans_set.add(i)
ans = len(ans_set)
print(ans)
|
p02722
|
N = int(eval(input()))
sqrt_N = int(N ** 0.5)
dividers_for_N = set()
ans_set = set()
for i in range(1, sqrt_N + 1):
if (N - 1) % i == 0:
ans_set.add(i)
ans_set.add((N - 1) // i)
if N % i == 0:
dividers_for_N.add(i)
dividers_for_N.add(N // i)
dividers_for_N -= {1}
ans_set -= {1}
for i in dividers_for_N:
num = N
while num % i == 0:
num //= i
if num % i == 1:
ans_set.add(i)
ans = len(ans_set)
print(ans)
|
N = int(eval(input()))
sqrt_N = int(N ** 0.5)
dividers_for_N = []
ans_list = []
for i in range(1, sqrt_N + 1):
if (N - 1) % i == 0:
ans_list.append(i)
if i != (N - 1) // i:
ans_list.append((N - 1) // i)
if N % i == 0:
dividers_for_N.append(i)
if i != N // i:
dividers_for_N.append(N // i)
dividers_for_N.remove(1)
ans_list.remove(1)
for i in dividers_for_N:
num = N
while num % i == 0:
num //= i
if num % i == 1:
ans_list.append(i)
ans = len(ans_list)
print(ans)
|
p02722
|
from copy import deepcopy
# 約数を全列挙する関数
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors
N0 = int(eval(input()))
ans = 0
# N = K^a (bK + 1) と表現できるので K は N or N-1 の約数であることが必要
K_cand = set(make_divisors(N0) + make_divisors(N0-1))
for K in K_cand:
N = deepcopy(N0)
if K == 1: # K = 1 を除外
continue
else:
while N%K == 0:
N = N // K # 割れるだけ割る
N = N%K # 引けるだけ引く
if N == 1:
ans += 1
print(ans)
|
# 約数を全列挙する関数
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors
N0 = int(eval(input()))
ans = 0
# N = K^a (bK + 1) と表現できるので K は N or N-1 の約数であることが必要
K_cand = set(make_divisors(N0) + make_divisors(N0-1))
for K in K_cand:
N = N0
if K == 1: # K = 1 を除外
continue
else:
while N%K == 0:
N = N // K # 割れるだけ割る
N = N%K # 引けるだけ引く
if N == 1:
ans += 1
print(ans)
|
p02722
|
N=int(eval(input()))
if N==2:
print((1))
exit()
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
#N-1の約数(1は除く) Nそのもの
#2
d=make_divisors(N-1)
if not 2 in d:
d.append(2)
#print(d)
d2=make_divisors(N)
#print(len(d))
for i in d2:
if i!=N and i!=1 and i not in d:
now=N
while now%i==0:
now/=i
if now%i==1:
d.append(i)
print((len(d)))
|
N=int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
#print(make_divisors(3141))
#N, N-1, 2
#%*==1
ans=[2]
if N not in ans:
ans.append(N)
if (N%(N-1)!=0) and (N-1 not in ans):
ans.append(N-1)
D=make_divisors(N)
for d in D:
now=N
if d==1:
continue
while now%d==0:
now=now//d
if now%d==1:
if d not in ans:
ans.append(d)
#print(ans)
ans2=[]
for a in ans:
i=1
while a**i<=N:
x=a**i
now=N
while now%x==0:
now=now//x
if now%x==1:
if x not in ans2:
ans2.append(x)
i+=1
#print(ans2)
d2=make_divisors(N-1)
for d in d2:
if d!=1 and (d not in ans2):
ans2.append(d)
#print(ans2)
print((len(ans2)))
|
p02722
|
import sys
input = lambda: sys.stdin.readline().rstrip()
N = int(eval(input()))
div = []
ans = 0
for i in range(1, int(N**0.5)+1):
if N % i == 0:
div.append(i)
if i != N // i:
div.append(N//i)
for d in div:
if d == 1: continue
tmp = N
while tmp % d == 0:
tmp //= d
if tmp % d == 1:
ans += 1
div2 = []
for i in range(1, int((N-1)**0.5)+1):
if (N-1) % i == 0:
div2.append(i)
if i != (N-1) // i:
div2.append((N-1)//i)
print((ans + len(div2)-1))
|
import sys
input = lambda: sys.stdin.readline().rstrip()
N = int(eval(input()))
ans = 0
def divisor(x):
res = []
for i in range(1, int(x**0.5) + 1):
if x % i == 0:
if i != x//i:
res.append(i)
res.append(x//i)
else:
res.append(i)
return res[1:]
ans += len(divisor(N-1))
div_N = divisor(N)
for num in div_N:
tmp = N
while tmp % num == 0:
tmp //= num
if tmp == 1:
ans += 1
continue
if (tmp-1) % num == 0:
ans += 1
print(ans)
|
p02722
|
from math import sqrt
def f(x):
ret = []
for i in range(1, int(sqrt(x)) + 1):
if x % i == 0:
ret.append(i)
ret.append(x // i)
return ret
n = int(eval(input()))
ans = 1
for k in range(2, int(sqrt(n)) + 1):
r = n
while r % k == 0:
r //= k
if r % k == 1:
ans += 1
li = f(n - 1)
for e in li:
if e > int(sqrt(n)):
ans += 1
print(ans)
|
from math import sqrt
def divisors(x):
for i in range(1, int(sqrt(x)) + 1):
if x % i == 0:
yield i
if x // i != i:
yield x // i
n = int(eval(input()))
ans = 0
for e in divisors(n):
if e == 1:
continue
r = n
while r % e == 0:
r //= e
if r % e == 1:
ans += 1
ans += len(list(divisors(n - 1))) - 1
print(ans)
|
p02722
|
n = int(eval(input()))
def divisior(n):
a = []
i = 1
while (i*i <= n):
if n%i == 0:
a.append(i)
if (i*i != n): a.append(n//i)
i += 1
return a
ans = 0
a = divisior(n)
for x in a[1:]:
tmp = n
while (tmp%x == 0): tmp = tmp//x
if (tmp%x == 1) : ans += 1
b = divisior(n-1)
ans = ans + len(b) -1
print(ans)
|
n = int(eval(input()))
def divisior(n):
a = []
i = 1
while (i*i <= n):
if n%i == 0:
a.append(i)
if (i*i != n): a.append(n//i)
i += 1
return a
ans = 0
a = divisior(n)
for x in a:
if x == 1: continue
tmp = n
while (tmp%x == 0): tmp = tmp//x
if (tmp%x == 1) : ans += 1
b = divisior(n-1)
ans = ans + len(b) -1
print(ans)
|
p02722
|
N = int(eval(input()))
def check(p):
_N = N
while _N%p == 0:
_N //= p
return ((_N-1)%p == 0) or (_N == 1)
n = int(N**0.5) + 1
P0 = set([N])
P1 = set([N-1])
for i in range(2, n+1):
if (N-1)%i == 0:
P1.add(i)
P1.add((N-1)//i)
if N%i == 0:
P0.add(i)
P0.add(N//i)
ans = len(P1)
for p in P0:
ans += check(p)
print(ans)
|
N = int(eval(input()))
def check(p):
_N = N
while _N%p == 0:
_N //= p
return (_N-1)%p == 0
n = int(N**0.5) + 1
P0 = set([N])
P1 = set([N-1])
for i in range(2, n+1):
if (N-1)%i == 0:
P1.add(i)
P1.add((N-1)//i)
if N%i == 0:
P0.add(i)
P0.add(N//i)
P0.discard(1)
P1.discard(1)
ans = len(P1)
for p in P0:
ans += check(p)
print(ans)
|
p02722
|
N = int(eval(input()))
def check(p):
_N = N
while _N%p == 0:
_N //= p
return (_N-1)%p == 0
n = int(N**0.5) + 1
P0 = set([N])
P1 = set([N-1])
for i in range(2, n+1):
if (N-1)%i == 0:
P1.add(i)
P1.add((N-1)//i)
if N%i == 0:
P0.add(i)
P0.add(N//i)
P0.discard(1)
P1.discard(1)
ans = len(P1)
for p in P0:
ans += check(p)
print(ans)
|
def check(p):
_N = N
while _N%p == 0:
_N //= p
return (_N-1)%p == 0
def calc_divisors(n):
m = int(n**0.5)
left = []
right = []
for i in range(1, m+1):
if n%i == 0:
left.append(i)
right.append(n//i)
if left[-1] == right[-1]:
right.pop()
return left + right[::-1]
N = int(eval(input()))
P0 = calc_divisors(N)[1:] # [:1]で1を除外
P1 = calc_divisors(N-1)[1:] # 同上
ans = len(P1)
for p in P0:
ans += check(p)
print(ans)
|
p02722
|
# 1は除外
# ・N-1の約数は全て対象
# ・Nの約数で、sqrt(N)以下であればOK ただしN自身は対象
# これを足し合わせる
N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
# N-1の約数の個数
ans = len(make_divisors(N-1)) - 1
def check(n,x):
# xで割った余りがxの倍数でなくなるまでxで割る
# xの倍数でなくなったときにxで割って1余ればOK
while n % x == 0:
n //= x
return (n % x == 1)
# Nの約数で2以上sqrt(N)以下の数
for i in range(2,int(N ** 0.5) + 1):
if N % i == 0:
if check(N,i):
ans += 1
# N自身も対象
ans += 1
print(ans)
|
# 1は除外
# ・N-1の約数は全て対象
# ・Nの約数でsqrt(N)以下の数について、Nで割れなくなるまで割って、最後にあまりが1になればOK
# ・N自身は必ず対象
# これを足し合わせる
N = int(eval(input()))
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
# N-1の約数の個数
ans = len(make_divisors(N-1)) - 1
def check(n,x):
# xで割った余りがxの倍数でなくなるまでxで割る
# xの倍数でなくなったときにxで割って1余ればOK
while n % x == 0:
n //= x
return (n % x == 1)
# Nの約数で2以上sqrt(N)以下の数
for i in range(2,int(N ** 0.5) + 1):
if N % i == 0:
if check(N,i):
ans += 1
# N自身も対象
ans += 1
print(ans)
|
p02722
|
def make_divisors(n):
divisors = [n]
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors
def main():
N = int(eval(input()))
if N == 2:
print((1))
exit()
n = make_divisors(N)
m = make_divisors(N - 1)
answer = m[:]
cnt = len(answer)
for i in n:
tmp = N
while tmp % i == 0:
tmp //= i
if tmp % i == 1:
cnt += 1
answer.append(i)
answer.sort()
print(cnt)
if __name__ == '__main__':
main()
|
def make_divisors(n):
divisors = [n]
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors
def main():
N = int(eval(input()))
if N == 2:
print((1))
exit()
n = make_divisors(N)
m = make_divisors(N - 1)
cnt = len(m)
for i in n:
tmp = N
while tmp % i == 0:
tmp //= i
if tmp % i == 1:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
p02722
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def divisors(n):
lower = []
upper = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
lower.extend(reversed(upper))
return lower
def main():
N = int(readline())
D = divisors(N)
D1 = divisors(N - 1)
ans = len(D1) - 1
for d in D[1:]:
n = N
while n % d == 0:
n //= d
if (n - 1) % d == 0:
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def divisors(n):
lower = []
upper = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
lower.append(i)
if i != n // i:
upper.append(n // i)
lower.extend(reversed(upper))
return lower
def main():
N = int(readline())
D = divisors(N)
D1 = divisors(N - 1)
ans = len(D1) - 1
for d in D[1:]:
n = N
while n % d == 0:
n //= d
if n % d == 1:
ans += 1
print(ans)
return
if __name__ == '__main__':
main()
|
p02722
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def all_pattern(l):
global n
ans=0
for ds in make_divisors(l)[1:]:
k=n
while k%ds==0:
k//=ds
ans+=(k%ds==1 or k-k%ds==1)
return ans
n=int(eval(input()))
print((all_pattern(n)+all_pattern(n-1)))
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def all_pattern(l):
global n
ans=0
for ds in make_divisors(l)[1:]:
k=n
while k%ds==0:
k//=ds
ans+=(k%ds==1)
return ans
n=int(eval(input()))
print((all_pattern(n)+all_pattern(n-1)))
|
p02722
|
N = int(eval(input()))
def divisor(M):
div = set()
for i in range(1, int(N ** 0.5 + 0.5) + 1):
if M % i == 0:
div.add(i)
div.add(M // i)
return div
def simu(M, X):
cnt = 0
while M >= X:
if M % X == 0:
M //= X
elif M % X == 1:
return True
else:
M -= X
cnt += 1
if cnt > 1000:
return False
return M == 1
A = divisor(N)
B = divisor(N - 1)
# N%K==1となるやつ
ans = len(B) - 1
for a in (A - B):
if simu(N, a):
ans += 1
print(ans)
|
N = int(eval(input()))
def divisor(M):
div = set()
for i in range(1, int(N ** 0.5 + 0.5) + 1):
if M % i == 0:
div.add(i)
div.add(M // i)
return div
def simu(M, X):
while M % X == 0:
M //= X
return M % X == 1
B = divisor(N - 1)
ans = len(B) - 1
A = divisor(N)
A -= {1}
for a in A:
if simu(N, a):
ans += 1
print(ans)
|
p02722
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
AGC028 D
"""
import itertools
from functools import reduce
from functools import lru_cache
nn, k = list(map(int, input().split()))
n = 2*nn
abli = []
for i in range(k):
a, b = list(map(int, input().split()))
if a < b:
abli.append((a, b))
else:
abli.append((b, a))
flattenabli = itertools.chain.from_iterable(abli)
cut = 10**9+7
unused = [1 for i in range(n+1)]
for a in flattenabli:
unused[a] -= 1
unusedacum = list(itertools.accumulate(unused))
def modInverse(a, b, divmod=divmod):
r0, r1, s0, s1 = a, b, 1, 0
while r1 != 0:
q, rtmp = divmod(r0, r1)
stmp = s0-q*s1
r0, s0 = r1, s1
r1, s1 = rtmp, stmp
return s0 % cut
@lru_cache(maxsize=None)
def doubleFactorial(x):
return reduce(lambda y, z: y*z % cut, list(range(x, 0, -2)))
@lru_cache(maxsize=None)
def isSandwiched(i, j):
return any([abli[k][0] < i <= abli[k][1] <= j or i <= abli[k][0] <= j < abli[k][1] for k in range(k)])
nonSandwichedNums = [[] for i in range(n+1)]
for i in range(1, n+1):
for j in range(i+1, n+1):
if not isSandwiched(i, j):
nonSandwichedNums[i].append(j)
def numberUnderterminedBetween(i, j):
return unusedacum[j]-unusedacum[i-1]
def pairCombinations(x):
if x == 0:
return 1
elif x % 2 == 0:
return doubleFactorial(x-1)
else:
return 0
def g(i, j):
x = numberUnderterminedBetween(i, j)
return pairCombinations(x)
undetermined = numberUnderterminedBetween(1, n)
ggg = [[0]*(i+1) for i in range(n+1)]
for i in range(1, n+1):
for j in range(i+1, n+1):
ggg[i].append(g(i, j))
ans = 0
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(1, n+1):
for j in nonSandwichedNums[i]:
dp[i][j] = (ggg[i][j]-sum([dp[i][kk]*ggg[kk+1][j] for kk in nonSandwichedNums[i] if kk < j])) % cut
ans = (ans + dp[i][j]*pairCombinations(undetermined-numberUnderterminedBetween(i, j))) % cut
print(ans)
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
"""
AGC028 D
"""
import itertools
from functools import reduce
from functools import lru_cache
nn, k = list(map(int, input().split()))
n = 2*nn
abli = []
for i in range(k):
a, b = list(map(int, input().split()))
if a < b:
abli.append((a, b))
else:
abli.append((b, a))
flattenabli = itertools.chain.from_iterable(abli)
cut = 10**9+7
unused = [1 for i in range(n+1)]
for a in flattenabli:
unused[a] -= 1
unusedacum = list(itertools.accumulate(unused))
def modInverse(a, b, divmod=divmod):
r0, r1, s0, s1 = a, b, 1, 0
while r1 != 0:
q, rtmp = divmod(r0, r1)
stmp = s0-q*s1
r0, s0 = r1, s1
r1, s1 = rtmp, stmp
return s0 % cut
@lru_cache(maxsize=None)
def doubleFactorial(x):
return reduce(lambda y, z: y*z % cut, list(range(x, 0, -2)))
@lru_cache(maxsize=None)
def isSandwiched(i, j):
return any([abli[k][0] < i <= abli[k][1] <= j or i <= abli[k][0] <= j < abli[k][1] for k in range(k)])
nonSandwichedNums = [[] for i in range(n+1)]
for i in range(1, n+1):
for j in range(i+1, n+1):
if not isSandwiched(i, j):
nonSandwichedNums[i].append(j)
def numberUnderterminedBetween(i, j):
return unusedacum[j]-unusedacum[i-1]
def pairCombinations(x):
if x == 0:
return 1
elif x % 2 == 0:
return doubleFactorial(x-1)
else:
return 0
def g(i, j):
x = numberUnderterminedBetween(i, j)
return pairCombinations(x)
undetermined = numberUnderterminedBetween(1, n)
ggg = [[0]*(i+1) for i in range(n+1)]
for i in range(1, n+1):
for j in range(i+1, n+1):
ggg[i].append(g(i, j))
ans = 0
dp = [[0]*(n+1) for i in range(n+1)]
for i in range(1, n+1):
for j in nonSandwichedNums[i]:
gg = ggg[i][j]
if gg != 0:
dp[i][j] = (ggg[i][j]-sum([dp[i][kk]*ggg[kk+1][j] for kk in nonSandwichedNums[i] if kk < j])) % cut
else:
dp[i][j] = 0
ans = (ans + dp[i][j]*pairCombinations(undetermined-numberUnderterminedBetween(i, j))) % cut
print(ans)
|
p03234
|
n=int(eval(input()))
if n%2==0:
print(n)
else:
print((2*n))
|
N = int(eval(input()))
if N%2 == 0:
print(N)
else:
print((N*2))
|
p03307
|
n = int(input())
if n % 2 == 0:
print(n)
else:
print(n * 2)
|
n = int(input())
if n % 2 == 1:
print(n * 2)
else:
print(n)
|
p03307
|
# -*-coding=utf-8-*-
n = int(eval(input()))
if n%2:
n *= 2
print(n)
|
n=int(eval(input()))
if n%2==0:
print(n)
else:
print((n*2))
|
p03307
|
n = int(eval(input()))
if n % 2:
print((2 * n))
else:
print(n)
|
n = int(eval(input()))
if n % 2 == 0:
ans = n
else:
ans = 2*n
print(ans)
|
p03307
|
N = int(eval(input()))
if N%2 == 0:
print(N)
else:
print((2*N))
|
N = int(eval(input()))
print((2*N if N%2==1 else N))
|
p03307
|
import math
n = int(eval(input()))
print((2 // math.gcd(2, n) * n))
|
n = int(eval(input()))
if n % 2 == 0:
print(n)
else:
print((2 * n))
|
p03307
|
N=int(eval(input()))
#A1,A2,A3=map(int,input().split())
if N%2==0:
print(N)
else:
print((N*2))
|
N=int(eval(input()))
if N%2==0:
print(N)
else:
print((N*2))
|
p03307
|
n=int(eval(input()))
print((2*n if n%2 else n))
|
n=int(eval(input()))
print((n+n%2*n))
|
p03307
|
import math
n = int(eval(input()))
gcd = math.gcd(2, n)
lcm = 2 * n // gcd
print(lcm)
|
n = int(eval(input()))
if n % 2 == 0:
print(n)
else:
print((2 * n))
|
p03307
|
a=eval(input());print(a+a%2*a)
|
n=int(eval(input()))
print((n+n%2*n))
|
p03307
|
n = int(eval(input()))
print((n if n%2==0 else n*2))
|
n = int(eval(input()))
if n%2 ==0 :
print(n)
else:
print((n*2))
|
p03307
|
N = int(eval(input()))
if N%2 == 1:
print((N*2))
else:
print(N)
|
N = int(eval(input()))
print((N if N%2==0 else 2*N))
|
p03307
|
N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
def lcm(m, n):
return int((m * n) / gcd(m, n))
print((lcm(N,2)))
|
N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
def lcm(m, n):
print((m * n // gcd(m, n)))
lcm(N,2)
|
p03307
|
a = int(eval(input()))
if a%2 == 0:
print(a)
else:
print((a*2))
|
a = int(eval(input()))
if a%2 == 0:
print(a)
else:
print((2*a))
|
p03307
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.