input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(S):
M = Mod(10**9 + 7)
M13 = Mod(13)
t = [0] * 13
t[0] = 1
for i, c in enumerate(reversed(S)):
if c != '?':
n = M13.mul(M13.pow(10, i), int(c))
nt = [0] * 13
for k in range(13):
nt[(k+n) % 13] = t[k]
t = nt
else:
nt = [0] * 13
for j in range(10):
n = M13.mul(M13.pow(10, i), j)
for k in range(13):
nt[(k+n) % 13] = M.add(nt[(k+n) % 13], t[k])
t = nt
return t[5]
def main():
S = read_str()
print(slv(S))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(S):
M = Mod(10**9 + 7)
t = [0] * 13
t[0] = 1
m = 1
for i, c in enumerate(reversed(S)):
if c != '?':
n = (m * int(c)) % 13
nt = [0] * 13
for k in range(13):
nt[(k+n) % 13] = t[k]
t = nt
else:
nt = [0] * 13
for j in range(10):
n = (m * j) % 13
for k in range(13):
nt[(k+n) % 13] = M.add(nt[(k+n) % 13], t[k])
t = nt
m *= 10
m %= 13
return t[5]
def main():
S = read_str()
print(slv(S))
if __name__ == '__main__':
main()
| p02960 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
@mt
def slv(S):
mod = 10**9 + 7
t = [0] * 13
t[0] = 1
m = 1
for c in reversed(S):
nt = [0] * 13
if c != '?':
n = (m * int(c)) % 13
for k in range(13):
nt[(k+n) % 13] = t[k]
else:
for j in range(10):
n = (m * j) % 13
for k in range(13):
l = (k+n) % 13
nt[l] = (nt[l] + t[k]) % mod
t = nt
m *= 10
m %= 13
return t[5]
def main():
S = read_str()
# S = '?' * (10**5)
print(slv(S))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
@mt
def slv(S):
memo = [0] * 13
memo[0] = 1
mod = 10**9 + 7
for c in S:
nm = [0] * 13
if c == '?':
r = range(10)
else:
r = [int(c)]
for d in r:
for i in range(13):
nm[(i*10+d) % 13] += memo[i]
nm[(i*10+d) % 13] %= mod
memo = nm
return memo[5]
def main():
S = read_str()
print(slv(S))
if __name__ == '__main__':
main()
| p02960 |
# 17:02-17:26
MOD = pow(10,9)+7
S = input()[::-1]
N = len(S)
F = [0]*N
for i in range(N):
F[i] = pow(10,i,13)
D = [[[0]*13 for j in range(10)] for i in range(N)]
for i in range(N):
if S[i]=="?":
for j in range(10):
k = (F[i]*j)%13
if i==0:
D[i][j][k] = 1
else:
for l in range(10):
for m in range(13):
D[i][j][(m+k)%13] += D[i-1][l][m]
else:
j = int(S[i])
k = (F[i]*j)%13
if i==0:
D[i][j][k] = 1
else:
for l in range(10):
for m in range(13):
D[i][j][(m+k)%13] += D[i-1][l][m]
if i%1000==0:
for j in range(10):
for k in range(13):
D[i][j][k] = D[i][j][k]%MOD
ans = 0
for j in range(10):
ans += D[N-1][j][5]
print((ans%MOD)) | MOD = pow(10,9)+7
S = input()[::-1]
N = len(S)
DP = [[0]*13 for i in range(N)]
K = 1
for i in range(N):
if S[i]=="?":
for j in range(10):
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j*K+k)%13] += DP[i-1][k]%MOD
else:
j = int(S[i])*K
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j+k)%13] += DP[i-1][k]%MOD
K = (K*10)%13
print((DP[N-1][5]%MOD)) | p02960 |
MOD = pow(10,9)+7
S = input()[::-1]
N = len(S)
DP = [[0]*13 for i in range(N)]
K = 1
for i in range(N):
if S[i]=="?":
for j in range(10):
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j*K+k)%13] += DP[i-1][k]%MOD
else:
j = int(S[i])*K
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j+k)%13] += DP[i-1][k]%MOD
K = (K*10)%13
print((DP[N-1][5]%MOD)) | MOD = pow(10,9)+7
S = input()[::-1]
N = len(S)
DP = [[0]*13 for i in range(N)]
K = 1
for i in range(N):
if S[i]=="?":
for j in range(10):
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j*K+k)%13] += DP[i-1][k]
else:
j = int(S[i])*K
if i==0:
DP[0][(j*K)%13] = 1
else:
for k in range(13):
DP[i][(j+k)%13] += DP[i-1][k]
K = (K*10)%13
for j in range(13):
DP[i][j] = DP[i][j]%MOD
print((DP[N-1][5]%MOD)) | p02960 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class mint:
def __init__(self, x):
self.__x = x % md
def __str__(self):
return str(self.__x)
def __add__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x + other)
def __sub__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x - other)
def __rsub__(self, other):
return mint(other - self.__x)
def __mul__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * other)
__radd__ = __add__
__rmul__ = __mul__
def __truediv__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * pow(other, md - 2, md))
def __rtruediv__(self, other):
return mint(other * pow(self.__x, md - 2, md))
def __pow__(self, power, modulo=None):
return mint(pow(self.__x, power, md))
md = 10 ** 9 + 7
def main():
s = SI()
n = len(s)
dp = [[0] * 13 for _ in range(n + 1)]
# dp[i][m]...iケタ目までみたときに、余りがmになる数の個数
dp[0][0] = mint(1)
e10 = 1
for i, c in enumerate(s[::-1]):
for m in range(13):
pre = dp[i][m]
if pre == 0: continue
if c == "?":
for d in range(10):
nm = (m + d * e10) % 13
dp[i + 1][nm] += pre
else:
nm = (m + int(c) * e10) % 13
dp[i + 1][nm] += pre
e10 = e10 * 10
print(dp[n][5])
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class mint:
def __init__(self, x):
self.__x = x % md
def __str__(self):
return str(self.__x)
def __add__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x + other)
def __sub__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x - other)
def __rsub__(self, other):
return mint(other - self.__x)
def __mul__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * other)
__radd__ = __add__
__rmul__ = __mul__
def __truediv__(self, other):
if isinstance(other, mint): other = other.__x
return mint(self.__x * pow(other, md - 2, md))
def __rtruediv__(self, other):
return mint(other * pow(self.__x, md - 2, md))
def __pow__(self, power, modulo=None):
return mint(pow(self.__x, power, md))
md = 10 ** 9 + 7
def main():
s = SI()
n = len(s)
dp = [[0] * 13 for _ in range(n + 1)]
# dp[i][m]...iケタ目までみたときに、余りがmになる数の個数
dp[0][0] = mint(1)
e10 = 1
for i, c in enumerate(s[::-1]):
for m in range(13):
pre = dp[i][m]
if pre == 0: continue
if c == "?":
for d in range(10):
nm = (m + d * e10) % 13
dp[i + 1][nm] += pre
else:
nm = (m + int(c) * e10) % 13
dp[i + 1][nm] += pre
e10 = e10 * 10 % 13
print(dp[n][5])
main()
| p02960 |
import sys
sys.setrecursionlimit(4100000)
import logging
# logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
import re
def resolve():
S = sys.stdin.readline().split()[0]
logger.debug(S)
dp = [[0] * 13 for i in range(len(S))]
i = 0
if S[i] == '?':
for j in range(10):
r = 10**(len(S) - i - 1) * j
dp[i][r % 13] += 1
else:
r = 10**(len(S) - i - 1) * int(S[i])
dp[i][r % 13] = 1
len_S = len(S)
for i in range(1, len(S)):
order_r = (10**(len_S - i - 1)) % 13
if S[i] == '?':
for r in range(13):
dp[i-1][r] %= (10**9 + 7)
for j in range(10):
new_r = order_r * j + r
dp[i][new_r % 13] += dp[i-1][r]
else:
for r in range(13):
new_r = order_r * int(S[i]) + r
dp[i][new_r % 13] += dp[i-1][r] % (10**9 + 7)
print((dp[len(S)-1][5] % (10**9 + 7)))
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """??2??5"""
output = """768"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """?44"""
output = """1"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """7?4"""
output = """0"""
self.assertIO(input, output)
def test_入力例_4(self):
input = """?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???"""
output = """153716888"""
self.assertIO(input, output)
| import sys
sys.setrecursionlimit(4100000)
import logging
# logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
import re
# @profile
def resolve():
S = sys.stdin.readline().split()[0]
logger.debug(S)
dp = [[0] * 13 for i in range(len(S))]
i = 0
if S[i] == '?':
for j in range(10):
dp[i][j] += 1
else:
dp[i][int(S[i])] = 1
len_S = len(S)
for i in range(1, len(S)):
if S[i] == '?':
for r in range(13):
dp[i-1][r] %= (10**9 + 7)
for j in range(10):
new_r = j + r * 10
dp[i][new_r % 13] += dp[i-1][r]
else:
int_s = int(S[i])
for r in range(13):
new_r = int_s + r * 10
dp[i][new_r % 13] += dp[i-1][r] % (10**9 + 7)
print((dp[len(S)-1][5] % (10**9 + 7)))
if __name__ == "__main__":
resolve()
# AtCoder Unit Test で自動生成できる, 最後のunittest.main は消す
# python -m unittest template/template.py で実行できる
# pypy3 -m unittest template/template.py で実行できる
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """??2??5"""
output = """768"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """?44"""
output = """1"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """7?4"""
output = """0"""
self.assertIO(input, output)
def test_入力例_4(self):
input = """?6?42???8??2??06243????9??3???7258??5??7???????774????4?1??17???9?5?70???76???"""
output = """153716888"""
self.assertIO(input, output)
| p02960 |
def main():
s = input()[::-1]
mod = 10**9+7
dp = [[0 for j in range(13)] for i in range(len(s)+1)]
dp[0][0] = 1
ten = 1
for i in range(len(s)):
if s[i] == "?":
for k in range(10):
x = k*ten%13
for j in range(13):
dp[i+1][(j+x)%13] = (dp[i][j]+dp[i+1][(j+x)%13])%mod
else:
x = int(s[i])*ten%13
for j in range(13):
dp[i+1][(j+x)%13] += dp[i][j]%mod
ten *= 10%mod
print((dp[-1][5]%mod))
if __name__ == "__main__":
main() | def main():
s = input()[::-1]
mod = 10**9+7
dp = [[0 for j in range(13)] for i in range(len(s)+1)]
dp[0][0] = 1
ten = 1
for i in range(len(s)):
if s[i] == "?":
for k in range(10):
x = k*ten%13
for j in range(13):
dp[i+1][(j+x)%13] = (dp[i][j]+dp[i+1][(j+x)%13])%mod
else:
x = int(s[i])*ten%13
for j in range(13):
dp[i+1][(j+x)%13] = (dp[i][j]+dp[i+1][(j+x)%13])%mod
ten = (ten*10)%13
print((dp[-1][5]%mod))
if __name__ == "__main__":
main() | p02960 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
mod = 10**9+7
s = readline().rstrip().decode('utf-8')
dp = [0]*13 #あまりが0~12の13通りとなる場合の数
dp[0] = 1
dig = 1 #今見てる桁数
for i in range(len(s)-1,-1,-1): #小さい方の桁から見ていく
c = s[i]
next_dp = [0]*13 #逐次更新してはいけないので、次の桁の数についてjを回して入れていく
if c == "?": #?なら0~10の10通り全てについてあたる必要がある
for d in range(10):
for j in range(13):
next_dp[(d*dig + j)%13] += dp[j]
next_dp[(d*dig + j)%13] %= mod
else:
d = int(c)
for j in range(13):
next_dp[(d*dig + j)%13] += dp[j]
next_dp[(d*dig + j)%13] %= mod
dig *= 10
dp = next_dp
print((dp[5]%mod)) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
mod = 10**9+7
s = readline().rstrip().decode('utf-8')
dp = [0]*13 #あまりが0~12の13通りとなる場合の数
dp[0] = 1
dig = 1 #今見てる桁数
for i in range(len(s)-1,-1,-1): #小さい方の桁から見ていく
c = s[i]
next_dp = [0]*13 #逐次更新してはいけないので、次の桁の数についてjを回して入れていく
if c == "?": #?なら0~10の10通り全てについてあたる必要がある
for d in range(10):
for j in range(13):
next_dp[(d*dig + j)%13] += dp[j]
next_dp[(d*dig + j)%13] %= mod
else:
d = int(c)
for j in range(13):
next_dp[(d*dig + j)%13] += dp[j]
next_dp[(d*dig + j)%13] %= mod
dig *= 10
dig %= 13
dp = next_dp
print((dp[5]%mod)) | p02960 |
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
MOD = 10**9+7
def solve():
S = input()[:-1]
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
S = list(reversed(S))
for i in range(len(S)):
if S[i] == "?":
#dig = 10**i
dig = pow(10, i, 13)
for k in range(10):
for j in range(13):
# dp[i+1][j] += dp[i][(k*dig+j) % 13]
dp[i+1][(k*dig+j) % 13] += dp[i][j]
dp[i+1][(k*dig+j) % 13] %= MOD
pass
else:
dig = pow(10, i, 13)
#dig = 10**i
for j in range(13):
dp[i+1][(int(S[i])*dig+j) % 13] += dp[i][j]
#dp[i+1][j] = dp[i][(int(S[i])*dig+j) % 13]
dp[i+1][(int(S[i])*dig+j) % 13] %= MOD
ans = dp[-1][5]
print(ans)
solve()
| import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
MOD = 10**9+7
S = input()[:-1]
#dp[文字列をしたの桁からI番目まで見て][あまりがjになる数] = のこすう
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
# 文字列を逆順から見ていく
S = list(reversed(S))
for i in range(len(S)):
if S[i] == "?":
dig = pow(10, i, 13)
# ?だと新しく追加する数を10通り試す
for k in range(10): # 新しく追加する数
for j in range(13): # 各あまりからの遷移
dp[i+1][(k*dig+j) % 13] += dp[i][j]
dp[i+1][(k*dig+j) % 13] %= MOD
else:
dig = pow(10, i, 13)
#dig = 10**i
for j in range(13):
dp[i+1][(int(S[i])*dig+j) % 13] += dp[i][j]
dp[i+1][(int(S[i])*dig+j) % 13] %= MOD
print((dp[-1][5]))
| p02960 |
from sys import stdin, setrecursionlimit
def main():
mod = 10 ** 9 + 7
input = stdin.buffer.readline
s = list(input()[:-1].decode())
s.reverse()
n = len(s)
p10 = [0] * n
p10[0] = 1
for i in range(1, n):
p10[i] = 10 * p10[i - 1]
dp = [0] * 13
if s[0] == '?':
for i in range(10):
dp[i % 13] += 1
else:
dp[int(s[0]) % 13] += 1
for i in range(1, n):
tmp_dp = [0] * 13
if s[i] == '?':
for j in range(13):
for k in range(10):
index = (k * p10[i] + j) % 13
tmp_dp[index] += dp[j]
tmp_dp[index] %= mod
else:
for j in range(13):
index = (int(s[i]) * p10[i] + j) % 13
tmp_dp[index] += dp[j]
tmp_dp[index] %= mod
dp = tmp_dp
print((dp[5] % mod))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| from sys import stdin, setrecursionlimit
def main():
mod = 10 ** 9 + 7
input = stdin.buffer.readline
s = list(input()[:-1].decode())
n = len(s)
dp = [0] * 13
if s[0] == '?':
for i in range(10):
dp[i % 13] += 1
else:
dp[int(s[0]) % 13] += 1
for i in range(1, n):
tmp_dp = [0] * 13
if s[i] == '?':
for j in range(13):
for k in range(10):
index = (10 * j + k) % 13
tmp_dp[index] += dp[j]
tmp_dp[index] %= mod
else:
for j in range(13):
index = (10 * j + int(s[i])) % 13
tmp_dp[index] += dp[j]
tmp_dp[index] %= mod
dp = tmp_dp
print((dp[5] % mod))
if __name__ == "__main__":
setrecursionlimit(10000)
main()
| p02960 |
import sys,math,copy
# import numpy as np
input = sys.stdin.readline
S = ''.join(reversed(input().strip()))
# dp = np.zeros((13), dtype=int)
# dp_ = np.zeros((13), dtype=int)
dp = [0] * 13
dp_ = [0] * 13
mod13_list = [i % 13 for i in range(12 ** 2 + 1)]
list10 = list(range(10))
list13 = list(range(13))
divisor = 10 ** 9 + 7
dp_[0] = 1
mul = 1
for i in range(len(S)):
s = S[i]
if s == '?':
for d in list10:
m = mod13_list[(d * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] += dp_[pm]
else:
si = int(s)
m = mod13_list[(si * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] = dp_[pm]
# dp_ = dp % divisor
# dp = dp * 0 # np.zeros((13), dtype=int)
for j in list13:
dp_[j] = dp[j] % divisor
dp[j] = 0
mul = mod13_list[(mul * 10)]
print((dp_[5])) | import sys,math,copy
def main():
# import numpy as np
input = sys.stdin.readline
S = ''.join(reversed(input().strip()))
# dp = np.zeros((13), dtype=int)
# dp_ = np.zeros((13), dtype=int)
dp = [0] * 13
dp_ = [0] * 13
mod13_list = [i % 13 for i in range(12 ** 2 + 1)]
list10 = list(range(10))
list13 = list(range(13))
divisor = 10 ** 9 + 7
dp_[0] = 1
mul = 1
for i in range(len(S)):
s = S[i]
if s == '?':
for d in list10:
m = mod13_list[(d * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] += dp_[pm]
else:
si = int(s)
m = mod13_list[(si * mul)]
for pm in list13:
dp[mod13_list[(pm+m)]] = dp_[pm]
# dp_ = dp % divisor
# dp = dp * 0 # np.zeros((13), dtype=int)
for j in list13:
dp_[j] = dp[j] % divisor
dp[j] = 0
mul = mod13_list[(mul * 10)]
print((dp_[5]))
if __name__ == '__main__':
main() | p02960 |
N = input()[::-1]
iv = 1
MOD = 10**9+7
pdp = [0 for i in range(13)]
pdp[0]=1
dp = [0 for i in range(13)]
for i in range(len(N)):
x = N[i]
if x=='?':
for j in range(13):
for h in range(10):
dp[(h*iv+j)%13] += pdp[j]
for j in range(13):
pdp[j] = (dp[j]%MOD)
dp[j] = 0
else:
x = int(x)
for j in range(13):
dp[(j+x*iv)%13]+=pdp[j]
for j in range(13):
pdp[j] = (dp[j]%MOD)
dp[j]=0
iv *= 10
iv %= 13
print((pdp[5])) | N = input()[::-1]
iv = 1
MOD = 10**9+7
dp = [0 for i in range(13)]
dp[0]=1
ls = [0 for i in range(13)]
for i in range(len(N)):
x = N[i]
if x=='?':
for j in range(13):
for h in range(10):
ls[(h*iv+j)%13] += dp[j]
for j in range(13):
dp[j] = (ls[j]%MOD)
ls[j] = 0
else:
x = int(x)
for j in range(13):
ls[(j+x*iv)%13]+=dp[j]
for j in range(13):
dp[j] = (ls[j]%MOD)
ls[j]=0
iv *= 10
iv %= 13
print((dp[5]))
| p02960 |
N = input()[::-1]
iv = 1
MOD = 10**9+7
dp = [0]*13
dp[0]=1
ls = [0]*13
for i in range(len(N)):
x = N[i]
if x=='?':
for j in range(13):
for h in range(10):
ls[(h*iv+j)%13] += dp[j]
else:
x = int(x)
for j in range(13):
ls[(j+x*iv)%13]+=dp[j]
for j in range(13):
dp[j] = (ls[j]%MOD)
ls = [0]*13
iv *= 10
iv %= 13
print((dp[5])) | N = input()[::-1]
iv = 1
MOD = 10**9+7
dp = [0]*13
dp[0]=1
ls = [0]*13
for i in range(len(N)):
x = N[i]
if x=='?':
for j in range(13):
for h in range(10):
ls[(h*iv+j)%13] += dp[j]
else:
x = int(x)
for j in range(13):
ls[(j+x*iv)%13]+=dp[j]
for j in range(13):
dp[j] = (ls[j]%MOD)
ls[j]=0
iv *= 10
iv %= 13
print((dp[5])) | p02960 |
from sys import stdin
input = stdin.readline
def main():
S = input()[:-1]
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
for i in range(1, len(S)+1):
if S[i-1] == '?':
for s in range(10):
for j in range(13):
dp[i][(10*j + s) % 13] += dp[i-1][j]
else:
for j in range(13):
dp[i][(10*j + int(S[i-1])) % 13] += dp[i-1][j]
print((dp[len(S)][5] % 1_000_000_007))
if(__name__ == '__main__'):
main()
| from sys import stdin
input = stdin.readline
def main():
S = input()[:-1]
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
MOD = 1_000_000_007
for i in range(1, len(S)+1):
if S[i-1] == '?':
for s in range(10):
for j in range(13):
dp[i][(10*j + s) % 13] += (dp[i-1][j] % MOD)
else:
for j in range(13):
dp[i][(10*j + int(S[i-1])) % 13] += (dp[i-1][j] % MOD)
print((dp[len(S)][5] % MOD))
if(__name__ == '__main__'):
main()
| p02960 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
s = ns()
n = len(s)
class ModInt:
def __init__(self, n=0, mod=mod):
self.mod = mod
self.n = n % self.mod
def value(self):
return self.n
def __add__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n + rhs.n, self.mod)
return self.__class__(self.n + rhs, self.mod)
__radd__ = __add__
def __sub__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n - rhs.n, self.mod)
return self.__class__(self.n - rhs, self.mod)
def __rsub__(self, lhs):
if isinstance(lhs, ModInt):
return self.__class__(lhs.n - self.n, self.mod)
return self.__class__(lhs - self.n, self.mod)
def __mul__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n * rhs.n, self.mod)
return self.__class__(self.n * rhs, self.mod)
__rmul__ = __mul__
def __floordiv__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n // rhs.n, self.mod)
return self.__class__(self.n // rhs, self.mod)
def __rfloordiv__(self, lhs):
if isinstance(lhs, ModInt):
return self.__class__(lhs.n // self.n, self.mod)
return self.__class__(lhs // self.n, self.mod)
def __iadd__(self, rhs):
if isinstance(rhs, ModInt):
self.n += rhs.n
else:
self.n += rhs
if self.n >= self.mod:
self.n -= self.mod
return self
def __isub__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
if self.n < rhs_n:
self.n += self.mod
self.n -= rhs_n
return self
def __imul__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
self.n = self.n * rhs_n % self.mod
return self
def __ifloordiv__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
exp = self.mod - 2
while exp:
if exp % 2:
self *= rhs_n
rhs_n *= rhs_n
rhs_n %= self.mod
exp //= 2
return self
def __pow__(self, exp):
exp_n = exp.n if isinstance(exp, ModInt) else exp
if exp_n == 0:
return self.__class__(1, self.mod)
if exp_n % 2 == 0:
t = self.__pow__(exp_n // 2)
return t * t
return self * self.__pow__(exp_n - 1)
def __str__(self):
return str(self.n)
dp = [[0] * 13 for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
for j in range(13):
if s[i] != '?':
dig = int(s[i])
t = ModInt(10, mod=13)
t = t ** (n - i - 1)
t *= dig
t += j
ni = i + 1
nj = t.value()
dp[ni][nj] += dp[i][j]
dp[ni][nj] %= mod
else:
for k in range(10):
dig = k
t = ModInt(10, mod=13)
t = t ** (n - i - 1)
t *= dig
t += j
ni = i + 1
nj = t.value()
dp[ni][nj] += dp[i][j]
dp[ni][nj] %= mod
print((dp[n][5] % mod)) | import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
s = ns()
n = len(s)
class ModInt:
def __init__(self, n=0, mod=mod):
self.mod = mod
self.n = n % self.mod
def value(self):
return self.n
def __add__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n + rhs.n, self.mod)
return self.__class__(self.n + rhs, self.mod)
__radd__ = __add__
def __sub__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n - rhs.n, self.mod)
return self.__class__(self.n - rhs, self.mod)
def __rsub__(self, lhs):
if isinstance(lhs, ModInt):
return self.__class__(lhs.n - self.n, self.mod)
return self.__class__(lhs - self.n, self.mod)
def __mul__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n * rhs.n, self.mod)
return self.__class__(self.n * rhs, self.mod)
__rmul__ = __mul__
def __floordiv__(self, rhs):
if isinstance(rhs, ModInt):
return self.__class__(self.n // rhs.n, self.mod)
return self.__class__(self.n // rhs, self.mod)
def __rfloordiv__(self, lhs):
if isinstance(lhs, ModInt):
return self.__class__(lhs.n // self.n, self.mod)
return self.__class__(lhs // self.n, self.mod)
def __iadd__(self, rhs):
if isinstance(rhs, ModInt):
self.n += rhs.n
else:
self.n += rhs
if self.n >= self.mod:
self.n -= self.mod
return self
def __isub__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
if self.n < rhs_n:
self.n += self.mod
self.n -= rhs_n
return self
def __imul__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
self.n = self.n * rhs_n % self.mod
return self
def __ifloordiv__(self, rhs):
rhs_n = rhs.n if isinstance(rhs, ModInt) else rhs
exp = self.mod - 2
while exp:
if exp % 2:
self *= rhs_n
rhs_n *= rhs_n
rhs_n %= self.mod
exp //= 2
return self
def __pow__(self, exp):
exp_n = exp.n if isinstance(exp, ModInt) else exp
if exp_n == 0:
return self.__class__(1, self.mod)
if exp_n % 2 == 0:
t = self.__pow__(exp_n // 2)
return t * t
return self * self.__pow__(exp_n - 1)
def __str__(self):
return str(self.n)
dp = [[0] * 13 for _ in range(n + 1)]
dp[0][0] = 1
dp2 = [0] * (n + 7)
dp2[0] = 1
for i in range(n + 6):
dp2[i + 1] = dp2[i] * 10 % 13
for i in range(n):
for j in range(13):
if s[i] != '?':
dig = int(s[i])
t = dp2[n - i - 1] * dig + j
t %= 13
ni = i + 1
nj = t
dp[ni][nj] += dp[i][j]
dp[ni][nj] %= mod
else:
for k in range(10):
dig = k
t = dp2[n - i - 1] * dig + j
t %= 13
ni = i + 1
nj = t
dp[ni][nj] += dp[i][j]
dp[ni][nj] %= mod
print((dp[n][5] % mod)) | p02960 |
s = input().strip()
DIV = 10**9 + 7
digit = 1
log = []
for i, c in enumerate(reversed(s)):
if i == 0:
if c == '?':
log.append([int(t < 10) for t in range(13)])
else:
log.append([int(t == int(c)) for t in range(13)])
else:
log.append([0 for t in range(13)])
if c == '?':
for m in range(10):
shift = (m * digit) % 13
for mod, cnt in enumerate(log[i - 1]):
shifted = (mod + shift) % 13
log[i][shifted] = (log[i][shifted] + cnt)
else:
c = int(c)
shift = (c * digit) % 13
for mod, cnt in enumerate(log[i - 1]):
shifted = (mod + shift) % 13
log[i][shifted] = (log[i][shifted] + cnt)
digit = (digit * 10) % 13
print((log[len(s) - 1][5] % DIV)) | s = input().strip()
DIV = 10**9 + 7
digit = 1
log = []
for i, c in enumerate(reversed(s)):
if i == 0:
if c == '?':
log.append([int(t < 10) for t in range(13)])
else:
log.append([int(t == int(c)) for t in range(13)])
else:
log.append([0 for t in range(13)])
if c == '?':
for m in range(10):
shift = (m * digit) % 13
for mod, cnt in enumerate(log[i - 1]):
shifted = (mod + shift) % 13
log[i][shifted] = (log[i][shifted] + cnt)
else:
c = int(c)
shift = (c * digit) % 13
for mod, cnt in enumerate(log[i - 1]):
shifted = (mod + shift) % 13
log[i][shifted] = (log[i][shifted] + cnt)
log[i] = [v % DIV for v in log[i]]
digit = (digit * 10) % 13
print((log[len(s) - 1][5])) | p02960 |
import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def inpS(): return inp().rstrip().decode()
readlines = sys.stdin.buffer.readlines
MOD = 10**9+7
S = inpS()
N = len(S)
dp = [[0]*13 for _ in range(N+1)]
dp[0][0] = 1
for dgt in range(N):
for mo in range(13):
if S[dgt] == "?":
for nxt in range(10):
ind = (mo*10 + nxt) % 13
dp[dgt+1][ind] += dp[dgt][mo]
#dp[dgt+1][ind] %= MOD
else:
ind = (mo*10 + int(S[dgt])) % 13
dp[dgt+1][ind] += dp[dgt][mo]
#dp[dgt+1][ind] %= MOD
print((dp[N][5]%MOD)) | import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def inpS(): return inp().rstrip().decode()
readlines = sys.stdin.buffer.readlines
MOD = 10**9+7
S = inpS()
N = len(S)
dp = [0]*13
dp[0] = 1
mul = 1
for i in range(N-1, -1, -1):
nextDP = [0]*13
s = S[i]
if s == "?":
for dgt in range(10):
for mo in range(13):
ind = (dgt*mul+mo)%13
nextDP[ind] += dp[mo]
nextDP[ind] %= MOD
else:
dgt = int(S[i])
for mo in range(13):
ind = (dgt*mul+mo)%13
nextDP[ind] += dp[mo]
nextDP[ind] %= MOD
mul *= 10
mul %= 13
dp = nextDP
print((dp[5]))
| p02960 |
# -*- 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 ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
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
# やりやすさのため、小さい桁からいけるように逆順にしておく
S=input()[::-1]
N=len(S)
# dp[i][j] := 下からi桁を考えた時，13で割ったあまりがjであるものの数
dp=list2d(N+1, 13, 0)
dp[0][0]=1
for i in range(N):
for j in range(13):
# ?だったら0~9を全て遷移させる
if S[i]=='?':
for k in range(10):
# 桁を合わせる
nxt=k*pow(10, i, 13)
dp[i+1][(j+nxt)%13]+=dp[i][j]
dp[i+1][(j+nxt)%13]%=MOD
else:
# 決まっていたらその数字のみ遷移させる
nxt=int(S[i])*pow(10, i, 13)
dp[i+1][(j+nxt)%13]+=dp[i][j]
dp[i+1][(j+nxt)%13]%=MOD
# 最終的にN桁終わって余り5の数が答え
print((dp[N][5]))
| # -*- 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 ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
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
# やりやすさのため、小さい桁からいけるように逆順にしておく
S=input()[::-1]
N=len(S)
# dp[i][j] := 下からi桁を考えた時，13で割ったあまりがjであるものの数
dp=list2d(N+1, 13, 0)
dp[0][0]=1
mul=1
for i in range(N):
for j in range(13):
# ?だったら0~9を全て遷移させる
if S[i]=='?':
for k in range(10):
# 桁を合わせる
nxt=k*mul
dp[i+1][(j+nxt)%13]+=dp[i][j]
dp[i+1][(j+nxt)%13]%=MOD
else:
# 決まっていたらその数字のみ遷移させる
nxt=int(S[i])*mul
dp[i+1][(j+nxt)%13]+=dp[i][j]
dp[i+1][(j+nxt)%13]%=MOD
# 桁を合わせ用(10万桁とか直接使ったら死ぬので、毎回ここでMOD13する)
mul*=10
mul%=13
# 最終的にN桁終わって余り5の数が答え
print((dp[N][5]))
| p02960 |
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10 ** 9 + 7
S = sr()
# 桁DP, 上から
dp = [0] * 13
dp[0] = 1
for s in S:
prev = [x for x in dp]
num = s
dp = [0] * 13
if num != '?':
num = int(num)
for j in range(13):
dp[(10*j+num)%13] = prev[j]
else:
for j in range(13):
for k in range(10):
dp[(10*j+k)%13] += prev[j]
dp = [x%MOD for x in dp]
answer = dp[5]
print((answer%MOD))
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 10 ** 9 + 7
S = sr()
# 桁DP, 上から
dp = [0] * 13
dp[0] = 1
for s in S:
prev = [x for x in dp]
dp = [0] * 13
if s == '?':
loop = list(range(10))
else:
loop = [int(s)]
for j in range(13):
for lo in loop:
dp[(10*j+lo)%13] += prev[j]
dp = [x%MOD for x in dp]
answer = dp[5]
print((answer%MOD))
| p02960 |
import sys
input = sys.stdin.readline
mod = 10**9 + 7
s = input().rstrip()
n = len(s)
s = s[::-1]
dp = [[0]*13 for _ in range(n + 1)] # dp[i][j] : i桁目まで見て13で割ってj余る個数
dp[0][0] = 1
for i in range(n):
if s[i] != '?':
s_ = int(s[i]) * 10**i
for j in range(13):
dp[i + 1][(j + s_) % 13] += dp[i][j]
dp[i + 1][(j + s_) % 13] %= mod
else:
for j in range(13):
for k in range(10):
k *= 10**i
dp[i + 1][(j + k) % 13] += dp[i][j]
dp[i + 1][(j + k) % 13] %= mod
print((dp[-1][5]))
| import sys
input = sys.stdin.readline
mod = 10**9 + 7
s = input().rstrip()
n = len(s)
s = s[::-1]
dp = [[0]*13 for _ in range(n + 1)] # dp[i][j] : i桁目まで見て13で割ってj余る個数
dp[0][0] = 1
mul = 1
for i in range(n):
if i > 0:
mul *= 10
mul %= 13
if s[i] != '?':
s_ = int(s[i]) * mul
for j in range(13):
dp[i + 1][(j + s_) % 13] += dp[i][j]
dp[i + 1][(j + s_) % 13] %= mod
else:
for j in range(13):
for k in range(10):
k *= mul
dp[i + 1][(j + k) % 13] += dp[i][j]
dp[i + 1][(j + k) % 13] %= mod
print((dp[-1][5]))
| p02960 |
import sys
def main():
input = sys.stdin.readline
MOD = 10**9 + 7
S = list(str(input().strip()))
n = len(S)
dp = [[0] * 13 for _ in range(n)]
s = S.pop()
if s == '?':
for i in range(10):
dp[0][i] = 1
else:
s = int(s)
dp[0][s] = 1
digit = 1
m = 1
while S:
s = S.pop()
m = (m * 10) % 13
if s == '?':
for k in range(10):
M = (m * k) % 13
for i in range(13):
j = (i + M) % 13
dp[digit][j] += dp[digit-1][i]
dp[digit][j] %= MOD
else:
s = int(s)
M = (m * s) % 13
for i in range(13):
j = (i + M) % 13
dp[digit][j] += dp[digit-1][i]
dp[digit][j] %= MOD
digit += 1
return dp[n-1][5]
if __name__ == '__main__':
print((main()))
| import sys
def main():
input = sys.stdin.readline
MOD = 10**9 + 7
T = list(str(input().strip()))
S = [int(t) if t != '?' else -1 for t in T]
n = len(S)
dp = [[0] * 13 for _ in range(n)]
s = S.pop()
if s < 0:
for i in range(10):
dp[0][i] = 1
else:
dp[0][s] = 1
digit = 1
m = 1
while S:
s = S.pop()
m = (m * 10) % 13
if s < 0:
for k in range(10):
M = (m * k) % 13
for i in range(13):
j = (i + M) % 13
dp[digit][j] += dp[digit-1][i]
dp[digit][j] %= MOD
else:
M = (m * s) % 13
for i in range(13):
j = (i + M) % 13
dp[digit][j] += dp[digit-1][i]
dp[digit][j] %= MOD
digit += 1
return dp[n-1][5]
if __name__ == '__main__':
print((main()))
| p02960 |
s=input()[::-1]
if s[0]=="?":
p=[1]*10+[0]*3
else:
p=[0]*13
p[int(s[0])]=1
q=10
for i in s[1:]:
if i!="?":
i=int(i)
s=q*i%13
p=p[-s:]+p[:-s]
else:
d=[0]*13
for j in range(10):
s=q*j%13
r=p[-s:]+p[:-s]
d=[(r[i]+d[i])%(10**9+7)for i in range(13)]
p=d
q=(q*10)%13
print((p[5]%(10**9+7))) | s=input()[::-1]
p=[1]+[0]*12
q=1
t=[[(i*k)%13 for i in range(10)]for k in range(13)]
for i in s:
if i!="?":
i=int(i)
g=t[q][i]
p=p[-g:]+p[:-g]
else:
d=[0]*13
for j in t[q]:
r=p[-j:]+p[:-j]
d=[(r[i]+d[i])%(10**9+7)for i in range(13)]
p=d
q=(q*10)%13
print((p[5]%(10**9+7))) | p02960 |
S=input()
l=len(S)
dp=[ 0 for j in range(13) ]
dp[0]=1
mod=10**9+7
dp2=[ 0 for _ in range(13) ]
for i in range(1,l+1):
dp2=[0]*13
for j in range(13):
if dp[j]!=0:
if S[i-1]=="?":
for k in range(10):
next=(k*pow(10,l-i,13)+j)%13
dp2[next]+=dp[j]
dp2[next]%=mod
else:
k=int(S[i-1])
next=(k*pow(10,l-i,13)+j)%13
dp2[next]+=dp[j]
dp2[next]%=mod
dp=dp2
print(dp[5])
| S=input()
S=S[::-1]
l=len(S)
dp=[ 0 for j in range(13) ]
dp[0]=1
mod=10**9+7
dp2=[ 0 for _ in range(13) ]
keta=1
for i in range(1,l+1):
dp2=[0]*13
for j in range(13):
if dp[j]!=0:
if S[i-1]=="?":
for k in range(10):
next=(k*keta+j)%13
dp2[next]+=dp[j]
dp2[next]%=mod
else:
k=int(S[i-1])
next=(k*keta+j)%13
dp2[next]+=dp[j]
dp2[next]%=mod
dp=dp2
keta=(keta*10)%13
print(dp[5])
| p02960 |
# -*- coding: utf-8 -*-
import sys
S=sys.stdin.readline().strip()
N=len(S)
mod=10**9+7
dp=[ [ 0 for j in range(13) ] for i in range(N) ]
for i,x in enumerate(S[::-1]): #i桁目
if i==0:
if x!="?":
x=int(x)
dp[i][(x*pow(10,i,13))%13]=1
else:
for x in range(10):
dp[i][(x*pow(10,i,13))%13]=1
else:
if x!="?":
x=int(x)
for j in range(13):
dp[i][(x*pow(10,i,13)+j)%13]+=dp[i-1][j]
else:
for j in range(13):
for x in range(10):
dp[i][(x*pow(10,i,13)+j)%13]+=dp[i-1][j]
print(dp[N-1][5]%mod)
| # -*- coding: utf-8 -*-
import sys
S=sys.stdin.readline().strip()
N=len(S)
mod=10**9+7
dp=[ [ 0 for j in range(13) ] for i in range(N) ]
for i,x in enumerate(S[::-1]): #i桁目
if i==0:
if x!="?":
x=int(x)
dp[i][(x*pow(10,i,13))%13]=1
else:
for x in range(10):
dp[i][(x*pow(10,i,13))%13]=1
else:
if x!="?":
x=int(x)
for j in range(13):
n=(x*pow(10,i,13)+j)%13
dp[i][n]+=dp[i-1][j]
dp[i][n]%=mod
else:
for j in range(13):
for x in range(10):
n=(x*pow(10,i,13)+j)%13
dp[i][n]+=dp[i-1][j]
dp[i][n]%=mod
print(dp[N-1][5]%mod)
| p02960 |
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
S=sys.stdin.readline().strip()
N=len(S)
mod=10**9+7
S=S[::-1]
dp=defaultdict(lambda: 0)
for i,x in enumerate(S): #i桁目
if i==0:
if x!="?":
x=int(x)
dp[(i,(x*pow(10,i,13))%13)]=1
else:
for x in range(10):
dp[(i,(x*pow(10,i,13))%13)]=1
else:
if x!="?":
x=int(x)
for j in range(13):
n=(x*pow(10,i,13)+j)%13
dp[(i,n)]+=dp[(i-1,j)]
dp[(i,n)]%=mod
else:
for j in range(13):
for x in range(10):
n=(x*pow(10,i,13)+j)%13
dp[(i,n)]+=dp[(i-1,j)]%mod
dp[(i,n)]%=mod
print(dp[(N-1,5)]%mod)
| # -*- coding: utf-8 -*-
import sys
S=sys.stdin.readline().strip()
N=len(S)
mod=10**9+7
S=S[::-1]
dp=[ [ 0 for j in range(13) ] for i in range(N) ]
for i,x in enumerate(S): #i桁目
if i==0:
num=pow(10,i,13)
if x!="?":
x=int(x)
dp[i][(x*num)%13]=1
else:
for x in range(10):
dp[i][(x*num)%13]=1
else:
num=pow(10,i,13)
if x!="?":
x=int(x)
for j in range(13):
n=(x*num+j)%13
dp[i][n]+=dp[i-1][j]
dp[i][n]%=mod
else:
for j in range(13):
for x in range(10):
n=(x*num+j)%13
dp[i][n]+=dp[i-1][j]
dp[i][n]%=mod
print(dp[N-1][5]%mod)
| p02960 |
mo=10**9+7
t=input()[::-1]
dp=[0]*13
dp[0]=1
for d in range(len(t)):
p=[0]*13
if t[d]=='?':
for x in range(10):
r=int(x)*pow(10,d,13)
for i in range(13):
p[(i+r)%13]+=dp[i]
else:
r=int(t[d])*pow(10,d,13)
for i in range(13):
p[(i+r)%13]=dp[i]
dp=[j%mo for j in p]
print((dp[5]%mo))
| m=10**9+7
t=input()[::-1]
dp=[0]*13
dp[0]=1
for d in range(len(t)):
p=[0]*13
if t[d]=='?':
for x in range(10):
r=int(x)*pow(10,d,13)
for i in range(13):
p[(i+r)%13]+=dp[i]
else:
r=int(t[d])*pow(10,d,13)
for i in range(13):
p[(i+r)%13]=dp[i]
dp=[j%m for j in p]
print((dp[5]%m))
| p02960 |
z=10
m=z**9+7
k=13
t=input()[::-1]
dp=[0]*k
dp[0]=1
for d in range(len(t)):
p=[0]*k
f=(t[d]=='?')
for i in range(k):
for x in range(1+f*9):
r=pow(z,d,k)
r*=int(x if f else t[d])
p[(i+r)%k]+=dp[i]
dp=[j%m for j in p]
print((dp[5]%m))
| z=10
m=z**9+7
k=13
t=input()[::-1]
dp=[0]*k
dp[0]=1
for d in range(len(t)):
p=[0]*k
f=(t[d]=='?')
for i in range(k):
l=pow(z,d,k)
for x in range(1+f*9):
r=l*int(x if f else t[d])
p[(i+r)%k]+=dp[i]
dp=[j%m for j in p]
print((dp[5]%m))
| p02960 |
p = 10**9+7
def pow(x,m):
if m==0:
return 1
if m==1:
return x%13
if m%2==0:
return (pow(x,m//2)**2)%13
else:
return (x*(pow(x,(m-1)//2)**2)%13)%13
S = input().strip()
n = len(S)
A = [0 for _ in range(n)]
for i in range(n):
A[i] = pow(10,i)
dp = [[0 for _ in range(13)] for _ in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(13):
if S[i]!="?":
a = int(S[i])
b = (a*A[n-1-i])%13
dp[i+1][j] = dp[i][(j-b)%13]
else:
for k in range(10):
b = (k*A[n-1-i])%13
dp[i+1][j] = (dp[i+1][j]+dp[i][(j-b)%13])%p
print((dp[n][5])) | p = 10**9+7
S = input().strip()
n = len(S)
dp = [[0 for _ in range(13)] for _ in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(13):
if S[i]!="?":
dp[i+1][(10*j+int(S[i]))%13] = dp[i][j]
else:
for k in range(10):
dp[i+1][(10*j+k)%13] = (dp[i+1][(10*j+k)%13]+dp[i][j])%p
print((dp[n][5])) | p02960 |
p = 10**9+7
S = input().strip()
A = [[0 for k in range(13)] for j in range(13)]
for j in range(13):
for k in range(13):
for m in range(10):
if (10*k+m)%13==j:
A[j][k] = 1
break
B = [[0 for _ in range(10)] for _ in range(13)]
for j in range(13):
for m in range(10):
for k in range(13):
if (10*k+m)%13==j:
B[j][m] = k
break
N = len(S)
dp = [[0 for _ in range(13)] for _ in range(N+1)]
for j in range(13):
if S[0]!="?":
dp[1][j] = int(int(S[0])==j)
else:
if j<10:
dp[1][j] = 1
for i in range(2,N+1):
for j in range(13):
if S[i-1]!="?":
dp[i][j] = (dp[i][j]+dp[i-1][B[j][int(S[i-1])]])%p
else:
for k in range(13):
dp[i][j] = (dp[i][j]+dp[i-1][k]*A[j][k])%p
print((dp[N][5])) | p = 10**9+7
S = input().strip()
N = len(S)
dp = [[0 for _ in range(13)] for _ in range(N+1)]
for m in range(13):
dp[0][0] = 1
for i in range(1,N+1):
for m in range(13):
if S[i-1]=="?":
for j in range(10):
dp[i][(m*10+j)%13] = (dp[i][(m*10+j)%13]+dp[i-1][m])%p
else:
dp[i][(m*10+int(S[i-1]))%13] = (dp[i][(m*10+int(S[i-1]))%13]+dp[i-1][m])%p
print((dp[N][5])) | p02960 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
s = sys.stdin.readline()
n = len(s)-1
now = [0] * 13
now[0] = 1
for i in range(n)[::-1]:
prev = now[::]
now = [0] * 13
c = n - i - 1#桁
if s[i] == '?':
for k in range(10):
l = (k*10**c) % 13
for j in range(13):
now[(j+l)%13] += prev[j]
now[(j+l)%13] = now[(j+l)%13] % mod
else:
l = (int(s[i])*10**c) % 13
for j in range(13):
now[(j+l)%13] = prev[j]
now[(j+l)%13] = now[(j+l)%13] % mod
# print(now)
print((now[5]))
| from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools
sys.setrecursionlimit(10**8)
mod = 10**9+7
mod2 = 998244353
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
s = sys.stdin.readline()
n = len(s)-1
now = [0] * 13
now[0] = 1
for i in range(n)[::-1]:
prev = now[::]
now = [0] * 13
c = n - i - 1#桁
m = pow(10,c,13)
if s[i] == '?':
for k in range(10):
l = (m*k) % 13
for j in range(13):
now[(j+l)%13] += prev[j]
now[(j+l)%13] = now[(j+l)%13] % mod
else:
k = int(s[i])
l = (m*k) % 13
for j in range(13):
now[(j+l)%13] = prev[j]
# print(now)
print((now[5]))
| p02960 |
#coding utf-8
S=list(input().strip())
S=[0]+S
mod=10**9+7
dp=[[0 for i in range(13)] for j in range(len(S)+1)]
dp[0][0]=1
for i in range(len(S)):
if S[i]=="?":
for j in range(13):
for k in range(10):
dp[i+1][(j*10+k)%13]+=dp[i][j]%mod
else:
for j in range(13):
dp[i+1][(j*10+int(S[i]))%13]+=dp[i][j]%mod
print((dp[-1][5]%mod))
| #coding utf-8
S=list(input().strip())
S=[0]+S
l=len(S)
mod=10**9+7
dp=[[0 for i in range(13)] for j in range(l+1)]
dp[0][0]=1
for i in range(l):
if S[i]=="?":
for j in range(13):
for k in range(10):
dp[i+1][(j*10+k)%13]+=dp[i][j]%mod
else:
for j in range(13):
dp[i+1][(j*10+int(S[i]))%13]+=dp[i][j]%mod
print((dp[-1][5]%mod))
| p02960 |
MOD = 10**9 + 7
def main():
s = open(0).read()[:-1][::-1]
n = len(s)
prev = [0] * 13
if s[0] == '?':
for j in range(10):
prev[j] = 1
else:
prev[int(s[0])] = 1
mod13 = [1, 10, 9, 12, 3, 4]
for i, cur_s in enumerate(s[1:], start=1):
next = [0] * 13
if cur_s == '?':
for j in range(10):
remain = j * mod13[i % 6] % 13
for k in range(13):
next[(k + remain) % 13] += prev[k]
else:
remain = int(cur_s) * mod13[i % 6] % 13
for k in range(13):
next[(k + remain) % 13] += prev[k]
prev = [cur_next % MOD for cur_next in next]
ans = prev[5] % MOD
print(ans)
return()
if __name__ == '__main__':
main()
| MOD = 10**9 + 7
def main():
s = [int(in_i) if in_i != '?' else -1 for in_i in list(open(0).read())[:-1]]
n = len(s)
cnt = [0] * 13
if s[0] == -1:
for j in range(10):
cnt[j] = 1
else:
cnt[s[0]] = 1
for cur_s in s[1:]:
dp = [0] * 26
for i in range(13):
dp[i*10%13] = cnt[i] % MOD
dp[13:] = dp[:13]
if cur_s == -1:
for i in range(13):
cnt[i] = sum(dp[i+4:i+14])
else:
for i in range(13):
cnt[i] = dp[i+13-cur_s]
ans = cnt[5] % MOD
print(ans)
return()
if __name__ == '__main__':
main()
| p02960 |
import sys,math,collections,itertools
input = sys.stdin.readline
s = input().rstrip()[::-1]
DP=[0 for _ in range(13)]
DP[0]=1
m = 10**9+7
mul = 1
for i in range(len(s)):
dig = s[i]
nextDP = [0 for _ in range(13)]
if dig == '?':
for j in range(10):
for k in range(13):
nextDP[(k+mul*j)%13] += DP[k]
nextDP[(k+mul*j)%13]%=m
else:
j = int(dig)
for k in range(13):
nextDP[(k+mul*j)%13] += DP[k]
nextDP[(k+mul*j)%13]%=m
mul *= 10
DP = nextDP
print((DP[5]%m))
| import sys,math,collections,itertools
input = sys.stdin.readline
s = input().rstrip()[::-1]
DP=[0 for _ in range(13)]
DP[0]=1
m = 10**9+7
mul = 1
for i in range(len(s)):
dig = s[i]
nextDP = [0 for _ in range(13)]
if dig == '?':
for j in range(10):
for k in range(13):
nextDP[(k+mul*j)%13] += DP[k]
nextDP[(k+mul*j)%13]%=m
else:
j = int(dig)
for k in range(13):
nextDP[(k+mul*j)%13] += DP[k]
nextDP[(k+mul*j)%13]%=m
mul *= 10
mul%=13
DP = nextDP
print((DP[5]%m))
| p02960 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
S = readline().rstrip()
S = S[::-1]
dp = [0]*13
dp[0] = 1
for i,s in enumerate(S):
dpnew = [0]*13
if s != '?':
k = int(s)
for j in range(13):
dpnew[(k*(10**i)+j)%13] = (dpnew[(k*(10**i)+j)%13]+dp[j])%mod
else:
for k in range(10):
for j in range(13):
dpnew[(k*(10**i)+j)%13] = (dpnew[(k*(10**i)+j)%13]+dp[j])%mod
dp = dpnew
print((dp[5]))
| import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
S = readline().rstrip()
S = S[::-1]
dp = [0]*13
dp[0] = 1
for i,s in enumerate(S):
dpnew = [0]*13
pow10 = pow(10,i,13)
if s != '?':
k = int(s)
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
else:
for k in range(10):
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
dp = dpnew
print((dp[5]))
| p02960 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
S = readline().rstrip()
S = S[::-1]
dp = [0]*13
dp[0] = 1
pow10 = 4
for i,s in enumerate(S):
dpnew = [0]*13
pow10 = pow10*10%13
if s != '?':
k = int(s)
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
else:
for k in range(10):
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
dp = dpnew
print((dp[5]))
| import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
S = readline().rstrip()
S = S[::-1]
dp = [0]*13
dp[0] = 1
pow10 = 4
for i,s in enumerate(S):
dpnew = [0]*13
pow10 = (pow10*10)%13
if s != '?':
k = int(s)
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
else:
for k in range(10):
for j in range(13):
dpnew[(k*pow10+j)%13] = (dpnew[(k*pow10+j)%13]+dp[j])%mod
dp = dpnew
print((dp[5]))
| p02960 |
M = 10 ** 9 + 7
s = input().strip()
num = 0
q_list = []
d = 1
l = len(s)
for i in range(l - 1, -1, -1):
c = s[i]
if c != "?":
num = (num + int(c) * d) % 13
else:
q_list.append(d)
d *= 10
counts = [0] * 13
counts[0] = 1
for d in q_list:
new_counts = [0] * 13
for n in range(10):
r = (d * n) % 13
for m in range(13):
k = (r + m) % 13
new_counts[k] = (new_counts[k] + counts[m]) % M
counts = new_counts
print((counts[(13 + 5 - num) % 13]))
| M = 10 ** 9 + 7
s = input().strip()
num = 0
q_list = []
d = 1
l = len(s)
for i in range(l - 1, -1, -1):
c = s[i]
if c != "?":
num = (num + int(c) * d) % 13
else:
q_list.append(d)
d = (d * 10) % 13
counts = [0] * 13
counts[0] = 1
for d in q_list:
new_counts = [0] * 13
for n in range(10):
r = (d * n) % 13
for m in range(13):
k = (r + m) % 13
new_counts[k] = (new_counts[k] + counts[m]) % M
counts = new_counts
print((counts[(13 + 5 - num) % 13]))
| p02960 |
def slove():
import sys
input = sys.stdin.readline
s = [int(v) if v != "?" else -1 for v in list(str(input().rstrip('\n')))]
dp = [[0] * 13 for _ in range(2)]
mod = 10 ** 9 + 7
for i in range(1):
if s[-i-1] == -1:
for j in range(10):
dp[0][j % 13] += 1
else:
dp[0][s[-i - 1] % 13] += 1
for i in range(1, len(s)):
if s[-i-1] == -1:
for j in range(10):
for k in range(13):
dp[1][(pow(10, i, 13) * j + k) % 13] += dp[0][k]
else:
for k in range(13):
dp[1][(pow(10, i, 13) * s[-i-1] + k) % 13] += dp[0][k]
for j in range(13):
dp[0][j] = dp[1][j] % mod
dp[1][j] = 0
print((dp[0][5] % mod))
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
s = [int(v) if v != "?" else -1 for v in list(str(input().rstrip('\n')))]
dp = [[0] * 13 for _ in range(2)]
mod = 10 ** 9 + 7
for i in range(1):
if s[-i-1] == -1:
for j in range(10):
dp[0][j % 13] += 1
else:
dp[0][s[-i - 1] % 13] += 1
for i in range(1, len(s)):
m = pow(10, i, 13)
if s[-i-1] == -1:
for j in range(10):
mj = m * j
for k in range(13):
dp[1][(mj + k) % 13] += dp[0][k]
else:
for k in range(13):
dp[1][(m * s[-i-1] + k) % 13] += dp[0][k]
for j in range(13):
dp[0][j] = dp[1][j] % mod
dp[1][j] = 0
print((dp[0][5] % mod))
if __name__ == '__main__':
slove()
| p02960 |
def slove():
import sys
input = sys.stdin.readline
s = str(input().rstrip('\n'))
is_first = True
ls = [[0] * 13 for _ in range(len(s))]
mod = 10 ** 9 + 7
for i in range(len(s)):
if is_first:
is_first = False
if s[-i-1] == "?":
for j in range(10):
ls[i][j] += 1
else:
t = int(s[-i-1])
ls[i][t] += 1
else:
mlt = pow(10, i)
if s[-i-1] == "?":
for j in range(13):
for k in range(10):
r = (j + mlt * k) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
else:
t = int(s[-i-1])
for j in range(13):
r = (j + mlt * t) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
print((ls[-1][5]))
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
s = str(input().rstrip('\n'))
is_first = True
ls = [[0] * 13 for _ in range(len(s))]
mod = 10 ** 9 + 7
for i in range(len(s)):
if is_first:
is_first = False
if s[-i-1] == "?":
for j in range(10):
ls[i][j] += 1
else:
t = int(s[-i-1])
ls[i][t] += 1
else:
mlt = pow(10, i, 13)
if s[-i-1] == "?":
for j in range(13):
for k in range(10):
r = (j + mlt * k) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
else:
t = int(s[-i-1])
for j in range(13):
r = (j + mlt * t) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
print((ls[-1][5]))
if __name__ == '__main__':
slove()
| p02960 |
def slove():
import sys
input = sys.stdin.readline
s = str(input().rstrip('\n'))
is_first = True
ls = [[0] * 13 for _ in range(len(s))]
mod = 10 ** 9 + 7
for i in range(len(s)):
if is_first:
is_first = False
if s[-i-1] == "?":
for j in range(10):
ls[i][j] += 1
else:
t = int(s[-i-1])
ls[i][t] += 1
else:
mlt = pow(10, i, 13)
if s[-i-1] == "?":
for j in range(13):
for k in range(10):
r = (j + mlt * k) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
else:
t = int(s[-i-1])
for j in range(13):
r = (j + mlt * t) % 13
ls[i][r] += ls[i-1][j]
ls[i][r] %= mod
print((ls[-1][5]))
if __name__ == '__main__':
slove()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
s = str(input().rstrip('\n'))
ls = [[0] * 13 for _ in range(len(s))]
for i in range(len(s)):
if i == 0:
if s[-i-1] == "?":
for j in range(10):
ls[i][j] += 1
else:
ls[i][int(s[-i-1])] += 1
else:
mult = pow(10, i, 13)
if s[-i-1] == "?":
for j in range(13):
for k in range(10):
ls[i][(k * mult + j) % 13] += ls[i-1][j]
else:
st = int(s[-i-1])
for j in range(13):
ls[i][(st * mult + j) % 13] += ls[i-1][j]
for j in range(13):
ls[i][j] = ls[i][j] % mod
print((ls[-1][5]))
if __name__ == '__main__':
solve()
| p02960 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
dp = [[0] * 13 for _ in range(len(s))]
for i in range(len(s)):
ts = s[-i-1]
if i == 0:
if ts == "?":
for j in range(10):
dp[i][j] += 1
else:
dp[i][int(ts)] += 1
else:
mult = pow(10, i, 13)
if ts == "?":
for j in range(13):
for k in range(10):
dp[i][(k * mult + j) % 13] += dp[i-1][j]
else:
num = int(ts)
for j in range(13):
dp[i][(num * mult + j) % 13] += dp[i-1][j]
for j in range(13):
dp[i][j] %= mod
print((dp[-1][5] % mod))
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
dp = [[0] * 13 for _ in range(len(s))]
for i in range(len(s)):
if i == 0:
if s[-i-1] == "?":
for j in range(10):
dp[i][j % 13] += 1
else:
t = int(s[-i-1])
dp[i][t % 13] += 1
else:
md = pow(10, i, 13)
if s[-i-1] == "?":
for j in range(10):
for k in range(13):
dp[i][(j * md + k) % 13] += dp[i-1][k]
else:
t = int(s[-i-1])
for k in range(13):
dp[i][(t * md + k) % 13] += dp[i - 1][k]
for l in range(13):
dp[i][l] %= mod
print((dp[-1][5]))
if __name__ == '__main__':
solve()
| p02960 |
s=input()[::-1]
mod=10**9+7
if s[0]=='?':
dp=[[1]*10]
for _ in range(3):
dp[0].append(0)
else:
dp=[[0]*13]
dp[0][int(s[0])]=1
dp.append([0]*13)
now=1
for i in range(1,len(s)):
now=now*10
x=s[i]
if x!='?':
x=(now*int(x))%13
for j in range(13):
dp[i%2][(j+x)%13]=dp[i%2-1][j]
else:
for j in range(10):
x=(now*j)%13
for k in range(13):
if j==0:
dp[i%2][k]=dp[i%2-1][k]
else:
dp[i%2][(k+x)%13]+=dp[i%2-1][k]
dp[i%2][(k+x)%13]=dp[i%2][(k+x)%13]%mod
print((dp[len(s)%2-1][5]%mod)) | s=input()[::-1]
mod=10**9+7
dp=[[0]*13 for i in range(len(s))]
if s[0]=='?':
for i in range(10):
dp[0][i]=1
else:
dp[0][int(s[0])]=1
now=1
for i in range(1,len(s)):
now=(now*10)%13
x=s[i]
if x!='?':
x=now*int(x)
for j in range(13):
dp[i][(j+x)%13]=dp[i-1][j]
else:
for j in range(10):
x=now*j
for k in range(13):
dp[i][(k+x)%13]+=dp[i-1][k]
dp[i][(k+x)%13]=dp[i][(k+x)%13]%mod
print((dp[-1][5]%mod)) | p02960 |
def inpl(): return list(map(int, input().split()))
MOD = 10**9 + 7
S = input()[::-1]
x = 1
DP = [0]*13
DP[0] = 1
for i in range(len(S)):
DP2 = [0]*13
if S[i] != "?":
s = int(S[i])
for i in range(13):
DP2[(i + s*x)%13] = DP[i]%MOD
else:
for j in range(10):
for i in range(13):
DP2[(i + j*x)%13] = (DP2[(i + j*x)%13] + DP[i])%MOD
x *= 10
DP = DP2
print((DP[5]%MOD)) | def inpl(): return list(map(int, input().split()))
MOD = 10**9 + 7
S = input()[::-1]
x = 1
DP = [0]*13
DP[0] = 1
for i in range(len(S)):
DP2 = [0]*13
if S[i] != "?":
s = int(S[i])
for i in range(13):
DP2[(i + s*x)%13] = DP[i]%MOD
else:
for j in range(10):
for i in range(13):
DP2[(i + j*x)%13] = (DP2[(i + j*x)%13] + DP[i])%MOD
x = x*10%13
DP = DP2
print((DP[5]%MOD)) | p02960 |
S = input().strip()
mod = 10**9 + 7
d = {i:i*10%13 for i in range(13)}
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
for i, c in enumerate(S, 1):
if c != '?':
c = int(c)
for j in range(13):
dp[i][(d[j] + c) % 13] = dp[i-1][j] % mod
else:
for c in range(10):
for j in range(13):
k = (d[j] + c) % 13
dp[i][k] = (dp[i][k] + dp[i-1][j]) % mod
print((dp[-1][5])) | S = input().strip()
mod = 10**9 + 7
d = [i*10%13 for i in range(13)]
dp = [[0]*13 for _ in range(len(S)+1)]
dp[0][0] = 1
for i, c in enumerate(S, 1):
if c != '?':
c = int(c)
for j in range(13):
dp[i][(d[j] + c) % 13] = dp[i-1][j]
else:
for c in range(10):
for j in range(13):
k = (d[j] + c) % 13
dp[i][k] += dp[i-1][j]
for j in range(13):
dp[i][j] %= mod
print((dp[-1][5])) | p02960 |
import sys
if sys.platform =='ios':
sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return [int(s) for s in input().split()]
S = input().rstrip()
dp = [[0] * 13 for _ in range(len(S)+1)]
dp[0][0] = 1
#print(dp)
for i in range(len(S)):
for j in range(13):
if S[i]=='?':
for d in range(10):
nj = (j*10+d)%13
dp[i+1][nj] += dp[i][j]
else:
nj = (j*10+int(S[i]))%13
dp[i+1][nj] += dp[i][j]
#print(dp)
print(((dp[len(S)][5])%(10**9+7))) | import sys
if sys.platform =='ios':
sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(eval(input()))
def MAP(): return [int(s) for s in input().split()]
S = input().rstrip()
dp = [[0] * 13 for _ in range(len(S)+1)]
dp[0][0] = 1
#print(dp)
for i in range(len(S)):
for j in range(13):
if S[i]=='?':
for d in range(10):
nj = (j*10+d)%13
dp[i+1][nj] += dp[i][j]
else:
nj = (j*10+int(S[i]))%13
dp[i+1][nj] += dp[i][j]
for j in range(13):
dp[i+1][j] %= (10**9+7)
#print(dp)
print((dp[len(S)][5])) | p02960 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
mod = 10**9 + 7
s = input().rstrip()
n = len(s)
dp = [[0]*13 for _ in range(n)]
if s[-1]=='?':
for i in range(10):
dp[0][i] = 1
else:
a = int(s[-1])
dp[0][a] = 1
for i in range(1, n):
if s[-(i+1)] == '?':
for j in range(10):
a = (10**i) * j % 13
for k in range(13):
dp[i][(a+k)%13] += dp[i-1][k]
dp[i][(a+k)%13] %= mod
else:
a = int(s[-(i+1)])
a = (10**i) * a % 13
for k in range(13):
dp[i][(a+k)%13] += dp[i-1][k]
dp[i][(a+k)%13] %= mod
print((dp[-1][5]))
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
mod = 10**9 + 7
s = input().rstrip()
n = len(s)
dp = [[0]*13 for _ in range(n)]
if s[-1]=='?':
for i in range(10):
dp[0][i] = 1
else:
a = int(s[-1])
dp[0][a] = 1
a = 1
for i in range(1, n):
a = 10 * a % 13
if s[-(i+1)] == '?':
for j in range(10):
for k in range(13):
dp[i][(a*j+k)%13] += dp[i-1][k] % mod
else:
j = int(s[-(i+1)])
for k in range(13):
dp[i][(a*j+k)%13] += dp[i-1][k] % mod
print((dp[-1][5]%mod))
if __name__ == '__main__':
main() | p02960 |
import sys
S = sys.stdin.readline()[:-1]
l = len(S)
# S = S[::-1]
S = list(reversed(S))
dp =[[0 ] * 13 for _ in range(l + 1)]
kurai = 1
MOD = (10 ** 9) + 7
dp[0][0] = 1
for keta in range(len(S)):
c =S[keta]
if c == "?":
for j in range(0,10):
kurai %= 13
temp = (j * kurai) % 13
for i in range(13):
dp[keta + 1][(temp + i) % 13] += (dp[keta][i] )
dp[keta + 1][(temp + i) % 13] %= MOD
else:
temp = (int(c) * kurai) % 13
for i in range(13):
dp[keta + 1][(temp + i) % 13] += (dp[keta][i] )
dp[keta + 1][(temp + i) % 13] %= MOD
kurai *= 10
keta %= MOD
print((dp[-1][5] ))
|
import sys
S = sys.stdin.readline()[:-1]
l = len(S)
# S = S[::-1]
S = list(reversed(S))
dp =[[0 ] * 13 for _ in range(l + 1)]
kurai = 1
MOD = (10 ** 9) + 7
dp[0][0] = 1
for keta in range(len(S)):
c =S[keta]
if c == "?":
for j in range(0,10):
kurai %= 13
temp = (j * kurai) % 13
for i in range(13):
dp[keta + 1][(temp + i) % 13] += (dp[keta][i] )
dp[keta + 1][(temp + i) % 13] %= MOD
else:
kurai %= 13
temp = (int(c) * kurai) % 13
for i in range(13):
dp[keta + 1][(temp + i) % 13] += (dp[keta][i] )
dp[keta + 1][(temp + i) % 13] %= MOD
kurai *= 10
keta %= MOD
print((dp[-1][5] ))
| p02960 |
import sys
input = sys.stdin.readline
P = 10 ** 9 + 7
Q = 13
def main():
S = input().rstrip()
N = len(S)
dp = [[0] * Q for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
base = pow(10, N - 1 - i, Q)
D = S[i]
if D == "?":
for d in range(10):
n = d * base
for j in range(Q):
next_j = (j + n) % Q
dp[i + 1][next_j] += dp[i][j]
dp[i + 1][next_j] %= P
else:
n = int(D) * base
for j in range(Q):
next_j = (j + n) % Q
dp[i + 1][(j + n) % Q] += dp[i][j]
dp[i + 1][(j + n) % Q] %= P
ans = dp[N][5]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
P = 10 ** 9 + 7
Q = 13
def main():
S = input().rstrip()
N = len(S)
dp = [[0] * Q for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
D = S[i]
if D == "?":
for d in range(10):
for j in range(Q):
dp[i + 1][(10 * j + d) % Q] += dp[i][j]
else:
d = int(D)
for j in range(Q):
dp[i + 1][(10 * j + d) % Q] += dp[i][j]
for j in range(Q):
dp[i + 1][j] %= P
ans = dp[N][5]
print(ans)
if __name__ == "__main__":
main()
| p02960 |
import sys
readline = sys.stdin.readline
conv = {}
for i in range(13):
conv[i] = (i * 10) % 13
S = readline().rstrip()
N = len(S)
DIV = 10 ** 9 + 7
dp = [[0] * 13 for i in range(N)]
x0 = S[0]
if x0 == "?":
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(x0)] = 1
for i in range(1, N):
x = S[i]
if x == "?":
for j in range(13):
for k in range(10):
dp[i][(conv[j] + k) % 13] += dp[i - 1][j]
dp[i][(conv[j] + k) % 13] %= DIV
else:
for j in range(13):
dp[i][(conv[j] + int(x)) % 13] += dp[i - 1][j]
dp[i][(conv[j] + int(x)) % 13] %= DIV
print((dp[-1][5])) | import sys
readline = sys.stdin.readline
S = readline().rstrip()
N = len(S)
DIV = 10 ** 9 + 7
dp = [[0] * 13 for i in range(N)]
x0 = S[0]
if x0 == "?":
for i in range(10):
dp[0][i] = 1
else:
dp[0][int(x0)] = 1
for i in range(1, N):
x = S[i]
if x == "?":
for j in range(13):
for k in range(10):
ind = (j * 10 + k) % 13
dp[i][ind] += dp[i - 1][j]
dp[i][ind] %= DIV
else:
for j in range(13):
ind = (j * 10 + int(x)) % 13
dp[i][ind] += dp[i - 1][j]
dp[i][ind] %= DIV
print((dp[-1][5]))
| p02960 |
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
S = inputStr()
S_len = len(S)
DP = [[0 for j in range(13)] for i in range(S_len)]
S = S[::-1]
for i,val in enumerate(S):
if i == 0:
if val == "?":
for j in range(0,10):
DP[i][j] += 1
else:
DP[i][int(val)] += 1
else:
if val == "?":
for j in range(0,10):
tmp = (pow(10, i) * j) % 13
for v,vol in enumerate(DP[i-1]):
if vol == 0:
continue
tmptmp = (v + tmp) % 13
DP[i][tmptmp] = (DP[i][tmptmp] + vol) % mod
else:
tmp = (pow(10, i) * int(val)) % 13
for j,vol in enumerate(DP[i-1]):
if vol == 0:
continue
tmptmp = (j + tmp) % 13
DP[i][tmptmp] = (DP[i][tmptmp] + vol) % mod
#print(DP)
print((DP[S_len-1][5] % mod))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
from decimal import *
##### リストの 二分木検索 #####
# bisect_left(lists, 3)
# bisect_right(lists, 3)
##### プライオリティキュー #####
# heapq.heapify(a) #リストaのheap化
# heapq.heappush(a,x) #heap化されたリストaに要素xを追加
# heapq.heappop(a) #heap化されたリストaから最小値を削除＆その最小値を出力
# heapq.heappush(a, -x) #最大値を取り出す時は、pushする時にマイナスにして入れよう
# heapq.heappop(a) * (-1) #取り出す時は、-1を掛けて取り出すこと
##### タプルリストのソート #####
# sorted(ans) #(a, b) -> 1st : aの昇順, 2nd : bの昇順
# sorted(SP, key=lambda x:(x[0],-x[1])) #(a, b) -> 1st : aの昇順, 2nd : bの降順
# sorted(SP, key=lambda x:(-x[0],x[1])) #(a, b) -> 1st : aの降順, 2nd : bの昇順
# sorted(SP, key=lambda x:(-x[0],-x[1])) #(a, b) -> 1st : aの降順, 2nd : bの降順
# sorted(SP, key=lambda x:(x[1])) #(a, b) -> 1st : bの昇順
# sorted(SP, key=lambda x:(-x[1])) #(a, b) -> 1st : bの降順
##### 累乗 #####
# pow(x, y, z) -> x**y % z
##### 割り算の切り上げ #####
# tmp = -(-4 // 3)
##### dict の for文 #####
# for k, v in d.items():
# print(k, v)
def inputInt(): return int(eval(input()))
def inputMap(): return list(map(int, input().split()))
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]
inf = float('inf')
mod = 1000000007
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
def main():
S = inputStr()
S_len = len(S)
DP = [[0 for j in range(13)] for i in range(S_len)]
S = S[::-1]
mut = 10
for i,val in enumerate(S):
if i == 0:
if val == "?":
for j in range(0,10):
DP[i][j] += 1
else:
DP[i][int(val)] += 1
else:
if val == "?":
for j in range(0,10):
tmp = (mut * j) % 13
for v,vol in enumerate(DP[i-1]):
if vol == 0:
continue
tmptmp = (v + tmp) % 13
DP[i][tmptmp] = (DP[i][tmptmp] + vol) % mod
else:
tmp = (mut * int(val)) % 13
for j,vol in enumerate(DP[i-1]):
if vol == 0:
continue
tmptmp = (j + tmp) % 13
DP[i][tmptmp] = (DP[i][tmptmp] + vol) % mod
mut = (mut * 10) % 13
#print(DP)
print((DP[S_len-1][5] % mod))
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# N 個のボールを K グループに分ける場合のパターン数
def sunuke(N, K, mod=10**9+7):
if N < K or K-1 < 0:
return 0
else:
return combination(N-1, K-1, mod)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
# mを法とするaの乗法的逆元
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def egcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
# nHr mod m
# 問題によって、combination()を切り替えること
def H(n, r, mod=10**9+7):
# comb = Combination(n+r-1, mod)
# return comb(n+r-1, r)
return combination(n+r-1, r, mod)
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
# dfs のサンプル
def dfs(graph,parent,counter,edge):
stk = []
stk.append(edge)
while len(stk) > 0:
p = stk.pop()
for e in graph[p]:
if parent[p] == e:
continue
else:
parent[e] = p
counter[e] += counter[p]
stk.append(e)
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
#-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
if __name__ == "__main__":
main()
| p02960 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
def main():
S = readline().rstrip()
N = 13
dp = [0] * 13 # dp[k]: 13で割った余りがkのパターン数
dp[0] = 1
mul = 1
for i in range(len(S)-1, -1, -1):
next_dp = [0] * N
s = S[i]
if s == '?':
for k in range(10):
for j in range(N):
next_dp[(k * mul + j) % N] += dp[j]
next_dp[(k * mul + j) % N] %= MOD
else:
k = int(s)
for j in range(N):
next_dp[(k * mul + j) % N] += dp[j]
next_dp[(k * mul + j) % N] %= MOD
mul *= 10
mul %= N
dp = next_dp
print((dp[5]))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
def main():
S = readline().rstrip()
N = 13
dp = [0] * 13 # dp[k]: 13で割った余りがkのパターン数
dp[0] = 1
mul = 1
for s in S[::-1]:
next_dp = [0] * N
if s == '?':
for k in range(10):
for j in range(N):
next_dp[(k * mul + j) % N] += dp[j]
next_dp[(k * mul + j) % N] %= MOD
else:
k = int(s)
for j in range(N):
next_dp[(k * mul + j) % N] += dp[j]
next_dp[(k * mul + j) % N] %= MOD
mul *= 10
mul %= N
dp = next_dp
print((dp[5]))
if __name__ == '__main__':
main() | p02960 |
import sys,heapq,math,resource
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
DBG = True # and False
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def setrlim():
sys.setrecursionlimit(250000)
soft,hard = resource.getrlimit(RLIMIT_STACK)
# setrlimit works on ubuntu (and atcoder), but not on WSL
#resource.setrlimit(RLIMIT_STACK, (128*1024*1024,hard))
rem = [1,10,9,12,3,4]
s = input().strip()
sr = s[::-1]
n = len(s)
dp = [ [0]*13 for i in range(n) ]
if sr[0]=='?':
for j in range(10):
dp[0][j] = 1
else:
j = int(sr[0])
dp[0][j] = 1
for i in range(1,n):
r = rem[i%6]
if sr[i]=='?':
for j in range(10):
for k in range(13):
dp[i][(k+j*r)%13] = (dp[i][(k+j*r)%13] + dp[i-1][k])%R
else:
j = int(sr[i])
for k in range(13):
dp[i][(k+j*r)%13] = (dp[i][(k+j*r)%13] + dp[i-1][k])%R
print((dp[n-1][5]))
| #printn = lambda x: sys.stdout.write(x)
inn = lambda : int(eval(input()))
inl = lambda: list(map(int, input().split()))
inm = lambda: list(map(int, input().split()))
DBG = True # and False
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
rem = [1,10,9,12,3,4]
s = input().strip()
sr = s[::-1]
n = len(s)
dp = [ [0]*13 for i in range(n) ]
if sr[0]=='?':
for j in range(10):
dp[0][j] = 1
else:
j = int(sr[0])
dp[0][j] = 1
for i in range(1,n):
r = rem[i%6]
if sr[i]=='?':
for j in range(10):
for k in range(13):
dp[i][(k+j*r)%13] = (dp[i][(k+j*r)%13] + dp[i-1][k])%R
else:
j = int(sr[i])
for k in range(13):
dp[i][(k+j*r)%13] = (dp[i][(k+j*r)%13] + dp[i-1][k])%R
print((dp[n-1][5]))
| p02960 |
s = list(input().rstrip())
n = len(s)
dp = [[0] * 13 for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
c = -1 if s[i] == '?' else int(s[i])
for j in range(10):
if c != -1 and c != j:
continue
for ki in range(13):
dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki]
print((dp[n][5] % (10**9 + 7)))
| s = list(input().rstrip())
n = len(s)
dp = [[0] * 13 for _ in range(n + 1)]
dp[0][0] = 1
for i in range(n):
c = -1 if s[i] == '?' else int(s[i])
for j in range(10):
if c != -1 and c != j:
continue
for ki in range(13):
dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki]
for j in range(13):
dp[i + 1][j] %= 10 ** 9 + 7
print((dp[n][5]))
| p02960 |
from sys import exit, stderr, stdin
input = stdin.readline
# setrecursionlimit(10**7)
# def debug(var, name="hoge"):
# print(name +":" + str(type(var)) + " = " + repr(var), file=stderr)
# return
def main():
MOD = 10**9 + 7
S = list(input()[:-1])
L = len(S)
modsum = 0
# 余り
memo_prev = [0 for _ in range(13)]
memo_prev[0] = 1
memo = [0 for _ in range(13)]
for i in range(L):
memo = [0 for _ in range(13)]
# 数字なら以前までの余りにたす
if S[i].isnumeric():
for m in range(13):
cur = (10*m+int(S[i]))%13
memo[cur] += memo_prev[m]
# ?なら1~10の余りのケース全てをためす
else:
for n in range(10):
for m in range(13):
cur = (10*m+n)%13
memo[cur] += memo_prev[m]
memo[cur] %= MOD
memo_prev = memo.copy()
print((memo[5]))
if __name__ == "__main__":
main()
| from sys import exit, stderr, stdin
input = stdin.readline
def main():
MOD = 10**9 + 7
S = input()[:-1]
L = len(S)
# 余り
memo = [0 for _ in range(13)]
memo[0] = 1
for i in range(L):
memo_prev = [x for x in memo]
memo = [0 for _ in range(13)]
# 数字なら以前までの余りにたす
if S[i].isnumeric():
n = int(S[i])
for m in range(13):
cur = (10*m+n)%13
memo[cur] += memo_prev[m]
# ?なら1~10の余りのケース全てをためす
else:
for n in range(10):
for m in range(13):
cur = (10*m+n)%13
memo[cur] += memo_prev[m]
for m in range(13):
memo[m] %= MOD
print((memo[5]))
if __name__ == "__main__":
main()
| p02960 |
mod=10**9+7
s=input()[::-1]
l=len(s)
dp=[[0]*13 for i in range(l+1)]
dp[0][0]=1
for i in range(l):
s_sub=s[i]
if s_sub=="?":
for j in range(13):
for k in range(10):
dp[i+1][(j+k*(10**i))%13]+=dp[i][j]
dp[i+1][(j+k*(10**i))%13]%=mod
else:
k=int(s_sub)
for j in range(13):
dp[i+1][(j+k*(10**i))%13]+=dp[i][j]
dp[i+1][(j+k*(10**i))%13]%=mod
print((dp[l][5]%mod))
| mod=10**9+7
s=input()[::-1]
l=len(s)
dp=[[0]*13 for i in range(l+1)]
dp[0][0]=1
#累乗が大きすぎるので前計算
p=[0]*l
p[0]=1
for i in range(l-1):
p[i+1]=(p[i]*10)%13
for i in range(l):
s_sub=s[i]
if s_sub=="?":
for j in range(13):
for k in range(10):
dp[i+1][(j+k*p[i])%13]+=dp[i][j]
dp[i+1][(j+k*p[i])%13]%=mod
else:
k=int(s_sub)
for j in range(13):
dp[i+1][(j+k*p[i])%13]+=dp[i][j]
dp[i+1][(j+k*p[i])%13]%=mod
print((dp[l][5])) | p02960 |
n=int(eval(input()));a,b,c,p=1,1,n,n-1
for i in range(n-1):
p+=a-1;a,b,c=b,c,((n-1)**2+p+c)%(10**9+7)
print(c) | n=int(eval(input()))-1;a,b,c,p=1,1,n+1,n
for _ in[0]*n:p+=a-1;a,b,c=b,c,(n*n+p+c)%(10**9+7)
print(c) | p03766 |
for _ in range(int(eval(input()))):
p,q=list(map(int,input().split()))
c=0
for i in range(143):
for j in range(143):
if (i>0 or j>0)and(j*p+i*q)%(j*j+i*i)==0 and (j*q-i*p)%(j*j+i*i)==0:c+=1
print(('P' if c<5 else 'C')) | for _ in range(int(eval(input()))):
p,q=list(map(int,input().split()))
c=0
for i in range(142):
for j in range(142):
if (i>0 or j>0)and(j*p+i*q)%(j*j+i*i)==0 and (j*q-i*p)%(j*j+i*i)==0:c+=1
print(('P' if c<5 else 'C')) | p00904 |
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
H, W = list(map(int, readline().split()))
S = [0 for i in range(H)]
for i in range(H):
S[i] = readline().decode().strip()
from collections import deque
def bfs(start, H, W):
visited = [False] * (H * W)
q = deque([])
q.append((start[0], start[1], 0))
max_dist = 0
while q:
(i, j, dist) = q.popleft()
max_dist = max(dist, max_dist)
visited[i * W + j] = True
for dy in range(-1, 2):
for dx in range(-1, 2):
if dx * dy != 0 or dx == dy:
continue
if i + dy < 0 or i + dy >= H or j + dx < 0 or j + dx >= W:
continue
if S[i + dy][j + dx] == '#':
continue
if visited[(i + dy) * W + j + dx]:
continue
q.append((i + dy, j + dx, dist + 1))
return max_dist
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
start = (i, j)
ans = max(ans, bfs(start, H, W))
print(ans)
| import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
H, W = list(map(int, readline().split()))
S = [0 for i in range(H)]
for i in range(H):
S[i] = readline().decode().strip()
from collections import deque
def bfs(start, H, W):
INF = 10 ** 9
dist = [INF] * (H * W)
q = deque([start])
dist[start[0] * W + start[1]] = 0
while q:
(i, j) = q.popleft()
d = dist[i * W + j]
for dy in range(-1, 2):
for dx in range(-1, 2):
if dx * dy != 0:
continue
if dx == dy:
continue
if i + dy < 0 or i + dy >= H or j + dx < 0 or j + dx >= W:
continue
if S[i + dy][j + dx] == '#':
continue
if dist[(i + dy) * W + j + dx] != INF:
continue
dist[(i + dy) * W + j + dx] = d + 1
q.append((i + dy, j + dx))
return max(x for x in dist if x < INF)
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
start = (i, j)
ans = max(ans, bfs(start, H, W))
print(ans)
| p02803 |
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
H, W = list(map(int, readline().split()))
S = [0 for i in range(H)]
for i in range(H):
S[i] = readline().decode().strip()
from collections import deque
def bfs(start, H, W):
INF = 10 ** 9
visited = [False] * (H * W)
q = deque([(start[0], start[1], 0)])
max_d = 0
while q:
(i, j, d) = q.popleft()
max_d = max(max_d, d)
visited[i * W + j] = True
for dy in range(-1, 2):
for dx in range(-1, 2):
if dx * dy != 0:
continue
if dx == dy:
continue
if i + dy < 0 or i + dy >= H or j + dx < 0 or j + dx >= W:
continue
if S[i + dy][j + dx] == '#':
continue
if visited[(i + dy) * W + j + dx]:
continue
q.append((i + dy, j + dx, d + 1))
return max_d
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
start = (i, j)
ans = max(ans, bfs(start, H, W))
print(ans)
| import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import reduce
# from math import *
from fractions import *
H, W = list(map(int, readline().split()))
S = [0 for i in range(H)]
for i in range(H):
S[i] = readline().decode().strip()
from collections import deque
def bfs(start, H, W):
INF = 10 ** 9
dist = [INF] * (H * W)
q = deque([start])
dist[start[0] * W + start[1]] = 0
max_d = 0
while q:
(i, j) = q.popleft()
d = dist[i * W + j]
max_d = max(d, max_d)
for dy in range(-1, 2):
for dx in range(-1, 2):
if dx * dy != 0:
continue
if dx == dy:
continue
if i + dy < 0 or i + dy >= H or j + dx < 0 or j + dx >= W:
continue
if S[i + dy][j + dx] == '#':
continue
if dist[(i + dy) * W + j + dx] != INF:
continue
dist[(i + dy) * W + j + dx] = d + 1
q.append((i + dy, j + dx))
return max_d
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
start = (i, j)
ans = max(ans, bfs(start, H, W))
print(ans) | p02803 |
from itertools import product
def solve(string):
h, w, *s = string.split()
h, w = list(map(int, [h, w]))
s = ["#" * (w + 2)] + ["#" + _s + "#" for _s in s] + ["#" * (w + 2)]
ans = 0
d = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for _h, _w in product(list(range(1, h + 1)), list(range(1, w + 1))):
if s[_h][_w] == "#":
continue
q = list()
for x, y in d:
if s[_h + x][_w + y] == ".":
q.append((_h + x, _w + y, _h, _w))
if len(q) > 2:
continue
c = [[h * w] * (w + 2) for _ in range(h + 2)]
c[_h][_w] = 0
while q:
cx, cy, px, py = q.pop()
if c[px][py] + 1 >= c[cx][cy]:
continue
c[cx][cy] = c[px][py] + 1
for x, y in d:
if s[cx + x][cy + y] == ".":
q.append((cx + x, cy + y, cx, cy))
ans = max(
ans,
*(c[i][j] * (s[i][j] == ".") for i, j in product(list(range(1, h + 1)), list(range(1, w + 1)))))
return str(ans)
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from itertools import product
def solve(string):
h, w, *s = string.split()
h, w = list(map(int, [h, w]))
s = ["#" * (w + 2)] + ["#" + _s + "#" for _s in s] + ["#" * (w + 2)]
ans = 0
d = [(1, 0), (-1, 0), (0, 1), (0, -1)]
for _h, _w in product(list(range(1, h + 1)), list(range(1, w + 1))):
if s[_h][_w] == "#":
continue
q = list()
for x, y in d:
if s[_h + x][_w + y] == ".":
q.append((_h + x, _w + y, _h, _w))
if len(q) > 2:
continue
c = [[h * w] * (w + 2) for _ in range(h + 2)]
c[_h][_w] = 0
while q:
cx, cy, px, py = q.pop()
if c[px][py] + 1 >= c[cx][cy]:
continue
c[cx][cy] = c[px][py] + 1
for x, y in d:
if s[cx + x][cy + y] == ".":
q.append((cx + x, cy + y, cx, cy))
for i, j in product(list(range(1, h + 1)), list(range(1, w + 1))):
ans = max(ans, c[i][j] * (s[i][j] == "."))
return str(ans)
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02803 |
# D - Maze Master
from collections import deque, defaultdict
INF = 1 << 30
MOD = 10 ** 9 + 7
dxy = [(-1, 0), (0, -1), (0, 1), (1, 0)]
def bfs(sx: int, sy: int):
queue = deque([(sx, sy)])
dist = defaultdict(lambda: INF)
dist[sx * MOD + sy] = 0
while queue:
x, y = queue.popleft()
for dx, dy in dxy:
nx, ny = x + dx, y + dy
if S[nx][ny] == "." and dist[x * MOD + y] + 1 < dist[nx * MOD + ny]:
dist[nx * MOD + ny] = dist[x * MOD + y] + 1
queue.append((nx, ny))
return max(dist.values())
def main():
global S
H, W, *S = open(0).read().split()
H, W = int(H) + 2, int(W) + 2
S = ["#" * W] + ["#" + s + "#" for s in S] + ["#" * W] # put sentinels
ans = max(bfs(i, j) for i, s in enumerate(S) for j, c in enumerate(s) if c == ".")
print(ans)
if __name__ == "__main__":
main()
| # D - Maze Master
from collections import deque, defaultdict
INF = 1 << 30
MOD = 10 ** 9 + 7
dxy = [(-1, 0), (0, -1), (0, 1), (1, 0)]
def bfs(sx: int, sy: int):
queue = deque([(sx, sy)])
dist = defaultdict(lambda: INF)
dist[sx * MOD + sy] = 0
while queue:
x, y = queue.popleft()
for dx, dy in dxy:
nx, ny = x + dx, y + dy
if S[nx][ny] == ".":
if nx * MOD + ny not in dist:
dist[nx * MOD + ny] = dist[x * MOD + y] + 1
queue.append((nx, ny))
return max(dist.values())
def main():
global S
H, W, *S = open(0).read().split()
H, W = int(H) + 2, int(W) + 2
S = ["#" * W] + ["#" + s + "#" for s in S] + ["#" * W] # put sentinels
ans = max(bfs(i, j) for i, s in enumerate(S) for j, c in enumerate(s) if c == ".")
print(ans)
if __name__ == "__main__":
main()
| p02803 |
# D - Maze Master
from collections import deque
MOD = 10 ** 9 + 7
dxy = [(-1, 0), (0, -1), (0, 1), (1, 0)]
def bfs(sx: int, sy: int):
queue = deque([(sx, sy)])
dist = {sx * MOD + sy: 0}
while queue:
x, y = queue.popleft()
for dx, dy in dxy:
nx, ny = x + dx, y + dy
if S[nx][ny] == ".":
if nx * MOD + ny not in dist:
dist[nx * MOD + ny] = dist[x * MOD + y] + 1
queue.append((nx, ny))
return max(dist.values())
def main():
global S
H, W, *S = open(0).read().split()
H, W = int(H) + 2, int(W) + 2
S = ["#" * W] + ["#" + s + "#" for s in S] + ["#" * W] # put sentinels
ans = max(bfs(i, j) for i, s in enumerate(S) for j, c in enumerate(s) if c == ".")
print(ans)
if __name__ == "__main__":
main()
| # D - Maze Master
from collections import deque
def bfs(start: int):
queue = deque([start])
dist = {start: 0}
while queue:
x = queue.popleft()
for nx in (x + 1, x - 1, x + W, x - W):
if maze[nx] and nx not in dist:
dist[nx] = dist[x] + 1
queue.append(nx)
return max(dist.values())
def main():
global H, W, maze
H, W, *S = open(0).read().split()
H, W = int(H) + 2, int(W) + 2
maze = [0] * W # flatten S and put sentinels
for s in S:
maze += [0] + [c == "." for c in s] + [0]
maze += [0] * W
ans = max(bfs(i) for i, x in enumerate(maze) if x)
print(ans)
if __name__ == "__main__":
main()
| p02803 |
# D - Maze Master
from collections import deque
def bfs(start: int):
queue = deque([start])
dist = {start: 0}
while queue:
x = queue.popleft()
for nx in (x + 1, x - 1, x + W, x - W):
if maze[nx] == "." and nx not in dist:
dist[nx] = dist[x] + 1
queue.append(nx)
return max(dist.values())
def main():
global W, maze
H, W = list(map(int, input().split()))
H, W = H + 2, W + 2
maze = "#" * W
for _ in range(H - 2):
maze += "#" + input().rstrip() + "#"
maze += "#" * W
ans = max(bfs(i) for i, x in enumerate(maze) if x == ".")
print(ans)
if __name__ == "__main__":
main()
| # D - Maze Master
from collections import deque
def bfs(start: int):
queue = deque([start])
dist = [0] * (H * W)
dist[start] = 1
while queue:
x = queue.popleft()
for nx in (x + 1, x - 1, x + W, x - W):
if maze[nx] == "." and not dist[nx]:
dist[nx] = dist[x] + 1
queue.append(nx)
return max(dist) - 1
def main():
global H, W, maze
H, W = list(map(int, input().split()))
H, W = H + 2, W + 2
maze = "#" * W
for _ in range(H - 2):
maze += "#" + input().rstrip() + "#"
maze += "#" * W
ans = max(bfs(i) for i, c in enumerate(maze) if c == ".")
print(ans)
if __name__ == "__main__":
main()
| p02803 |
import sys
input = sys.stdin.readline
from collections import deque
def main():
H, W = [int(x) for x in input().split()]
A = [["" for i in range(W)] for j in range(H)]
for j in range(H):
S = input().strip()
for i, s in enumerate(list(S)):
A[j][i] = s
ma = 0
dj = [1, 0, -1, 0]
di = [0, 1, 0, -1]
for sj in range(H):
for si in range(W):
for gj in range(H):
for gi in range(W):
d = [[-1] * W for i in range(H)]
q = deque([])
q.append((sj, si))
d[sj][si] = 0
while q:
p = q.popleft()
if p[0] == gj and p[1] == gi:
break
for i in range(4):
nj = p[0] + dj[i]
ni = p[1] + di[i]
if 0 <= nj < H and 0 <= ni < W and A[nj][ni] != "#" and d[nj][ni] == -1:
q.append((nj, ni))
d[nj][ni] = d[p[0]][p[1]] + 1
ma = max(ma, d[gj][gi])
print(ma)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
from collections import deque
def main():
H, W = [int(x) for x in input().split()]
A = [["" for i in range(W)] for j in range(H)]
for j in range(H):
S = input().strip()
for i, s in enumerate(list(S)):
A[j][i] = s
ma = 0
dj = [1, 0, -1, 0]
di = [0, 1, 0, -1]
for sj in range(H):
for si in range(W):
if A[sj][si] == "#":
continue
d = [[-1 for i in range(W)] for j in range(H)]
q = deque([])
q.append((sj, si))
d[sj][si] = 0
while q:
p = q.popleft()
for i in range(4):
nj = p[0] + dj[i]
ni = p[1] + di[i]
if 0 <= nj < H and 0 <= ni < W and A[nj][ni] != "#" and d[nj][ni] == -1:
q.append((nj, ni))
d[nj][ni] = d[p[0]][p[1]] + 1
for gj in range(H):
for gi in range(W):
ma = max(ma, d[gj][gi])
print(ma)
if __name__ == '__main__':
main()
| p02803 |
import sys
input = sys.stdin.readline
from collections import deque
H, W = list(map(int, input().split()))
S = [list(input().split()[0]) for _ in range(H)]
def bfs(S, H, W, start, goal):
INF = 100000000
stack=deque([start])
distance = [[INF]*W for _ in range(H)]
distance[start[1]][start[0]] = 0
while stack:
x, y = stack.popleft()
if (x, y) == goal:
break
for i, j in [(1,0),(0,1),(-1,0),(0,-1)]:
next_x = x + i
next_y = y + j
if not(0 <= next_x < W and 0 <= next_y < H):
continue
if S[next_y][next_x] != '#' and distance[next_y][next_x] == INF:
stack.append([next_x, next_y])
distance[next_y][next_x] = distance[y][x] + 1
return distance[goal[1]][goal[0]]
ans = 0
for i in range(H):
for j in range(W):
for k in range(H):
for l in range(W):
if (i, j) == (k, l) or S[i][j] == "#" or S[k][l] == "#":
continue
start = (j, i)
goal = (l, k)
ans = max(ans, bfs(S, H, W, start, goal))
print(ans) | import sys
input = sys.stdin.readline
from collections import deque
H, W = list(map(int, input().split()))
S = [list(input().split()[0]) for _ in range(H)]
def bfs(S, H, W, start):
INF = -1
stack=deque([start])
distance = [[INF]*W for _ in range(H)]
distance[start[1]][start[0]] = 0
while stack:
x, y = stack.popleft()
for i, j in [(1,0),(0,1),(-1,0),(0,-1)]:
next_x = x + i
next_y = y + j
if not(0 <= next_x < W and 0 <= next_y < H):
continue
if S[next_y][next_x] != '#' and distance[next_y][next_x] == -1:
stack.append([next_x, next_y])
distance[next_y][next_x] = distance[y][x] + 1
return max(list(map(max, distance)))
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] != "#":
ans = max(ans, bfs(S, H, W, (j, i)))
print(ans) | p02803 |
from collections import deque
from copy import deepcopy
# 初期入力
import sys
input = sys.stdin.readline
H,W = (int(i) for i in input().split())
map_initial =[["#"]*(W+2) for i in range(H+2)] #周囲を壁にするため＋２
for h in range(1,H+1):
map_initial[h] =["#"] +list(input().strip()) +["#"]
def BSF(x,y):
dist =0
map =deepcopy(map_initial)
if map[x][y] =="#":
return dist
dq =deque()
dq.append((x,y))
dq_sarch =deque()
while len(dq) >0:
h,w =dq.popleft()
map[h][w] ="#" #通り済を壁にする
if map[h+1][w]==".":
dq_sarch.append((h+1,w))
if map[h-1][w]==".":
dq_sarch.append((h-1,w))
if map[h][w+1]==".":
dq_sarch.append((h,w+1))
if map[h][w-1]==".":
dq_sarch.append((h,w-1))
if len(dq)==0:
dq =deepcopy(dq_sarch)
dq_sarch.clear()
dist +=1
#print(h,w,dist,end="\t")
return dist-1
#スタート位置を全探索し、最長距離を探す
dist_all =[]
for i in range(1,H+1):
for j in range(1,W+1):
dist_all.append(BSF(i,j) )
print((max(dist_all))) | from collections import deque
from copy import deepcopy
# 初期入力
import sys
input = sys.stdin.readline
H,W = (int(i) for i in input().split())
map_initial =[["#"]*(W+2) for i in range(H+2)] #周囲を壁にするため＋２
for h in range(1,H+1):
map_initial[h] =["#"] +list(input().strip()) +["#"]
def BSF(x,y):
dist =0
map =deepcopy(map_initial)
if map[x][y] =="#":
return dist
dq =set()
dq.add((x,y))
dq_sarch =set()
while len(dq) >0:
h,w =dq.pop()
map[h][w] ="#" #通り済を壁にする
if map[h+1][w]==".":
dq_sarch.add((h+1,w))
if map[h-1][w]==".":
dq_sarch.add((h-1,w))
if map[h][w+1]==".":
dq_sarch.add((h,w+1))
if map[h][w-1]==".":
dq_sarch.add((h,w-1))
if len(dq)==0:
dq =deepcopy(dq_sarch)
dq_sarch.clear()
dist +=1
#print(h,w,dist,end="\t")
return dist-1
#スタート位置を全探索し、最長距離を探す
dist_all =[]
for i in range(1,H+1):
for j in range(1,W+1):
dist_all.append(BSF(i,j) )
print((max(dist_all))) | p02803 |
import queue
import sys
input = sys.stdin.readline
class Solution:
def main(self):
H, W = list(map(int, input().split()))
S = [list(input().rstrip()) for _ in range(H)]
for i in range(H):
S[i] = ["#"] + S[i] + ["#"]
S = [["#"] * (W + 2)] + S + [["#"] * (W + 2)]
already = set()
ans = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if S[i][j] == "#":
continue
for n in range(1, H + 1):
for m in range(1, W + 1):
if S[n][m] == "#" or (i, j) == (n, m) or (i, j, n, m) in already:
continue
v = self.min_move(S, (i, j), (n, m))
already.add((i, j, n, m))
already.add((n, m, i, j))
ans = max(ans, v)
print(ans)
def min_move(self, map, start, goal):
moving_range = ((1, 0), (-1, 0), (0, 1), (0, -1))
q = queue.Queue()
q.put((start, 0))
while not q.empty():
pos, cnt = q.get()
for move in moving_range:
i, j = pos[0] + move[0], pos[1] + move[1]
if (i, j) == goal:
return cnt + 1
if map[i][j] == ".":
q.put(((i, j), cnt + 1))
# Run main
if __name__ == '__main__':
Solution().main()
| import queue
import sys
input = sys.stdin.readline
class Solution:
def main(self):
H, W = list(map(int, input().split()))
S = [list(input().rstrip()) for _ in range(H)]
for i in range(H):
S[i] = ["#"] + S[i] + ["#"]
S = [["#"] * (W + 2)] + S + [["#"] * (W + 2)]
ans = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if S[i][j] == "#":
continue
v = self.min_move(S, (i, j))
ans = max(ans, v)
print(ans)
def min_move(self, map, start):
moving_range = ((1, 0), (-1, 0), (0, 1), (0, -1))
q = queue.Queue()
q.put((start, 0))
already = {start}
ret = 0
while not q.empty():
pos, cnt = q.get()
ret = max(ret, cnt)
for move in moving_range:
i, j = pos[0] + move[0], pos[1] + move[1]
if (i, j) not in already and map[i][j] == ".":
q.put(((i, j), cnt + 1))
already.add((i, j))
return ret
# Run main
if __name__ == '__main__':
Solution().main()
| p02803 |
import sys
from collections import deque
input = sys.stdin.readline
H,W=list(map(int,input().rstrip().split()))
maze=[list(input().rstrip()) for i in range(H)]
def resolve():
seen=[[0 for i in range(W)] for j in range(H)]
ans=0
for i in range(H):
for j in range(W):
for k in range(H):
for l in range(W):
if maze[i][j]=="#" or maze[k][l]=="#":
continue
maze[k][l]=1#end
buf=bfs(maze,seen,i,j)
ans=max(ans,buf)
seen=[[0 for i in range(W)] for j in range(H)]
maze[k][l]="."
print(ans)
def bfs(maze, seen, sh, sw):
stack = deque([[sh, sw]])
seen[sh][sw] = 1
expandcount=0#今のdepthに展開されたノードを親ノードとしたときの子ノードの数
expanded=-1#今のdepthに展開されたノード数
popcount=0#popした数
depth=0#ルートからの深さ
while stack:
h, w = stack.popleft()
popcount+=1
if maze[h][w] == 1:
return depth
for j, k in ([1, 0], [-1, 0], [0, 1], [0, -1]):
new_h, new_w = h+j, w+k
if new_h < 0 or new_h >= H or new_w < 0 or new_w >= W:
continue
elif maze[new_h][new_w] != "#" and seen[new_h][new_w] == 0:#未発見
seen[new_h][new_w] = 1#発見済みにする
stack.append([new_h, new_w])#隣接を探索予定に
expandcount+=1
if popcount==expanded or expanded==-1:#同一のdepthは探索済み、下のdepthの探索に移る
expanded=expandcount
popcount=0
expandcount=0
depth+=1
"""
for i in range(H):
for j in range(W):
if(S[i][j]=="#"):
for dir in range(4):
nx=j+dx[dir]
ny=i+dy[dir]
if(nx<0 or nx>=W):
continue
if(ny<0 or ny>=H):
continue
if(S[i][j]==S[ny][nx]):
break
else:
print("No")
return
print("Yes")
"""
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3 3
...
...
..."""
output = """4"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """3 5
...#.
.#.#.
.#..."""
output = """10"""
self.assertIO(input, output)
if __name__ == "__main__":
#unittest.main()
resolve() | import sys
from collections import deque
input = sys.stdin.readline
H,W=list(map(int,input().rstrip().split()))
maze=[list(input().rstrip()) for i in range(H)]
def resolve():
seen=[[0 for i in range(W)] for j in range(H)]
ans=0
for i in range(H):
for j in range(W):
if maze[i][j]=="#":
continue
#maze[k][l]=1#end
buf=bfs(maze,seen,i,j)
ans=max(ans,buf)
seen = [[0 for i in range(W)] for j in range(H)]
#maze[k][l]="."
print(ans)
def bfs(maze, seen, sh, sw): #sh,swはスタート
stack = deque([[sh, sw]])
seen[sh][sw] = 1
expandcount=0#今のdepthに展開されたノードを親ノードとしたときの子ノードの数
expanded=-1#今のdepthに展開されたノード数、最初は-1にする
popcount=0#popした数、今のdepthでの探索回数
depth=0#ルートからの深さ
while stack:
h, w = stack.popleft()
popcount+=1
for j, k in ([1, 0], [-1, 0], [0, 1], [0, -1]):
new_h, new_w = h+j, w+k
if new_h < 0 or new_h >= H or new_w < 0 or new_w >= W:
continue
elif maze[new_h][new_w] != "#" and seen[new_h][new_w] == 0:#未発見
seen[new_h][new_w] = 1#発見済みにする
stack.append([new_h, new_w])#隣接を探索予定に
expandcount+=1
if popcount==expanded or expanded==-1:#今のdepthが全て探索済みなら、下のdepthの探索に移る
expanded=expandcount
popcount=0
expandcount=0
depth+=1
return depth-1
"""
for i in range(H):
for j in range(W):
if(S[i][j]=="#"):
for dir in range(4):
nx=j+dx[dir]
ny=i+dy[dir]
if(nx<0 or nx>=W):
continue
if(ny<0 or ny>=H):
continue
if(S[i][j]==S[ny][nx]):
break
else:
print("No")
return
print("Yes")
"""
import sys
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """3 3
...
...
..."""
output = """4"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """3 5
...#.
.#.#.
.#..."""
output = """10"""
self.assertIO(input, output)
if __name__ == "__main__":
#unittest.main()
resolve() | p02803 |
import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_matrix(H):
'''
H is number of rows
'''
return [list(map(int, read().split())) for _ in range(H)]
def read_map(H):
'''
H is number of rows
文字列で与えられた盤面を読み取る用
'''
return [read()[:-1] for _ in range(H)]
def read_col(H, n_cols):
'''
H is number of rows
n_cols is number of cols
A列、B列が与えられるようなとき
'''
ret = [[] for _ in range(n_cols)]
for _ in range(H):
tmp = list(map(int, read().split()))
for col in range(n_cols):
ret[col].append(tmp[col])
return ret
# このグラフ構造の中で一番遠い連結成分では？
H, W = read_ints()
S = read_map(H)
# おとなしく深さ優先探索
mvx = (1, 0, -1, 0)
mvy = (0, 1, 0, -1)
from itertools import product, combinations
from collections import deque
def ret_shortest(si, sj, gi, gj):
visited = [[False] * W for _ in range(H)]
que = deque([(si, sj, 0)])
visited[si][sj] = True
while que:
i, j, cost = que.popleft()
if i == gi and j == gj:
ans = cost
break
for di, dj in zip(mvy, mvx):
ni, nj = i + di, j + dj
if not (-1 < ni < H) or not (-1 < nj < W) or visited[ni][nj] or S[ni][nj] == '#':
continue
que.append((ni, nj, cost + 1))
visited[ni][nj] = True
return ans
ans = 0
candi = []
for i, j in product(list(range(H)), list(range(W))):
if S[i][j] == '.':
candi.append((i, j))
ans = 0
for a, b in combinations(candi, 2):
ans = max(ans, ret_shortest(a[0], a[1], b[0], b[1]))
print(ans)
| import sys
read = sys.stdin.readline
def read_ints():
return list(map(int, read().split()))
def read_a_int():
return int(read())
def read_matrix(H):
'''
H is number of rows
'''
return [list(map(int, read().split())) for _ in range(H)]
def read_map(H):
'''
H is number of rows
文字列で与えられた盤面を読み取る用
'''
return [read()[:-1] for _ in range(H)]
def read_col(H, n_cols):
'''
H is number of rows
n_cols is number of cols
A列、B列が与えられるようなとき
'''
ret = [[] for _ in range(n_cols)]
for _ in range(H):
tmp = list(map(int, read().split()))
for col in range(n_cols):
ret[col].append(tmp[col])
return ret
# このグラフ構造の中で一番遠い連結成分では？
H, W = read_ints()
S = read_map(H)
# おとなしく深さ優先探索
mvx = (1, 0, -1, 0)
mvy = (0, 1, 0, -1)
from itertools import product, combinations
from collections import deque
def ret_shortest(si, sj):
visited = [[False] * W for _ in range(H)]
que = deque([(si, sj, 0)])
visited[si][sj] = True
ans = 0
while que:
i, j, cost = que.popleft()
ans = max(ans, cost)
for di, dj in zip(mvy, mvx):
ni, nj = i + di, j + dj
if not (-1 < ni < H) or not (-1 < nj < W):
continue
if S[ni][nj] == '.' and not visited[ni][nj]:
que.append((ni, nj, cost + 1))
visited[ni][nj] = True
return ans
ans = 0
ans = 0
for i, j in product(list(range(H)), list(range(W))):
if S[i][j] == '.':
ans = max(ret_shortest(i, j), ans)
print(ans)
| p02803 |
import sys
from queue import Queue
def print_costs(costs):
for c in costs:
print(c)
def solve(inp):
(H, W) = list(map(int, inp.readline().strip().split(' ')))
S = [list(inp.readline().strip()) for i in range(H)]
max_cost = 0
for start_y in range(H):
for start_x in range(W):
if S[start_y][start_x] == '#':
continue
costs = [[0 for w in range(W)] for h in range(H)]
queue = Queue()
queue.put((start_y, start_x, 1))
cost = 1
while not queue.empty():
(y, x, c) = queue.get()
if costs[y][x] != 0:
continue
# print("({},{}): {}".format(y, x, c))
costs[y][x] = c
cost = c
for (next_y, next_x) in [(y - 1, x), (y, x + 1), (y + 1, x), (y, x - 1)]:
if 0 <= next_y < H and 0 <= next_x < W and S[next_y][next_x] == '.':
queue.put((next_y, next_x, c + 1))
if cost > max_cost:
max_cost = cost
# print("--- cost={}".format(max_cost))
# print_costs(costs)
# print()
return str(max_cost - 1)
def main():
result = solve(sys.stdin)
if result:
print(result)
if __name__ == '__main__':
main()
| import sys
from queue import Queue
def print_costs(costs):
for c in costs:
print(c)
def solve(inp):
(H, W) = list(map(int, inp.readline().strip().split(' ')))
S = [list(inp.readline().strip()) for i in range(H)]
max_cost = 0
for start_y in range(H):
for start_x in range(W):
if S[start_y][start_x] == '#':
continue
costs = [[0 for w in range(W)] for h in range(H)]
costs[start_y][start_x] = 1
queue = Queue()
queue.put((start_y, start_x))
cost = 1
while not queue.empty():
(y, x) = queue.get()
# print("({},{}): {}".format(y, x, c))
for (next_y, next_x) in [(y - 1, x), (y, x + 1), (y + 1, x), (y, x - 1)]:
if 0 <= next_y < H and 0 <= next_x < W and S[next_y][next_x] == '.' and costs[next_y][next_x] == 0:
costs[next_y][next_x] = costs[y][x] + 1
if cost < costs[next_y][next_x]:
cost = costs[next_y][next_x]
queue.put((next_y, next_x))
if cost > max_cost:
max_cost = cost
# print("--- cost={}".format(max_cost))
# print_costs(costs)
# print()
return str(max_cost - 1)
def main():
result = solve(sys.stdin)
if result:
print(result)
if __name__ == '__main__':
main()
| p02803 |
import queue
import copy
def main():
H, W = list(map(int, input().split()))
S = []
for i in range(H):
S.append(list(input()))
def bfs(start, S2):
q = queue.Queue()
q.put(start)
candidates = [[0, 1], [1, 0], [0, -1], [-1, 0]]
dist = [[0]*W for _ in range(H)]
while not q.empty():
i = q.get()
x = i[0]
y = i[1]
S2[x][y] = "#"
for candi in candidates:
x_new = x + candi[0]
y_new = y + candi[1]
if x_new < H and x_new >= 0:
if y_new < W and y_new >=0:
if S2[x_new][y_new] == ".":
dist[x_new][y_new] = dist[x][y] + 1
q.put([x_new, y_new])
ans = 0
for i in range(H):
ans = max(ans, max(dist[i]))
return ans
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == ".":
S2 = copy.deepcopy(S)
ans = max(ans, bfs([i, j], S2))
print(ans)
if __name__ == "__main__":
main()
| import queue
import copy
def main():
H, W = list(map(int, input().split()))
S = []
for i in range(H):
S.append(list(input()))
def bfs(start, S2):
q = queue.Queue()
q.put(start)
candidates = [[0, 1], [1, 0], [0, -1], [-1, 0]]
dist = [[0]*W for _ in range(H)]
S2[start[0]][start[1]] = "#"
while not q.empty():
i = q.get()
x = i[0]
y = i[1]
for candi in candidates:
x_new = x + candi[0]
y_new = y + candi[1]
if x_new < H and x_new >= 0:
if y_new < W and y_new >=0:
if S2[x_new][y_new] == ".":
dist[x_new][y_new] = dist[x][y] + 1
S2[x_new][y_new] = "#"
q.put([x_new, y_new])
ans = 0
for i in range(H):
ans = max(ans, max(dist[i]))
return ans
ans = 0
for i in range(H):
for j in range(W):
if S[i][j] == ".":
S2 = copy.deepcopy(S)
ans_temp = bfs([i, j], S2)
# print i, j, ans_temp
ans = max(ans, ans_temp)
print(ans)
if __name__ == "__main__":
main()
| p02803 |
import sys
import itertools
import collections
def search(H, W, S, start, end):
wall_i = ord(b'#')
used = [[-1 for h in range(W)] for w in range(H)]
qu = collections.deque()
qu.append(start)
used[start[0]][start[1]] = 0
while qu:
h, w = qu.popleft()
cost = used[h][w]
for h0, w0 in ((h - 1, w), (h + 1, w), (h, w - 1), (h, w + 1)):
if not (0 <= h0 < H and 0 <= w0 < W):
continue
if used[h0][w0] != -1:
continue
if S[h0][w0] == wall_i:
continue
if (h0, w0) == end:
return cost + 1
used[h0][w0] = cost + 1
qu.append((h0, w0))
cost += 1
return -1
def resolve(in_):
H, W = list(map(int, next(in_).split()))
S = tuple(s.strip() for s in itertools.islice(in_, H))
road_i = ord(b'.')
roads = []
for h in range(H):
for w in range(W):
if S[h][w] == road_i:
roads.append((h, w))
ans = max(search(H, W, S, start, end) for start, end in itertools.permutations(roads, 2))
return ans
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| import sys
import itertools
import collections
def search(H, W, S, start):
wall_i = ord(b'#')
used = [[-1 for h in range(W)] for w in range(H)]
qu = collections.deque()
qu.append(start)
used[start[0]][start[1]] = 0
while qu:
h, w = qu.popleft()
cost = used[h][w]
for h0, w0 in ((h - 1, w), (h + 1, w), (h, w - 1), (h, w + 1)):
if not (0 <= h0 < H and 0 <= w0 < W):
continue
if used[h0][w0] != -1:
continue
if S[h0][w0] == wall_i:
continue
used[h0][w0] = cost + 1
qu.append((h0, w0))
return max(cost for costs in used for cost in costs)
def resolve(in_):
H, W = list(map(int, next(in_).split()))
S = tuple(s.strip() for s in itertools.islice(in_, H))
road_i = ord(b'.')
roads = []
for h in range(H):
for w in range(W):
if S[h][w] == road_i:
roads.append((h, w))
ans = max(search(H, W, S, start) for start in roads)
return ans
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| p02803 |
from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w, 0))
temp_h = h
temp_w = w
visited = [[0] * W for _ in range(H)]
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
temp_d = temp[2]
ans = max(ans, temp_d)
visited[temp_h][temp_w] = 1
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] == 0:
q.put((temp_h + 1, temp_w, temp_d + 1))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] == 0:
q.put((temp_h - 1, temp_w, temp_d + 1))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] == 0:
q.put((temp_h, temp_w + 1, temp_d + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] == 0:
q.put((temp_h, temp_w - 1, temp_d + 1))
print(ans) | from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w))
visited = [[-1] * W for _ in range(H)]
visited[h][w] = 0
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
ans = max(ans, visited[temp_h][temp_w])
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] < 0:
visited[temp_h + 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h + 1, temp_w))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] < 0:
visited[temp_h - 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h - 1, temp_w))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] < 0:
visited[temp_h][temp_w + 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] < 0:
visited[temp_h][temp_w - 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w - 1))
print(ans) | p02803 |
from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w, 0))
visited = [[-1] * W for _ in range(H)]
visited[h][w] = 0
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
temp_d = temp[2]
ans = max(ans, visited[temp_h][temp_w])
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] < 0:
visited[temp_h + 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h + 1, temp_w, temp_d + 1))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] < 0:
visited[temp_h - 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h - 1, temp_w, temp_d + 1))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] < 0:
visited[temp_h][temp_w + 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w + 1, temp_d + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] < 0:
visited[temp_h][temp_w - 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w - 1, temp_d + 1))
print(ans)
| from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w, 0))
visited = [[0] * W for _ in range(H)]
visited[h][w] = 1
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
temp_d = temp[2]
ans = max(ans, temp_d)
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] == 0:
visited[temp_h + 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h + 1, temp_w, temp_d + 1))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] == 0:
visited[temp_h - 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h - 1, temp_w, temp_d + 1))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] == 0:
visited[temp_h][temp_w + 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w + 1, temp_d + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] == 0:
visited[temp_h][temp_w - 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w - 1, temp_d + 1))
print(ans) | p02803 |
from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w, 0))
visited = [[0] * W for _ in range(H)]
visited[h][w] = 1
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
temp_d = temp[2]
ans = max(ans, temp_d)
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] == 0:
visited[temp_h + 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h + 1, temp_w, temp_d + 1))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] == 0:
visited[temp_h - 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h - 1, temp_w, temp_d + 1))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] == 0:
visited[temp_h][temp_w + 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w + 1, temp_d + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] == 0:
visited[temp_h][temp_w - 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w - 1, temp_d + 1))
print(ans) | from sys import stdin
import queue
H, W = [int(x) for x in stdin.readline().rstrip().split()]
maze = [stdin.readline().rstrip().split()[0] for _ in range(H)]
ans = 0
for h in range(H):
for w in range(W):
if maze[h][w] == '#':
continue
else:
q = queue.Queue()
q.put((h, w, 0))
temp_h = h
temp_w = w
visited = [[0] * W for _ in range(H)]
visited[h][w] = 1
while q.qsize() > 0:
temp = q.get()
temp_h = temp[0]
temp_w = temp[1]
temp_d = temp[2]
ans = max(ans, temp_d)
if temp_h + 1 < H and maze[temp_h + 1][temp_w] == '.' and visited[temp_h + 1][temp_w] == 0:
visited[temp_h + 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h + 1, temp_w, temp_d + 1))
if temp_h - 1 >= 0 and maze[temp_h - 1][temp_w] == '.' and visited[temp_h - 1][temp_w] == 0:
visited[temp_h - 1][temp_w] = visited[temp_h][temp_w] + 1
q.put((temp_h - 1, temp_w, temp_d + 1))
if temp_w + 1 < W and maze[temp_h][temp_w + 1] == '.' and visited[temp_h][temp_w + 1] == 0:
visited[temp_h][temp_w + 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w + 1, temp_d + 1))
if temp_w - 1 >= 0 and maze[temp_h][temp_w - 1] == '.' and visited[temp_h][temp_w - 1] == 0:
visited[temp_h][temp_w - 1] = visited[temp_h][temp_w] + 1
q.put((temp_h, temp_w - 1, temp_d + 1))
print(ans) | p02803 |
from queue import Queue
h, w = list(map(int, input().split()))
s = []
for i in range(h):
s.append(input().strip())
ans = 0
for i in range(h):
for j in range(w):
start = s[i][j]
if start == "#":
continue
else:
visited = [[False for k in range(w)] for l in range(h)]
queue = Queue()
queue.put((i, j, 0))
while 0 < queue.qsize():
now = queue.get()
visited[now[0]][now[1]] = True
ans = max(ans, now[2])
if (now[0] <= (h - 2)):
if (s[now[0] + 1][now[1]] == ".") and not visited[now[0] + 1][now[1]]:
queue.put(((now[0] + 1), now[1], (now[2] + 1)))
if (now[1] <= (w - 2)):
if (s[now[0]][now[1] + 1] == ".") and not visited[now[0]][now[1] + 1]:
queue.put((now[0], (now[1] + 1), (now[2] + 1)))
if (1 <= now[0]):
if (s[now[0] - 1][now[1]] == ".") and not visited[now[0] - 1][now[1]]:
queue.put(((now[0] - 1), now[1], (now[2] + 1)))
if (1 <= now[1]):
if (s[now[0]][now[1] - 1] == ".") and not visited[now[0]][now[1] - 1]:
queue.put((now[0], (now[1] - 1), (now[2] + 1)))
print(ans)
| from queue import Queue
h, w = list(map(int, input().split()))
s = []
for i in range(h):
s.append(input().strip())
ans = 0
for i in range(h):
for j in range(w):
start = s[i][j]
if start == "#":
continue
else:
visited = [[False for _ in range(w)] for _ in range(h)]
visited[i][j] = True
queue = Queue()
queue.put((i, j, 0))
while 0 < queue.qsize():
now = queue.get()
ans = max(ans, now[2])
if (now[0] <= (h - 2)) and (s[now[0] + 1][now[1]] == ".") and not visited[now[0] + 1][now[1]]:
queue.put(((now[0] + 1), now[1], (now[2] + 1)))
visited[now[0] + 1][now[1]] = True
if (now[1] <= (w - 2)) and (s[now[0]][now[1] + 1] == ".") and not visited[now[0]][now[1] + 1]:
queue.put((now[0], (now[1] + 1), (now[2] + 1)))
visited[now[0]][now[1] + 1] = True
if (1 <= now[0]) and (s[now[0] - 1][now[1]] == ".") and not visited[now[0] - 1][now[1]]:
queue.put(((now[0] - 1), now[1], (now[2] + 1)))
visited[now[0] - 1][now[1]] = True
if (1 <= now[1]) and (s[now[0]][now[1] - 1] == ".") and not visited[now[0]][now[1] - 1]:
queue.put((now[0], (now[1] - 1), (now[2] + 1)))
visited[now[0]][now[1] - 1] = True
print(ans)
| p02803 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import deque
h, w = na()
maze = nsn(h)
def bfs(sx, sy):
q = deque()
q.append((sx, sy))
dist = [[inf] * w for _ in range(h)]
dist[sy][sx] = 0
dx, dy = [1, 0, 0, -1], [0, 1, -1, 0]
res = 0
while len(q):
p = q.popleft()
cx, cy = p
for i in range(4):
nx, ny = cx + dx[i], cy + dy[i]
if nx < 0 or nx >= w:
continue
if ny < 0 or ny >= h:
continue
if dist[ny][nx] != inf:
continue
if maze[ny][nx] == '#':
continue
update = dist[cy][cx] + 1
dist[ny][nx] = update
res = max(res, update)
q.append((nx, ny))
return res
ans = 0
for y in range(h):
for x in range(w):
if maze[y][x] == '#':
continue
ans = max(ans, bfs(x, y))
print(ans) | import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import deque
h, w = na()
maze = nsn(h)
def bfs(sx, sy):
q = deque()
q.append((sx, sy))
dist = [[inf] * w for _ in range(h)]
dist[sy][sx] = 0
dx, dy = [1, 0, 0, -1], [0, 1, -1, 0]
res = 0
while len(q):
p = q.popleft()
cx, cy = p
for i in range(4):
nx, ny = cx + dx[i], cy + dy[i]
if nx < 0 or nx >= w:
continue
if ny < 0 or ny >= h:
continue
if dist[ny][nx] != inf:
continue
if maze[ny][nx] == '#':
continue
update = dist[cy][cx] + 1
dist[ny][nx] = update
res = max(res, update)
q.append((nx, ny))
return res
def main():
ans = 0
for y in range(h):
for x in range(w):
if maze[y][x] == '#':
continue
ans = max(ans, bfs(x, y))
print(ans)
if __name__ == '__main__':
main() | p02803 |
h, w = list(map(int, input().split()))
maze = [list(input()) for i in range(h)]
INF = 10 ** 10
my = [-1, 0, 1, 0]
mx = [0, -1, 0, 1]
def bfs(sy, sx, ey, ex):
q = [(sy, sx)]
dp = [ [INF for j in range(w)] for i in range(h) ]
dp[sy][sx] = 0
while q:
(y, x) = q.pop(0)
if (y, x) == (ey, ex):
break
for (dy, dx) in zip(my, mx):
ny = y + dy
nx = x + dx
if ny < 0 or nx < 0 or ny >= h or nx >= w:
continue
if maze[ny][nx] == '#':
continue
if dp[ny][nx] != INF:
continue
dp[ny][nx] = dp[y][x] + 1
q.append((ny, nx))
res = dp[ey][ex]
assert res < INF
return res
res = 0
for sy in range(h):
for sx in range(w):
if maze[sy][sx] == '#':
continue
for ey in range(h):
for ex in range(w):
if maze[ey][ex] == '#':
continue
res = max(res, bfs(sy, sx, ey, ex))
print(res)
| h, w = list(map(int, input().split()))
maze = [list(input()) for i in range(h)]
INF = 10 ** 10
my = [-1, 0, 1, 0]
mx = [0, -1, 0, 1]
def bfs(sy, sx):
q = [(sy, sx)]
dp = [ [INF for j in range(w)] for i in range(h) ]
dp[sy][sx] = 0
while q:
(y, x) = q.pop(0)
for (dy, dx) in zip(my, mx):
ny = y + dy
nx = x + dx
if ny < 0 or nx < 0 or ny >= h or nx >= w:
continue
if maze[ny][nx] == '#':
continue
if dp[ny][nx] != INF:
continue
dp[ny][nx] = dp[y][x] + 1
q.append((ny, nx))
res = 0
for i in range(h):
for j in range(w):
if maze[i][j] != '#':
res = max(res, dp[i][j])
return res
res = 0
for sy in range(h):
for sx in range(w):
if maze[sy][sx] == '#':
continue
res = max(res, bfs(sy, sx))
print(res)
| p02803 |
h,w=list(map(int,input().split()))
s = [[0]*w for _ in range(h)]
for i in range(h):
s[i] = list(*input().split())
def cango(now,h,w):
ans = []
if now[0]>0:
ans.append( (now[0]-1,now[1]) )
if now[0]<h-1:
ans.append( (now[0]+1,now[1]) )
if now[1]>0:
ans.append( (now[0],now[1]-1) )
if now[1]<w-1:
ans.append( (now[0],now[1]+1) )
return ans
from collections import deque
ans=0
for hh in range(h):
for ww in range(w):
if s[hh][ww]==".":
start = (hh,ww)
q = deque( [] )
q.append( ((-1,-1),start,0) )
visit = [[0]*w for _ in range(h)]
while q:
old,now,dist = q.popleft()
visit[now[0]][now[1]] = 1
# print(old,now,dist)
if ans<dist:
ans=dist
for new in cango(now,h,w):
if s[new[0]][new[1]]=="." and visit[new[0]][new[1]]==0:
q.append( (now,new,dist+1) )
print(ans )
| h,w=list(map(int,input().split()))
s = [[0]*w for _ in range(h)]
for i in range(h):
s[i] = list(*input().split())
def cango(now,h,w):
ans = []
if now[0]>0:
ans.append( (now[0]-1,now[1]) )
if now[0]<h-1:
ans.append( (now[0]+1,now[1]) )
if now[1]>0:
ans.append( (now[0],now[1]-1) )
if now[1]<w-1:
ans.append( (now[0],now[1]+1) )
return ans
from collections import deque
ans=0
for hh in range(h):
for ww in range(w):
if s[hh][ww]==".":
start = (hh,ww)
q = deque( [] )
q.append( ((-1,-1),start,0) )
visit = [[0]*w for _ in range(h)]
visit[hh][ww]=1
while q:
old,now,dist = q.popleft()
# print(old,now,dist)
if ans<dist:
ans=dist
for new in cango(now,h,w):
if s[new[0]][new[1]]=="." and visit[new[0]][new[1]]==0:
q.append( (now,new,dist+1) )
visit[new[0]][new[1]] = 1
print(ans )
| p02803 |
# -*- coding: utf-8 -*-
import sys
from collections import deque
from collections import defaultdict
H,W=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
D=[(1,0),(-1,0),(0,1),(0,-1)]
def bfs(start):
Visit={}
q=deque()
q.append(start)
L=defaultdict(lambda: float("inf"))
L[start]=0
while q:
fro_x,fro_y=q.popleft()
for dx,dy in D:
to_x=fro_x+dx
to_y=fro_y+dy
alt=L[(fro_x,fro_y)]+1
if 0<=to_x<H and 0<=to_y<W:
if S[to_x][to_y]=="." and alt<L[(to_x,to_y)]:
L[(to_x,to_y)]=alt
q.append((to_x,to_y))
return max(L.values())
ans=0
for h in range(H):
for w in range(W):
if S[h][w]==".":
ans=max(ans,bfs((h,w)))
print(ans)
| # -*- coding: utf-8 -*-
import sys
from collections import deque
from collections import defaultdict
H,W=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
D=[(1,0),(-1,0),(0,1),(0,-1)]
def bfs(start):
Visit={}
q=deque()
q.append(start)
Visit[start]=1
L=defaultdict(lambda: float("inf")) #距離
L[start]=0
while q:
fro_x,fro_y=q.popleft()
for dx,dy in D:
to_x=fro_x+dx
to_y=fro_y+dy
if 0<=to_x<H and 0<=to_y<W:
if S[to_x][to_y]=="." and (to_x,to_y) not in Visit:
Visit[to_x,to_y]=1
L[(to_x,to_y)]=min(L[(to_x,to_y)],L[(fro_x,fro_y)]+1)
q.append((to_x,to_y))
if len(list(L.values()))==0:
return 0
else:
return max(L.values())
ans=0
for h in range(H):
for w in range(W):
if S[h][w]==".":
ans=max(ans,bfs((h,w)))
print(ans) | p02803 |
# -*- coding: utf-8 -*-
import sys
from collections import deque
from collections import defaultdict
H,W=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
D=[(1,0),(-1,0),(0,1),(0,-1)]
def bfs(start):
Visit={}
q=deque()
q.append(start)
Visit[start]=1
L=defaultdict(lambda: float("inf")) #距離
L[start]=0
while q:
fro_x,fro_y=q.popleft()
for dx,dy in D:
to_x=fro_x+dx
to_y=fro_y+dy
if 0<=to_x<H and 0<=to_y<W:
if S[to_x][to_y]=="." and (to_x,to_y) not in Visit:
Visit[to_x,to_y]=1
L[(to_x,to_y)]=min(L[(to_x,to_y)],L[(fro_x,fro_y)]+1)
q.append((to_x,to_y))
if len(list(L.values()))==0:
return 0
else:
return max(L.values())
ans=0
for h in range(H):
for w in range(W):
if S[h][w]==".":
ans=max(ans,bfs((h,w)))
print(ans) | # -*- coding: utf-8 -*-
import sys
from collections import deque
from collections import defaultdict
H,W=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
D=[(1,0),(-1,0),(0,1),(0,-1)]
def bfs(start):
Visit={}
q=deque()
q.append(start)
Visit[start]=1
L=defaultdict(lambda: 0) #距離
while q:
fro_x,fro_y=q.popleft()
for dx,dy in D:
to_x=fro_x+dx
to_y=fro_y+dy
if 0<=to_x<H and 0<=to_y<W:
if S[to_x][to_y]=="." and (to_x,to_y) not in Visit:
Visit[to_x,to_y]=1
L[(to_x,to_y)]=L[(fro_x,fro_y)]+1
q.append((to_x,to_y))
return max(L.values())
ans=0
for h in range(H):
for w in range(W):
if S[h][w]==".":
ans=max(ans,bfs((h,w)))
print(ans)
| p02803 |
from collections import deque
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def bfs(field, sx, sy, gx, gy, seen):
queue = deque([(sx, sy)])
seen[sx][sy] += 1
while queue:
x, y = queue.popleft()
if (x, y) == (gx, gy):
return seen[x][y]
for dx, dy in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
nx = x + dx
ny = y + dy
if seen[nx][ny] == -1 and field[nx][ny] != "#":
seen[nx][ny] = seen[x][y] + 1
queue.append((nx, ny))
def main():
H,W = list(map(int, readline().split()))
c = ["#" * (W + 2)]
for _ in range(H):
c.append("#" + readline().strip() + "#")
c.append("#" * (W + 2))
ans = 0
for sx in range(1,H+1):
for sy in range(1,W+1):
if c[sx][sy] == "#":
continue
for gx in range(sx,H+1):
for gy in range(1,W+1):
if c[gx][gy] == "#":
continue
seen = [[-1] * (W + 2) for i in range(H+2)]
dist = bfs(c, sx, sy, gx, gy, seen)
ans = max(ans, dist)
print(ans)
if __name__ == "__main__":
main()
| from collections import deque
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def bfs(field, sx, sy, seen):
queue = deque([(sx, sy)])
seen[sx][sy] += 1
while queue:
x, y = queue.popleft()
for dx, dy in [(-1, 0), (0, 1), (1, 0), (0, -1)]:
nx = x + dx
ny = y + dy
if seen[nx][ny] == -1 and field[nx][ny] != "#":
seen[nx][ny] = seen[x][y] + 1
queue.append((nx, ny))
return seen[x][y]
def main():
H,W = list(map(int, readline().split()))
c = ["#" * (W + 2)]
for _ in range(H):
c.append("#" + readline().strip() + "#")
c.append("#" * (W + 2))
ans = 0
for sx in range(1,H+1):
for sy in range(1,W+1):
if c[sx][sy] == ".":
seen = [[-1] * (W + 2) for i in range(H+2)]
dist = bfs(c, sx, sy, seen)
ans = max(ans, dist)
print(ans)
if __name__ == "__main__":
main()
| p02803 |
from collections import deque
H,W = list(map(int,input().split()))
S = [input().strip() for _ in range(H)]
cmax = 0
for i in range(H):
for j in range(W):
for k in range(H):
for l in range(W):
if (i,j)!=(k,l) and S[i][j]=="." and S[k][l]==".":
que = deque([(i,j,0)])
hist = {(n,m):0 for n in range(H) for m in range(W)}
hist[(i,j)] = 1
while que:
x = que.popleft()
n,m,c = x[0],x[1],x[2]
if n==k and m==l:
cmax = max(cmax,c)
break
if m+1<W and S[n][m+1]=="." and hist[(n,m+1)]==0:
que.append((n,m+1,c+1))
hist[(n,m+1)] = 1
if m-1>-1 and S[n][m-1]=="." and hist[(n,m-1)]==0:
que.append((n,m-1,c+1))
hist[(n,m-1)] = 1
if n+1<H and S[n+1][m]=="." and hist[(n+1,m)]==0:
que.append((n+1,m,c+1))
hist[(n+1,m)] = 1
if n-1>-1 and S[n-1][m]=="." and hist[(n-1,m)]==0:
que.append((n-1,m,c+1))
hist[(n-1,m)] = 1
print(cmax) | import heapq
INFTY = 10**3
H,W = list(map(int,input().split()))
S = [input().strip() for _ in range(H)]
dist = {(i,j):{(k,l):INFTY for k in range(H) for l in range(W)} for j in range(W) for i in range(H)}
for i in range(H):
for j in range(W):
if S[i][j]==".":
hist = {(k,l):0 for k in range(H) for l in range(W)}
heap = [(0,i,j)]
dist[(i,j)][(i,j)]= 0
hist[(i,j)] = 1
while heap:
d,k,l = heapq.heappop(heap)
if d>dist[(i,j)][(k,l)]:continue
hist[(k,l)] = 1
if l+1<W and S[k][l+1]=="." and hist[(k,l+1)]==0:
if dist[(i,j)][(k,l+1)]>d+1:
dist[(i,j)][(k,l+1)] = d+1
heapq.heappush(heap,(d+1,k,l+1))
if l-1>-1 and S[k][l-1]=="." and hist[(k,l-1)]==0:
if dist[(i,j)][(k,l-1)]>d+1:
dist[(i,j)][(k,l-1)]=d+1
heapq.heappush(heap,(d+1,k,l-1))
if k+1<H and S[k+1][l]=="." and hist[(k+1,l)]==0:
if dist[(i,j)][(k+1,l)]>d+1:
dist[(i,j)][(k+1,l)]=d+1
heapq.heappush(heap,(d+1,k+1,l))
if k-1>-1 and S[k-1][l]=="." and hist[(k-1,l)]==0:
if dist[(i,j)][(k-1,l)]>d+1:
dist[(i,j)][(k-1,l)]=d+1
heapq.heappush(heap,(d+1,k-1,l))
dmax = 0
for i in range(H):
for j in range(W):
for k in range(H):
for l in range(W):
if dist[(i,j)][(k,l)]<INFTY:
dmax = max(dmax,dist[(i,j)][(k,l)])
print(dmax) | p02803 |
from collections import deque
h,w = list(map(int, input().split()))
grid = []
for i in range(h):
s = list(input().rstrip())
grid.append(s)
dxdy = [[0, 1], [1,0], [-1, 0], [0, -1]]
visited = [[0]*w for _ in range(h)]
dist = [[0]*w for _ in range(h)]
for i in range(h):
for j in range(w):
if grid[i][j]==".":
y = i
x = j
break
que=deque()
que.append([x,y])
while que:
v=que.popleft()
x = v[0]
y = v[1]
visited[y][x]=1
for i in dxdy:
dx = i[0]
dy = i[1]
if((x+dx<w and y+dy<h) and ((x+dx)>-1)and(y+dy)>-1) and not visited[y+dy][x+dx]:
dist[y+dy][x+dx]=dist[y][x]+1
que.append([x+dx, y+dy])
max_dist = [0, []]
def max1(a,b):
if a[0]>b[0]:
return a
else:
return b
for i in range(h):
for j in range(w):
max_dist = max1(max_dist, [dist[i][j], i,j])
visited = [[0]*w for _ in range(h)]
dist = [[0]*w for _ in range(h)]
que2 = deque()
que2.append([max_dist[2], max_dist[1]])
while que2:
v=que2.popleft()
x = v[0]
y = v[1]
visited[y][x]=1
for i in dxdy:
dx = i[0]
dy = i[1]
if((x+dx<w and y+dy<h) and ((x+dx)>-1)and(y+dy)>-1) and not visited[y+dy][x+dx] and grid[y+dy][x+dx]==".":
dist[y+dy][x+dx]=dist[y][x]+1
que2.append([x+dx, y+dy])
for i in range(h):
for j in range(w):
max_dist = max1(max_dist, [dist[i][j], i,j])
print((max_dist[0]))
| from collections import deque
h,w = list(map(int, input().split()))
grid = []
for i in range(h):
s = list(input().rstrip())
grid.append(s)
dydx = [[0, 1], [1,0], [-1, 0], [0, -1]]
def find_longest_path(xy):
visited = [[0]*w for _ in range(h)]
dist = [[0]*w for _ in range(h)]
visited[xy[1]][xy[0]]=1
que = deque()
que.append(xy)
while que:
v = que.popleft()
x,y = v[0],v[1]
for i in dydx:
dx = i[0]
dy = i[1]
if ((x+dx<w and y+dy<h) and ((x+dx)>-1)and(y+dy)>-1) and not visited[y+dy][x+dx]:
if(grid[y+dy][x+dx]=="."):
que.append([x+dx, y+dy])
visited[y+dy][x+dx]=1
dist[y+dy][x+dx]=dist[y][x]+1
u,k = x+dx, y+dy
r = dist[y+dy][x+dx]
return r
def main():
k=0
for i in range(h):
for j in range(w):
if grid[i][j]==".":
k = max(k, find_longest_path([j,i]))
print(k)
if __name__ == '__main__':
main()
| p02803 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from copy import deepcopy
h, w = list(map(int, readline().split()))
s = [readline().rstrip().decode() for _ in range(h)]
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
sg = []
memo = [[False] * w for _ in range(h)]
for i in range(h):
for j in range(w):
if s[i][j] == '.':
sg.append((i, j))
else:
memo[i][j] = True
ans = 0
for ss in sg:
for g in sg:
if ss == g:
continue
q = [ss]
cnt = 0
dist = deepcopy(memo)
dist[ss[0]][ss[1]] = True
while q:
cnt += 1
qq = []
for y, x in q:
for dy, dx in move:
xx, yy = x + dx, y + dy
if xx < 0 or yy > h - 1 or yy < 0 or xx > w - 1:
continue
if dist[yy][xx]:
continue
dist[yy][xx] = True
qq.append((yy, xx))
q = qq
if g in q:
ans = max(ans, cnt)
break
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from copy import deepcopy
h, w = list(map(int, readline().split()))
s = [readline().rstrip().decode() for _ in range(h)]
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
sg = []
memo = [[False] * w for _ in range(h)]
for i in range(h):
for j in range(w):
if s[i][j] == '.':
sg.append((i, j))
else:
memo[i][j] = True
ans = 0
for ss in sg:
q = [ss]
cnt = 0
dist = deepcopy(memo)
dist[ss[0]][ss[1]] = True
while q:
cnt += 1
qq = []
for y, x in q:
for dy, dx in move:
xx, yy = x + dx, y + dy
if xx < 0 or yy > h - 1 or yy < 0 or xx > w - 1:
continue
if dist[yy][xx]:
continue
dist[yy][xx] = True
qq.append((yy, xx))
q = qq
ans = max(ans, cnt - 1)
print(ans)
| p02803 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
INF = 100000
dir = ((1, 0), (-1, 0), (0, 1), (0, -1))
def main():
H, W = list(map(int, readline().split()))
maze = []
for _ in range(H):
s = readline().rstrip().decode()
maze.append(s)
def bfs(si, sj):
dq = deque()
dq.append((si, sj))
dist = [[INF for _ in range(W)] for _ in range(H)]
dist[si][sj] = 0
while len(dq)>0:
i, j = dq.popleft()
for di, dj in dir:
nxi = i+di
nxj = j+dj
if (nxi<0) or (nxj<0) or (nxi>=H) or (nxj>=W):
continue
if maze[nxi][nxj] == '#':
continue
if dist[nxi][nxj] != INF:
continue
dist[nxi][nxj] = dist[i][j]+1
dq.append((nxi, nxj))
res = 0
for i in range(H):
for j in range(W):
if dist[i][j] == INF:
continue
res = max(dist[i][j], res)
return res
ans = 0
for si in range(H):
for sj in range(W):
if maze[si][sj] == '#':
continue
ans = max(bfs(si, sj), ans)
print(ans)
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import deque
dir = ((-1, 0), (1, 0), (0, -1), (0, 1))
def main():
h, w = list(map(int, readline().split()))
grid = []
for _ in range(h):
grid.append(readline().rstrip().decode())
INF = int(1e9)
mx = 0
for si in range(h):
for sj in range(w):
if grid[si][sj] == '#':
continue
dq = deque()
dq.append((si, sj))
dist = [[-1 for _ in range(w)] for _ in range(h)]
dist[si][sj] = 0
while len(dq) > 0:
ni, nj = dq.popleft()
for d in dir:
x, y = ni+d[0], nj+d[1]
if (x < 0) or (y < 0) or (x >= h) or (y >= w):
continue
if grid[x][y] == '#':
continue
if dist[x][y] != -1:
continue
dist[x][y] = dist[ni][nj]+1
dq.append((x, y))
for i in range(h):
for j in range(w):
if dist[i][j] == -1:
continue
mx = max(mx, dist[i][j])
print(mx)
if __name__ == '__main__':
main() | p02803 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def fact_and_inv(SIZE):
inv = [0] * SIZE # inv[j] = j^{-1} mod MOD
fac = [0] * SIZE # fac[j] = j! mod MOD
finv = [0] * SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2, SIZE):
inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
fac[i] = fac[i - 1] * i % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
return fac, finv
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def warshall_floyd(d, n):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
class TwoDimGrid:
# 2次元座標 -> 1次元
def __init__(self, h, w, wall="#"):
self.h = h
self.w = w
self.size = (h+2) * (w+2)
self.wall = wall
self.get_grid()
def get_grid(self):
grid = [self.wall * (self.w + 2)]
for i in range(self.h):
grid.append(self.wall + getS() + self.wall)
grid.append(self.wall * (self.w + 2))
self.grid = grid
def pos(self, x, y):
return y * (self.w + 2) + x + 1
def search(self):
grid = self.grid
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
move_eight = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
d = [[INF for i in range(self.size)] for j in range(self.size)]
for i in range(self.size):
d[i][i] = 0
for i in range(1, self.h + 1):
for j in range(1, self.w + 1):
# pass # ここから何か書いてね
cx, cy = j, i
if grid[cy][cx] == "#":
continue
cur = grid[cy][cx]
for mv in move:
dx, dy = mv
nx, ny = cx + dx, cy + dy
if grid[ny][nx] == ".":
d[self.pos(cx, cy)][self.pos(nx, ny)] = 1
d = warshall_floyd(d, self.size)
ans = 0
for dd in d:
for ddd in dd:
if ddd != INF:
ans = max(ans, ddd)
print(ans)
def solve():
h, w = getList()
G = TwoDimGrid(h, w)
G.search()
return
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def fact_and_inv(SIZE):
inv = [0] * SIZE # inv[j] = j^{-1} mod MOD
fac = [0] * SIZE # fac[j] = j! mod MOD
finv = [0] * SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2, SIZE):
inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
fac[i] = fac[i - 1] * i % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
return fac, finv
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def warshall_floyd(d, n):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
class TwoDimGrid:
# 2次元座標 -> 1次元
def __init__(self, h, w, wall="#"):
self.h = h
self.w = w
self.size = (h+2) * (w+2)
self.wall = wall
self.get_grid()
def get_grid(self):
grid = [self.wall * (self.w + 2)]
for i in range(self.h):
grid.append(self.wall + getS() + self.wall)
grid.append(self.wall * (self.w + 2))
self.grid = grid
def pos(self, x, y):
return y * (self.w + 2) + x + 1
def search(self):
grid = self.grid
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
move_eight = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
ans = 0
for i in range(1, self.h + 1):
for j in range(1, self.w + 1):
# pass # ここから何か書いてね
cx, cy = j, i
if grid[cy][cx] == ".":
ret = self.search_each(cx, cy)
ans = max(ans, ret)
print(ans)
def search_each(self, x, y):
grid = self.grid
d = deque()
d.append((x,y))
dist = [INF for i in range(self.size)]
# print(x,y, self.size, self.pos(x,y))
dist[self.pos(x,y)] = 0
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
ret = 0
while d:
cx, cy = d.pop()
ccos = dist[self.pos(cx, cy)]
ret = max(ret, ccos)
for mv in move:
dx, dy = mv
nx, ny = cx + dx, cy + dy
# print(nx, ny)
if grid[ny][nx] == ".":
if dist[self.pos(nx, ny)] > ccos + 1:
dist[self.pos(nx, ny)] = ccos + 1
d.append((nx, ny))
return max([r for r in dist if r != INF])
def solve():
h, w = getList()
G = TwoDimGrid(h, w)
G.search()
return
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve() | p02803 |
import copy
from collections import deque
H, W = list(map(int, input().split()))
field_s = []
# フィールドを作る
for h in range(H + 2):
field_s.append(["#"] * (W + 2))
if 1 <= h <= (H):
field_s[h][1:-1] = list(map(str, input().rstrip()))
# 動き方のセットを準備
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
# スタートとゴールの座標の組み合わせを作成
sg = []
for y in range(H + 2):
for x in range(W + 2):
if field_s[y][x] == ".":
sg.append([y, x])
# 答え
ans = 0
# スタートとゴールの座標を組み合わせてぐるぐる
for s in sg:
for g in sg:
# startとgoalの座標が同じならスキップ
if s == g:
continue
# fieldの初期化
field = copy.deepcopy(field_s)
# startをキューに追加
que = deque([s])
# startの距離は0に
field[s[0]][s[1]] = 0
# キューに何かがある限り探索を続ける
while que:
c = que.popleft()
# 今の距離
dist = field[c[0]][c[1]]
# 動いた先が「.」なら、距離を記録してキューに追加
for m in moves:
my = c[0] + m[0]
mx = c[1] + m[1]
if field[my][mx] == ".":
field[my][mx] = dist + 1
que.append([my, mx])
else:
continue
# もしゴールに到達していたらansを差し替えてbreak
if [my, mx] == g:
ans = max(ans, field[my][mx])
break
print(ans) | import copy
from collections import deque
H, W = list(map(int, input().split()))
field_s = []
# フィールドを作る
for h in range(H + 2):
field_s.append(["#"] * (W + 2))
if 1 <= h <= (H):
field_s[h][1:-1] = list(map(str, input().rstrip()))
# 動き方のセットを準備
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
# スタート座標を取得
start = []
for y in range(1, H + 1):
for x in range(1, W + 1):
if field_s[y][x] == ".":
start.append([y, x])
# 答え
ans = 0
for s in start:
# fieldの初期化
field = copy.deepcopy(field_s)
# startをキューに追加
que = deque([s])
# startの距離は0に
field[s[0]][s[1]] = 0
# キューに何かがある限り探索を続ける
while que:
c = que.popleft()
# 今の距離
dist = field[c[0]][c[1]]
# 動いた先が「.」なら、距離を記録してキューに追加
for m in moves:
my = c[0] + m[0]
mx = c[1] + m[1]
if field[my][mx] == ".":
field[my][mx] = dist + 1
que.append([my, mx])
else:
continue
# キューを消化したら最大値を取り出す
field = sum(field, [])
ans = max(ans, max([x for x in field if type(x)==int]))
print(ans) | p02803 |
import copy
from collections import deque
H, W = list(map(int, input().split()))
field_s = []
# フィールドを作る
for h in range(H + 2):
field_s.append(["#"] * (W + 2))
if 1 <= h <= (H):
field_s[h][1:-1] = list(map(str, input().rstrip()))
# 動き方のセットを準備
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
# スタート座標を取得
start = []
for y in range(1, H + 1):
for x in range(1, W + 1):
if field_s[y][x] == ".":
start.append([y, x])
# 答え
ans = 0
for s in start:
# fieldの初期化
field = copy.deepcopy(field_s)
# startをキューに追加
que = deque([s])
# startの距離は0に
field[s[0]][s[1]] = 0
# キューに何かがある限り探索を続ける
while que:
c = que.popleft()
# 今の距離
dist = field[c[0]][c[1]]
# 動いた先が「.」なら、距離を記録してキューに追加
for m in moves:
my = c[0] + m[0]
mx = c[1] + m[1]
if field[my][mx] == ".":
field[my][mx] = dist + 1
que.append([my, mx])
else:
continue
# キューを消化したら最大値を取り出す
field = sum(field, [])
ans = max(ans, max([x for x in field if type(x) == int]))
print(ans) | import copy
from collections import deque
def bfs(s, f):
f[s[0]][s[1]] = 0
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
q = deque([s])
while q:
c = q.popleft()
for m in moves:
my, mx = c[0] + m[0], c[1] + m[1]
if f[my][mx] == ".":
f[my][mx] = f[c[0]][c[1]] + 1
q.append([my, mx])
else:
continue
f = sum(f, [])
return max([x for x in f if type(x) == int])
def main():
H, W = list(map(int, input().split()))
field_s = []
for h in range(H + 2):
field_s.append(["#"] * (W + 2))
if 1 <= h <= (H):
field_s[h][1:-1] = list(map(str, input().rstrip()))
start = []
for y in range(1, H + 1):
for x in range(1, W + 1):
if field_s[y][x] == ".":
start.append([y, x])
ans = 0
for s in start:
field = copy.deepcopy(field_s)
ans = max(ans, bfs(s, field))
print(ans)
if __name__ == '__main__':
main() | p02803 |
import copy
from collections import deque
def bfs(s, f):
f[s[0]][s[1]] = 0
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
q = deque([s])
while q:
c = q.popleft()
for m in moves:
my, mx = c[0] + m[0], c[1] + m[1]
if f[my][mx] == ".":
f[my][mx] = f[c[0]][c[1]] + 1
q.append([my, mx])
else:
continue
f = sum(f, [])
return max([x for x in f if type(x) == int])
def main():
H, W = list(map(int, input().split()))
field_s = []
for h in range(H + 2):
field_s.append(["#"] * (W + 2))
if 1 <= h <= (H):
field_s[h][1:-1] = list(map(str, input().rstrip()))
ans = 0
for y in range(1, H + 1):
for x in range(1, W + 1):
if field_s[y][x] == ".":
field = copy.deepcopy(field_s)
ans = max(ans, bfs([y, x], field))
print(ans)
if __name__ == '__main__':
main() | import copy
from collections import deque
def bfs(s, f):
f[s[0]][s[1]] = 0
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
q = deque([s])
while q:
c = q.popleft()
for m in moves:
my, mx = c[0] + m[0], c[1] + m[1]
if f[my][mx] == ".":
f[my][mx] = f[c[0]][c[1]] + 1
q.append([my, mx])
else:
continue
f = sum(f, [])
return max([x for x in f if type(x) == int])
def main():
H, W = list(map(int, input().split()))
field = []
for h in range(H + 2):
field.append(["#"] * (W + 2))
if 1 <= h <= (H):
field[h][1:-1] = list(map(str, input().rstrip()))
ans = 0
for y in range(1, H + 1):
for x in range(1, W + 1):
if field[y][x] == ".":
ans = max(ans, bfs([y, x], copy.deepcopy(field)))
print(ans)
if __name__ == '__main__':
main() | p02803 |
import copy
from collections import deque
def bfs(s, f):
f[s[0]][s[1]] = 0
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
q = deque([s])
while q:
c = q.popleft()
for m in moves:
my, mx = c[0] + m[0], c[1] + m[1]
if f[my][mx] == ".":
f[my][mx] = f[c[0]][c[1]] + 1
q.append([my, mx])
else:
continue
f = sum(f, [])
return max([x for x in f if type(x) == int])
def main():
H, W = list(map(int, input().split()))
field = []
for h in range(H + 2):
field.append(["#"] * (W + 2))
if 1 <= h <= (H):
field[h][1:-1] = list(map(str, input().rstrip()))
ans = 0
for y in range(1, H + 1):
for x in range(1, W + 1):
if field[y][x] == ".":
ans = max(ans, bfs([y, x], copy.deepcopy(field)))
print(ans)
if __name__ == '__main__':
main() | import copy
from collections import deque
def bfs(s, f):
f[s[0]][s[1]] = 0
moves = [[1, 0], [-1, 0], [0, 1], [0, -1]]
q = deque([s])
while q:
c = q.popleft()
for m in moves:
my, mx = c[0] + m[0], c[1] + m[1]
if f[my][mx] == ".":
f[my][mx] = f[c[0]][c[1]] + 1
q.append([my, mx])
goal = [my, mx]
else:
continue
return goal, f[goal[0]][goal[1]]
def main():
H, W = list(map(int, input().split()))
field = []
for h in range(H + 2):
field.append(["#"] * (W + 2))
if 1 <= h <= (H):
field[h][1:-1] = list(map(str, input().rstrip()))
ans = 0
for y in range(1, H + 1):
for x in range(1, W + 1):
if field[y][x] == ".":
goal, tmp_ans = bfs([y, x], copy.deepcopy(field))
ans = max(ans, tmp_ans)
print(ans)
if __name__ == '__main__':
main() | p02803 |
import sys
# import re
# import math
# import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
# import copy
# import heapq
# import decimal
# import statistics
import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 10
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
h, w = ns()
mat = [list(sys.stdin.readline()) for _ in range(h)]
def bfs(x, y):
arrived_mat = [[False for i in range(w)] for j in range(h)]
que = queue.Queue()
que.put((x, y, 1))
arrived_mat[y][x] = True
res = 0
direc = [(0, 1), (0, -1), (1, 0), (-1, 0)]
while que.qsize() > 0:
xi, yi, cnt = que.get()
arrived_mat[yi][xi] = True
for dx, dy in direc:
next_x = xi + dx
next_y = yi + dy
if -1 < next_x < w and -1 < next_y < h:
if mat[next_y][next_x] == "." and arrived_mat[next_y][next_x] != True:
que.put((next_x, next_y, cnt + 1))
res = max(res, cnt + 1)
return res
ans = 0
for y in range(h):
for x in range(w):
if mat[y][x] == ".":
ans = max(ans, bfs(x, y) - 1)
print(ans)
if __name__ == '__main__':
main()
| import sys
# import re
# import math
# import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
# import copy
# import heapq
# import decimal
# import statistics
import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 10
MOD = 10 ** 9 + 7
ni = lambda: int(sys.stdin.readline())
ns = lambda: list(map(int, sys.stdin.readline().split()))
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
h, w = ns()
mat = [list(sys.stdin.readline()) for _ in range(h)]
def bfs(x, y):
arrived_mat = [[False for i in range(w)] for j in range(h)]
que = queue.Queue()
que.put((x, y, 1))
arrived_mat[y][x] = True
res = 0
direc = [(0, 1), (0, -1), (1, 0), (-1, 0)]
while que.qsize() > 0:
xi, yi, cnt = que.get()
for dx, dy in direc:
next_x = xi + dx
next_y = yi + dy
if -1 < next_x < w and -1 < next_y < h:
if mat[next_y][next_x] == "." and arrived_mat[next_y][next_x] != True:
que.put((next_x, next_y, cnt + 1))
arrived_mat[next_y][next_x] = True
res = max(res, cnt + 1)
return res
ans = 0
for y in range(h):
for x in range(w):
if mat[y][x] == ".":
ans = max(ans, bfs(x, y) - 1)
print(ans)
if __name__ == '__main__':
main()
| p02803 |
# すべてのスタートを試し、最大値の最大値を取る
import sys
readline = sys.stdin.readline
H,W = list(map(int,readline().split()))
grid = [readline().rstrip() for i in range(H)]
ans = 0
cases = ((0,1),(0,-1),(1,0),(-1,0))
from collections import deque
for i in range(H):
for j in range(W):
q = deque([[i,j,0]])
visited = [[False] * W for i in range(H)]
while q:
y,x,d = q.popleft()
if grid[y][x] == "#":
continue
if visited[y][x]:
continue
visited[y][x] = True
if d > ans:
ans = d
for c in cases:
if 0 <= y + c[0] < H and 0 <= x + c[1] < W:
q.append([y + c[0],x + c[1],d + 1])
print(ans) | import sys
readline = sys.stdin.readline
H,W = list(map(int,readline().split()))
S = [None] * H
for i in range(H):
S[i] = readline().rstrip()
ans = 0
from collections import deque
cases = ((1,0),(-1,0),(0,1),(0,-1))
for i in range(H):
for j in range(W):
q = deque([[i,j,0]])
seen = set()
while q:
y,x,d = q.popleft()
if S[y][x] == "#":
continue
if (y,x) in seen:
continue
seen.add((y,x))
if d > ans:
ans = d
for c in cases:
if 0 <= y + c[0] < H and 0 <= x + c[1] < W:
q.append([y + c[0], x + c[1], d + 1])
print(ans) | p02803 |
import sys
from collections import deque
from itertools import product
read = sys.stdin.read
readline = sys.stdin.readline
H, W = list(map(int, readline().split()))
S = [list(readline()) for i in range(H)]
def bfs(grid, start):
distance = [[-1] * W for _ in range(H)]
queue = deque([start])
distance[start[0]][start[1]] = 0
while queue:
x, y = queue.popleft()
for i, j in ((1, 0), (-1, 0), (0, 1), (0, -1)):
new_y, new_x = y + j, x + i
if 0 <= new_y < W and 0 <= new_x < H:
if grid[new_x][new_y] == '.' and distance[new_x][new_y] == -1:
distance[new_x][new_y] = distance[x][y] + 1
queue.append((new_x, new_y))
return max(list(map(max, distance)))
answer = 0
for i, j in product(list(range(H)), list(range(W))):
if S[i][j] == '#':
continue
tmp = bfs(S, (i, j))
if tmp > answer:
answer = tmp
print(answer)
| import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
H, W = list(map(int, readline().split()))
S = [list(readline()) for i in range(H)]
def bfs(grid, start):
distance = [[-1] * W for _ in range(H)]
queue = deque([start])
distance[start[0]][start[1]] = 0
while queue:
x, y = queue.popleft()
for i, j in ((1, 0), (-1, 0), (0, 1), (0, -1)):
new_y, new_x = y + j, x + i
if 0 <= new_y < W and 0 <= new_x < H:
if grid[new_x][new_y] == '.' and distance[new_x][new_y] == -1:
distance[new_x][new_y] = distance[x][y] + 1
queue.append((new_x, new_y))
if not queue:
return distance[x][y]
answer = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
tmp = bfs(S, (i, j))
if tmp > answer:
answer = tmp
print(answer)
| p02803 |
import sys
from collections import deque
read = sys.stdin.read
readline = sys.stdin.readline
H, W = list(map(int, readline().split()))
S = tuple(map(tuple, read().split()))
def bfs(grid, start):
distance = [[-1] * W for _ in range(H)]
queue = deque([start])
distance[start[0]][start[1]] = 0
while queue:
x, y = queue.popleft()
for i, j in ((1, 0), (-1, 0), (0, 1), (0, -1)):
new_y, new_x = y + j, x + i
if 0 <= new_y < W and 0 <= new_x < H:
if grid[new_x][new_y] == '.' and distance[new_x][new_y] == -1:
distance[new_x][new_y] = distance[x][y] + 1
queue.append((new_x, new_y))
if not queue:
return distance[x][y]
answer = 0
for i in range(H):
for j in range(W):
if S[i][j] == '#':
continue
tmp = bfs(S, (i, j))
if tmp > answer:
answer = tmp
print(answer)
| import sys
from collections import deque
read = sys.stdin.readline
H, W = list(map(int, input().split()))
S = [list('#' * (W + 2))] + [['#'] + list(read().rstrip()) + ['#'] for _ in range(H)] + [list('#' * (W + 2))]
def bfs(grid, start):
distance = [[-1] * (W + 2) for _ in range(H + 2)]
queue = deque([start])
distance[start[0]][start[1]] = 0
while queue:
x, y = queue.popleft()
for i, j in ((1, 0), (-1, 0), (0, 1), (0, -1)):
new_y, new_x = y + j, x + i
if grid[new_x][new_y] == '.' and distance[new_x][new_y] == -1:
distance[new_x][new_y] = distance[x][y] + 1
queue.append((new_x, new_y))
if not queue:
return distance[x][y]
answer = 0
for i in range(1, H + 1):
for j in range(1, W + 1):
if S[i][j] == '#':
continue
cnt = 0
for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
new_y, new_x = dy + j, dx + i
if S[new_x][new_y] == '.':
cnt += 1
if cnt > 2:
continue
tmp = bfs(S, (i, j))
if tmp > answer:
answer = tmp
print(answer)
| p02803 |
from collections import deque
INF = -1
sizeI, sizeJ = list(map(int, input().split()))
a = [input().rstrip() for _ in range(sizeI)]
def bfs(startI, startJ, targetI, targetJ):
dist = [[INF for _ in range(sizeJ)] for _ in range(sizeI)]
dist[startI][startJ] = 0
q = deque([(startI, startJ)])
while q:
i, j = q.pop()
curDist = dist[i][j]
if (i, j) == (targetI, targetJ):
return curDist
for di, dj in ((1, 0), (-1, 0), (0, 1), (0, -1)):
ni, nj = i + di, j + dj
if 0 <= ni < sizeI and 0 <= nj < sizeJ and dist[ni][nj] == INF and a[ni][nj] == '.':
dist[ni][nj] = 1 + curDist
q.appendleft((ni, nj))
raise Exception
points = []
for i in range(sizeI):
for j in range(sizeJ):
if a[i][j] == '.':
points.append((i, j))
ret = 0
for i in range(len(points) - 1):
for j in range(i + 1, len(points)):
ret = max(ret, bfs(points[i][0], points[i][1], points[j][0], points[j][1]))
print(ret) | from collections import deque
INF = -1
sizeI, sizeJ = list(map(int, input().split()))
a = [input().rstrip() for _ in range(sizeI)]
def bfs(startI, startJ):
dist = [[INF for _ in range(sizeJ)] for _ in range(sizeI)]
dist[startI][startJ] = 0
q = deque([(startI, startJ)])
while q:
i, j = q.pop()
curDist = dist[i][j]
for di, dj in ((1, 0), (-1, 0), (0, 1), (0, -1)):
ni, nj = i + di, j + dj
if 0 <= ni < sizeI and 0 <= nj < sizeJ and dist[ni][nj] == INF and a[ni][nj] == '.':
dist[ni][nj] = 1 + curDist
q.appendleft((ni, nj))
return max([max(row) for row in dist])
ret = -float('inf')
for i in range(sizeI):
for j in range(sizeJ):
if a[i][j] == '.':
ret = max(ret, bfs(i, j))
print(ret) | p02803 |
import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
H,W=mint()
s=[input() for _ in range(H)]
n=dict()
k=0
for i in range(H):
for j in range(W):
if s[i][j]=='.':
n[(i,j)]=k
k+=1
N=len(n)
def solve(s,g):
if s==g:
return 0
q=deque([s])
res=[-1]*N
res[n[s]]=0
while True:
i,j=q.popleft()
for x in [(i+1,j),(i-1,j),(i,j+1),(i,j-1)]:
if x in n and res[n[x]]<0:
res[n[x]]=res[n[(i,j)]]+1
if x==g:
return res[n[x]]
q.append(x)
ans=0
for s in n:
for g in n:
ans=max(ans,solve(s,g))
print(ans)
| import sys
from sys import exit
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7
def lcm(x,y):
return x*y//gcd(x,y)
def lgcd(l):
return reduce(gcd,l)
def llcm(l):
return reduce(lcm,l)
def powmod(n,i,mod):
return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
return x.bit_length()
def div10(x):
return len(str(x))-(x==0)
def intput():
return int(input())
def mint():
return map(int,input().split())
def lint():
return list(map(int,input().split()))
def ilint():
return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
def lprint(l, sep='\n'):
for x in l:
print(x, end=sep)
def ston(c, c0='a'):
return ord(c)-ord(c0)
def ntos(x, c0='a'):
return chr(x+ord(c0))
class counter(dict):
def __init__(self, *args):
super().__init__(args)
def add(self,x,d=1):
self.setdefault(x,0)
self[x] += d
def list(self):
l = []
for k in self:
l.extend([k]*self[k])
return l
class comb():
def __init__(self, n, mod=None):
self.l = [1]
self.n = n
self.mod = mod
def get(self,k):
l,n,mod = self.l, self.n, self.mod
k = n-k if k>n//2 else k
while len(l)<=k:
i = len(l)
l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
return l[k]
def pf(x):
C = counter()
p = 2
while x>1:
k = 0
while x%p==0:
x //= p
k += 1
if k>0:
C.add(p,k)
p = p+2-(p==2) if p*p<x else x
return C
H,W=mint()
S=[input() for _ in range(H)]
ans=0
for s in product(range(H),range(W)):
if S[s[0]][s[1]]=='#':
continue
q=deque([s])
d=[[-1]*W for _ in range(H)]
d[s[0]][s[1]]=0
while len(q)>0:
i,j = q.popleft()
for x,y in [(i-1,j),(i+1,j),(i,j-1),(i,j+1)]:
if 0<=x<H and 0<=y<W and S[x][y]=='.' and d[x][y]<0:
d[x][y]=d[i][j]+1
q.append((x,y))
for i in range(H):
for j in range(W):
ans=max(ans,d[i][j])
print(ans)
| p02803 |
from collections import deque
INF = float("inf")
def MAIN():
n = int(eval(input()))
G = [[i, INF] for i in range(n)]
G[0][1] = 0
m = {}
for _ in range(n):
A = list(map(int, input().split()))
m[A[0]] = {}
for i in range(2, len(A), 2):
m[A[0]][A[i]] = A[i + 1]
dp = deque([0])
while dp:
u = dp.popleft()
for v, c in list(m[u].items()):
if G[v][1] > G[u][1] + c:
G[v][1] = G[u][1] + c
dp.append(v)
print(("\n".join(" ".join(map(str, a)) for a in G)))
MAIN()
| from heapq import heapify, heappush, heappop
INF = float("inf")
def MAIN():
n = int(eval(input()))
G = [[i, INF] for i in range(n)]
G[0][1] = 0
m = {}
for _ in range(n):
A = list(map(int, input().split()))
m[A[0]] = {}
for i in range(2, len(A), 2):
m[A[0]][A[i]] = A[i + 1]
dp = [(0, 0)]
while dp:
cost, u = heappop(dp)
for v, c in list(m[u].items()):
if G[v][1] > G[u][1] + c:
G[v][1] = G[u][1] + c
heappush(dp, (G[v][1], v))
print(("\n".join(" ".join(map(str, a)) for a in G)))
MAIN()
| p02242 |
def dijkstra(s):
global d
color=[0]*n
d=[float('inf')]*n
d[s]=0
while True:
mincost=float('inf')
for i in range(n):
if color[i]!=2 and d[i]<mincost:
mincost=d[i]
u=i
if mincost==float('inf'):
break
color[u]=2
for v in range(n):
if color[v]!=2 and m[u][v]!=0:
if d[u]+m[u][v]<d[v]:
d[v]=d[u]+m[u][v]
color[v]=1
if __name__=='__main__':
n=eval(input())
m=[[0]*n for i in range(n)]
for i in range(n):
en=list(map(int,input().split()))
for j in range(2*en[1]):
if j%2==0:
enid=en[2+j]
else:
m[en[0]][enid]=en[2+j]
dijkstra(0)
for i in range(n):
print(i,d[i]) | import heapq
def dijkstra(s,g,c):
d=[float('inf')]*n
d[s]=0
heapq.heappush(pq,[0,s])
while len(pq)!=0:
t,u=heapq.heappop(pq)
if d[u]<t:
continue
for v in g[u]:
if d[u]+c[u][v]<d[v]:
d[v]=d[u]+c[u][v]
heapq.heappush(pq,[d[v],v])
return d
n=int(input())
g=[[] for _ in range(n)]
cost=[[10**9+5]*n for i in range(n)]
for i in range(n):
en=list(map(int,input().split()))
u=en[0];k=en[1];v=en[2:-1:2];c=en[3::2]
for j in range(k):
g[u].append(v[j])
cost[u][v[j]]=c[j]
pq=[]
dist=dijkstra(0,g,cost)
for i in range(n):
print(i,dist[i]) | p02242 |
import sys
global nodes
nodes = {}
def shortest_path(GRAPH):
global nodes
p1 = 0
nodes[p1][1] = 0;
edge={}
total = 0
mini = 0
while True:
nodes[p1][0]=True
for p2 in range(len(nodes)):
if nodes[p2][0]==False and (p1, p2) in GRAPH:
tmp = nodes[p1][1] + GRAPH[(p1, p2)]
if tmp < nodes[p2][1]:
nodes[p2][1] = tmp
p1 = -1
mini = 1000000
for p2 in range(len(nodes)):
if nodes[p2][0]==False and nodes[p2][1]<mini:
p1 = p2
mini = nodes[p2][1]
if mini == 1000000:
break
return
def resultout():
for i in range(len(nodes)):
print("%d %d" %(i, nodes[i][1]))
return
n = int(input())
x = {}
for i in range(n):
seq = list(map(int,input().split()))
i2 = seq.pop(0)
n2 = seq.pop(0)
for j in range(n2):
j2 = seq.pop(0)
weight = seq.pop(0)
x[(i2, j2)] = weight
nodes[i2] = [False, 1000000]
shortest_path(x)
resultout() | import sys
def shortest_path(GRAPH, distance):
nodes = set()
p1 = 0
distance[p1] = 0
while True:
dp1 = distance[p1]
gp1 = GRAPH[p1]
status[p1]=1
for p2 in list(gp1.keys()):
tmp = gp1[p2] + dp1
if status[p2]==0 and tmp < distance[p2]:
distance[p2] = tmp
nodes.add(p2)
p1 = -1
mini = 1000000
for p2 in nodes:
if distance[p2]<mini:
p1 = p2
mini = distance[p2]
if mini == 1000000:
break
nodes.remove(p1)
return
def resultout(distance):
for i in range(len(distance)):
print("%d %d" %(i, distance[i]))
return
n = int(input())
x = [{} for i in range(n)]
status = [0 for i in range(n)]
distance = [1000000 for i in range(n)]
for i in range(n):
seq = list(map(int, input().split()))
tmp={}
for j in range(2, len(seq), 2):
j2, weight = seq[j:j+2]
tmp[j2] = weight
x[seq[0]] = tmp
status[i] = 0
shortest_path(x, distance)
resultout(distance) | p02242 |
import sys
input = sys.stdin.readline
from collections import Counter
MAX = 2*10**6+100
MOD = 10**9+7
fact = [0]*MAX #fact[i]: i!
inv = [0]*MAX #inv[i]: iの逆元
finv = [0]*MAX #finv[i]: i!の逆元
fact[0] = 1
fact[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fact[i] = fact[i-1]*i%MOD
inv[i] = MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def C(n, r):
if n<r:
return 0
if n<0 or r<0:
return 0
return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD
K = int(eval(input()))
S = input()[:-1]
N = len(S)
ans = 0
for i in range(K+1):
ans += C(N+K-i-1, N-1)*pow(26, i, MOD)*pow(25, K-i, MOD)
ans %= MOD
print(ans) | import sys
input = sys.stdin.readline
MAX = 2*10**6+100
MOD = 10**9+7
fact = [0]*MAX #fact[i]: i!
inv = [0]*MAX #inv[i]: iの逆元
finv = [0]*MAX #finv[i]: i!の逆元
fact[0] = 1
fact[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fact[i] = fact[i-1]*i%MOD
inv[i] = MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def C(n, r):
if n<r:
return 0
if n<0 or r<0:
return 0
return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD
K = int(eval(input()))
S = input()[:-1]
L = len(S)
ans = 0
for i in range(L, L+K+1):
ans += C(i-1, L-1)*pow(25, i-L, MOD)*pow(26, L+K-i, MOD)
ans %= MOD
print(ans) | p02632 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.