input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
from functools import lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class Comb:
def __init__(self, N):
F = [1] * (N + 1)
for i in range(N):
F[i + 1] = (i + 1) * F[i] % mod
self.d_inv = {}
self.d_comb = {}
self.F = F
def inv(self, a):
if a not in self.d_inv:
self.d_inv[a] = pow(a, mod - 2, mod)
return self.d_inv[a]
def comb(self, a, b):
if (a, b) not in self.d_comb:
self.d_comb[(a, b)] = (self.F[a] * self.inv(self.F[a - b]) * self.inv(self.F[b])) % mod
self.d_comb[(a, a - b)] = self.d_comb[(a, b)]
return self.d_comb[(a, b)]
def main():
K = int(eval(input()))
S = input().strip()
F25 = [1] * (K + 1)
F26 = [1] * (K + 1)
for i in range(K):
F25[i + 1] = (25 * F25[i]) % mod
F26[i + 1] = (26 * F26[i]) % mod
comb = Comb(K + len(S) + 1)
res = 0
for k in range(K + 1):
res += ((F25[K - k] * F26[k]) % mod * comb.comb(K - k + len(S) - 1, len(S) - 1)) % mod
res %= mod
print(res)
if __name__ == "__main__":
main()
| import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
from functools import lru_cache
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
class Comb:
def __init__(self, N):
F = [1] * (N + 1)
for i in range(N):
F[i + 1] = (i + 1) * F[i] % mod
self.d_inv = {}
self.d_comb = {}
self.F = F
def inv(self, a):
if a not in self.d_inv:
self.d_inv[a] = pow(a, mod - 2, mod)
return self.d_inv[a]
def comb(self, a, b):
if (a, b) not in self.d_comb:
self.d_comb[(a, b)] = (self.F[a] * self.inv(self.F[a - b]) * self.inv(self.F[b])) % mod
self.d_comb[(a, a - b)] = self.d_comb[(a, b)]
return self.d_comb[(a, b)]
def main():
K = int(eval(input()))
S = input().strip()
F25 = [1] * (K + 2)
F26 = [1] * (K + 2)
T = [1] * (K + 2)
for i in range(K + 1):
F25[i + 1] = (25 * F25[i]) % mod
F26[i + 1] = (26 * F26[i]) % mod
if i != 0:
T[i] = pow(i, mod - 2, mod)
r = 1
res = 0
for k in range(K + 1):
res += ((F25[k] * F26[K - k]) % mod * r) % mod
r *= (len(S) - 1 + k + 1)
r %= mod
r *= T[k + 1]
r %= mod
res %= mod
print(res)
if __name__ == "__main__":
main()
| p02632 |
import sys
import math
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
K = int(eval(input()))
S = input().strip()
MOD = 10 ** 9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
def cmb(n, k, p):
if (k < 0) or (n < k):
return 0
r = min(k, n - k)
return fact[n] * factinv[k] * factinv[n - k] % p
N = 10 ** 6 * 2
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
ans = 0
for i in range(K + 1):
if len(S) == 1:
ans += pow(25, i, MOD) * pow(26, K - i, MOD)
else:
ans += pow(25, i, MOD) * cmb(i + len(S) - 1, len(S) - 1, MOD) * pow(26, K - i, MOD)
print((ans % MOD))
if __name__ == '__main__':
main()
| import sys
import math
import collections
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
K = int(eval(input()))
S = input().strip()
MOD = 10 ** 9 + 7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
def cmb(n, k, p):
if (k < 0) or (n < k):
return 0
r = min(k, n - k)
return fact[n] * factinv[k] * factinv[n - k] % p
N = 10 ** 6 * 2
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
factinv.append((factinv[-1] * inv[-1]) % MOD)
ans = 0
a = 1
b = pow(26, K, MOD)
for i in range(K + 1):
ans += a * cmb(i + len(S) - 1, len(S) - 1, MOD) * b
a = a * 25 % MOD
b = b * pow(26, MOD - 2, MOD) % MOD
print((ans % MOD))
if __name__ == '__main__':
main()
| p02632 |
# coding: utf-8
import sys
from math import factorial
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
def nCr(n,r):
return (factorial(n) // factorial(r) // factorial(n - r))
def main():
k = ni()
s = ns()
n = len(s)
mod = 1000000007
ans = 0
tmp1 = factorial(n+k)%mod
tmp2 = 1
tmp3 = tmp1
for m in range(n):
ans += ((nCr(n+k,m)%mod)*pow(25,n+k-m,mod))%mod
ans = pow(26,n+k,mod) - ans
ans %= mod
print(ans)
return
if __name__ == '__main__':
main()
| # coding: utf-8
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
def main():
k = ni()
s = ns()
n = len(s)
mod = 1000000007
ans = 0
inv25 = pow(25, mod-2, mod)
tmp1 = 1
tmp2 = pow(25,n+k,mod)
for m in range(n):
ans += (tmp1*tmp2)%mod
ans %= mod
tmp1 *= (n+k-m)*pow(m+1,mod-2,mod)
tmp2 *= inv25
tmp1 %= mod
tmp2 %= mod
ans = pow(26,n+k,mod) - ans
ans %= mod
print(ans)
return
if __name__ == '__main__':
main() | p02632 |
MOD = 10**9+7
factorial = [1]
inverse_factorial = [0]
def modpow(a, p):
ans = 1
while p:
if p&1 == 1:
ans = (ans*a)%MOD
a = (a*a)%MOD
p >>= 1
return ans
def nCr(n, r):
if r == 0 or r == n:
return 1
return (((factorial[n]*inverse_factorial[n-r])%MOD)*inverse_factorial[r])%MOD
def init_nCr(max_n):
for i in range(1, 2*max_n+1):
f = (factorial[-1]*i)%MOD
factorial.append(f)
inv_f = modpow(f, MOD-2)
inverse_factorial.append(inv_f)
def pow(b, p):
ans = 1
for _ in range(p):
ans = (ans*b)%MOD
return ans
def pow_list(b, p):
ans = [1]
for _ in range(p):
ans.append(ans[-1]*b)
return ans
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
K = read_int()
S = len(input().strip())
init_nCr(K+S)
T = pow(26, K+S)
pow_25 = pow_list(25, K+S)
for i in range(S):
T = (T-nCr(K+S, i)*pow_25[K+S-i])%MOD
return T
if __name__ == '__main__':
print((solve()))
|
MOD = 10**9+7
factorial = [1]
inverse_factorial = [0]
def modpow(a, p):
ans = 1
while p:
if p&1 == 1:
ans = (ans*a)%MOD
a = (a*a)%MOD
p >>= 1
return ans
def nCr(n, r):
if r == 0 or r == n:
return 1
return (((factorial[n]*inverse_factorial[n-r])%MOD)*inverse_factorial[r])%MOD
def init_nCr(max_n):
for i in range(1, max_n+1):
f = (factorial[-1]*i)%MOD
factorial.append(f)
inv_f = modpow(f, MOD-2)
inverse_factorial.append(inv_f)
def pow(b, p):
ans = 1
for _ in range(p):
ans = (ans*b)%MOD
return ans
def pow_list(b, p):
ans = [1]
for _ in range(p):
ans.append((ans[-1]*b)%MOD)
return ans
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
K = read_int()
S = len(input().strip())
init_nCr(K+S)
T = pow(26, K+S)
pow_25 = pow_list(25, K+S)
for i in range(S):
T = (T-(nCr(K+S, i)*pow_25[K+S-i])%MOD)%MOD
return T
if __name__ == '__main__':
print((solve()))
| p02632 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
K = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
s=input()
ls=len(s)
tot=pow(26,ls+K,mod)
N=ls+K
fact=[0]*(N+1)#NはnCrの最大のn
ifact=[0]*(N+1)
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=pow(x,mod-2,mod)
pows=[1]*(N+1)
for i in range(1,N+1):
pows[i]=pows[i-1]*25%mod
def comb(n,r): return (fact[n]*ifact[r]%mod)*ifact[n-r]%mod
for i in range(0,ls):
tot-=comb(ls+K,i)*pows[ls+K-i]
tot%=mod
print(tot)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
K = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
s=input()
ls=len(s)
tot=pow(26,ls+K,mod)
def extgcd1(a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t=a//b; a-=t*b; a,b=b,a; u,v=v,u-t*v
if a!=1: return -1#互いに素じゃない
return u%b0
N=ls+K
fact=[0]*(N+1)#NはnCrの最大のn
ifact=[0]*(N+1)
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=extgcd1(x,mod)
pows=[1]*(N+1)
for i in range(1,N+1):
pows[i]=pows[i-1]*25%mod
def comb(n,r): return (fact[n]*ifact[r]%mod)*ifact[n-r]%mod
for i in range(0,ls):
tot-=comb(ls+K,i)*pows[ls+K-i]
tot%=mod
print(tot)
if __name__ == "__main__":
main()
| p02632 |
#!/usr/bin/env python3
import sys
from functools import lru_cache
sys.setrecursionlimit(1_000_002)
MOD = 1000000007 # type: int
def solve(K: int, S: str):
'''
>>> solve(1, 'a')
51
'''
N = len(S)
mf = ModFactorial(MOD, N+K+1)
ans = 0
for k in range(K+1):
ans = (ans + mf.combination(k+N-1, k) * pow(25, k, MOD) % MOD * pow(26, K-k, MOD)) % MOD
return ans
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
S = next(tokens) # type: str
print((solve(K, S)))
def mod_range(mod, start, stop=None, step=1):
if stop == None:
stop = start
start = 0
return [i % mod for i in range(start, stop, step)]
def mod_inv(mod, n):
'''
>>> mod_inv(3, 2)
2
>>> mod_inv(1000000007, 2)
500000004
'''
return pow(n, mod-2, mod)
def mod_permutation(mod, n, r):
'''
>>> mod_permutation(1000000007, 10, 2)
90
>>> mod_permutation(7, 10, 2)
6
'''
m = 1
for i in mod_range(mod, n-r+1, n+1):
m = (m * i) % mod
return m
def mod_factorial(mod, n):
'''
>>> mod_factorial(1000000007, 10)
3628800
>>> mod_factorial(7, 6)
6
'''
return mod_permutation(mod, n, n)
def mod_combination(mod, n, r):
'''
>>> mod_combination(1000000007, 10, 2)
45
>>> mod_combination(7, 10, 2)
3
'''
return mod_permutation(mod, n, r) * mod_inv(mod, mod_factorial(mod, r)) % mod
class ModFactorial:
def __init__(self, mod, size=1):
'''
>>> ModFactorial(7, 7)
Traceback (most recent call last):
...
AssertionError
'''
assert mod > size
self._mod = mod
self._init_factorials(size)
def _mod_range(self, start, stop=None, step=1):
return mod_range(self._mod, start, stop, step)
def _mod_inv(self, n):
return mod_inv(self._mod, n)
def _init_factorials(self, size):
'''
>>> mf1 = ModFactorial(1000000007)
>>> mf2 = ModFactorial(1000000007, 10)
>>> mf1.factorial(10) == mf2.factorial(10)
True
'''
self._factorials = [1] * size
n = 1 # リストの参照は遅いので減らす
for i, m in enumerate(self._mod_range(1, size), 1):
n = (n * m) % self._mod
self._factorials[i] = n
def _append_factorials(self, n):
for m in [i % self._mod for i in range(len(self._factorials), n+1)]:
self._factorials.append((self._factorials[-1] * m) % self._mod)
def factorial(self, n):
'''
>>> ModFactorial(1000000007).factorial(10)
3628800
>>> ModFactorial(7).factorial(6)
6
>>> ModFactorial(7).factorial(7)
Traceback (most recent call last):
...
AssertionError
'''
assert n < self._mod
if len(self._factorials) <= n:
self._append_factorials(n)
return self._factorials[n]
def factorial_inv(self, n):
'''
>>> MOD = 1000000007
>>> mf = ModFactorial(MOD)
>>> mf.factorial_inv(10)
283194722
>>> mf.factorial_inv(10) * mf.factorial(10) % MOD
1
>>> MOD = 7
>>> mf = ModFactorial(MOD)
>>> mf.factorial_inv(6)
6
>>> mf.factorial_inv(6) * mf.factorial(6) % MOD
1
'''
return self._mod_inv(self.factorial(n))
def permutation(self, n, r):
'''
>>> ModFactorial(1000000007).permutation(10, 2)
90
'''
return self.factorial(n) * self.factorial_inv(n-r) % self._mod
def combination(self, n, r):
'''
>>> ModFactorial(1000000007).combination(10, 2)
45
'''
return self.permutation(n, r) * self.factorial_inv(r) % self._mod
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
| #!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
def solve(K: int, S: str):
'''
>>> solve(1, 'a')
51
'''
N = len(S)
mf = ModFactorial(MOD, N+K+1)
ans = 0
for k in range(K+1):
ans = (ans + mf.combination(k+N-1, k) * pow(25, k, MOD) % MOD * pow(26, K-k, MOD)) % MOD
return ans
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
K = int(next(tokens)) # type: int
S = next(tokens) # type: str
print((solve(K, S)))
def mod_range(mod, start, stop=None, step=1):
if stop == None:
stop = start
start = 0
return [i % mod for i in range(start, stop, step)]
def mod_inv(mod, n):
'''
>>> mod_inv(3, 2)
2
>>> mod_inv(1000000007, 2)
500000004
'''
return pow(n, mod-2, mod)
def mod_permutation(mod, n, r):
'''
>>> mod_permutation(1000000007, 10, 2)
90
>>> mod_permutation(7, 10, 2)
6
'''
m = 1
for i in mod_range(mod, n-r+1, n+1):
m = (m * i) % mod
return m
def mod_factorial(mod, n):
'''
>>> mod_factorial(1000000007, 10)
3628800
>>> mod_factorial(7, 6)
6
'''
return mod_permutation(mod, n, n)
def mod_combination(mod, n, r):
'''
>>> mod_combination(1000000007, 10, 2)
45
>>> mod_combination(7, 10, 2)
3
'''
return mod_permutation(mod, n, r) * mod_inv(mod, mod_factorial(mod, r)) % mod
class ModFactorial:
def __init__(self, mod, size=1):
'''
>>> ModFactorial(7, 7)
Traceback (most recent call last):
...
AssertionError
'''
assert mod > size
self._mod = mod
self._init_factorials(size)
def _mod_range(self, start, stop=None, step=1):
return mod_range(self._mod, start, stop, step)
def _mod_inv(self, n):
return mod_inv(self._mod, n)
def _init_factorials(self, size):
'''
>>> mf1 = ModFactorial(1000000007)
>>> mf2 = ModFactorial(1000000007, 10)
>>> mf1.factorial(10) == mf2.factorial(10)
True
'''
self._factorials = [1] * size
n = 1 # リストの参照は遅いので減らす
for i, m in enumerate(self._mod_range(1, size), 1):
n = (n * m) % self._mod
self._factorials[i] = n
def _append_factorials(self, n):
for m in [i % self._mod for i in range(len(self._factorials), n+1)]:
self._factorials.append((self._factorials[-1] * m) % self._mod)
def factorial(self, n):
'''
>>> ModFactorial(1000000007).factorial(10)
3628800
>>> ModFactorial(7).factorial(6)
6
>>> ModFactorial(7).factorial(7)
Traceback (most recent call last):
...
AssertionError
'''
assert n < self._mod
if len(self._factorials) <= n:
self._append_factorials(n)
return self._factorials[n]
def factorial_inv(self, n):
'''
>>> MOD = 1000000007
>>> mf = ModFactorial(MOD)
>>> mf.factorial_inv(10)
283194722
>>> mf.factorial_inv(10) * mf.factorial(10) % MOD
1
>>> MOD = 7
>>> mf = ModFactorial(MOD)
>>> mf.factorial_inv(6)
6
>>> mf.factorial_inv(6) * mf.factorial(6) % MOD
1
'''
return self._mod_inv(self.factorial(n))
def permutation(self, n, r):
'''
>>> ModFactorial(1000000007).permutation(10, 2)
90
'''
return self.factorial(n) * self.factorial_inv(n-r) % self._mod
def combination(self, n, r):
'''
>>> ModFactorial(1000000007).combination(10, 2)
45
'''
return self.permutation(n, r) * self.factorial_inv(r) % self._mod
def test():
import doctest
doctest.testmod()
if __name__ == '__main__':
#test()
main()
| p02632 |
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
K = ri()
S = rs()
class CombMod:
def __init__(self, N):
self.fact = [1]
self.rfact = [1]
for i in range(1, N+1):
self.fact.append(self.fact[i-1]*i % mod)
self.rfact.append(pow(self.fact[i], mod-2, mod))
def comb(self, n, k):
return self.fact[n]*self.rfact[k]*self.rfact[n-k] % mod
N = len(S)
cm = CombMod(K+N)
ans = 0
for i in range(K+1):
ans += cm.comb(K+N-i-1, N-1) * pow(26, i, mod) * pow(25, K-i, mod)
ans = ans % mod
print(ans)
| import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(eval(input()))
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
K = ri()
S = rs()
class CombMod:
def __init__(self, N):
self.fact = [1]
self.rfact = [1]
for i in range(1, N+1):
self.fact.append(self.fact[i-1]*i % mod)
self.rfact.append(pow(self.fact[i], mod-2, mod))
def comb(self, n, k):
return self.fact[n]*self.rfact[k]*self.rfact[n-k] % mod
N = len(S)
cm = CombMod(K+N)
pows = [1]
pows2 = [1]
p = 1
p2 = 1
for i in range(K+1):
p = (p * 25) % mod
p2 = (p2 * 26) % mod
pows.append(p)
pows2.append(p2)
#print(pows)
ans = 0
for i in range(K+1):
#ans += cm.comb(K+N-i-1, N-1) * pow(26, i, mod) * pow(25, K-i, mod)
ans += cm.comb(K+N-i-1, N-1) * pows2[i] * pows[K-i]
ans = ans % mod
print(ans)
| p02632 |
def main():
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
# "n 要素" は区別できる n 要素
# "k グループ" はちょうど k グループ
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def C(self, n, r):
if not 0 <= r <= n:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def P(self, n, r):
if not 0 <= r <= n:
return 0
return self.fac[n] * self.facinv[n-r] % self.mod
def H(self, n, r):
if (n == 0 and r > 0) or r < 0:
return 0
return self.fac[n+r-1] * self.facinv[r] % self.mod * self.facinv[n-1] % self.mod
def rising_factorial(self, n, r): # 上昇階乗冪 n * (n+1) * ... * (n+r-1)
return self.fac[n+r-1] * self.facinv[n-1] % self.mod
def stirling_first(self, n, k): # 第 1 種スターリング数 lru_cache を使うと O(nk) # n 要素を k 個の巡回列に分割する場合の数
if n == k:
return 1
if k == 0:
return 0
return (self.stirling_first(n-1, k-1) + (n-1)*self.stirling_first(n-1, k)) % self.mod
def stirling_second(self, n, k): # 第 2 種スターリング数 O(k + log(n)) # n 要素を区別のない k グループに分割する場合の数
if n == k:
return 1 # n==k==0 のときのため
return self.facinv[k] * sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def balls_and_boxes_3(self, n, k): # n 要素を区別のある k グループに分割する場合の数 O(k + log(n))
return sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def bernoulli(self, n): # ベルヌーイ数 lru_cache を使うと O(n**2 * log(mod))
if n == 0:
return 1
if n % 2 and n >= 3:
return 0 # 高速化
return (- pow(n+1, self.mod-2, self.mod) * sum(self.C(n+1, k) * self.bernoulli(k) % self.mod for k in range(n))) % self.mod
def faulhaber(self, k, n): # べき乗和 0^k + 1^k + ... + (n-1)^k
# bernoulli に lru_cache を使うと O(k**2 * log(mod)) bernoulli が計算済みなら O(k * log(mod))
return pow(k+1, self.mod-2, self.mod) * sum(self.C(k+1, j) * self.bernoulli(j) % self.mod * pow(n, k-j+1, self.mod) % self.mod for j in range(k+1)) % self.mod
def lah(self, n, k): # n 要素を k 個の空でない順序付き集合に分割する場合の数 O(1)
return self.C(n-1, k-1) * self.fac[n] % self.mod * self.facinv[k] % self.mod
def bell(self, n, k): # n 要素を k グループ以下に分割する場合の数 O(k**2 + k*log(mod))
return sum(self.stirling_second(n, j) for j in range(1, k+1)) % self.mod
k = int(readline())
s = readline().rstrip().decode()
n = len(s)
ans = 0
mod = 10 ** 9 + 7
comb = Combination(n + k)
for i in range(k + 1):
ans += comb(n + k, i) * pow(25, i, mod)
ans %= mod
print(ans)
if __name__ == '__main__':
main()
| def main():
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
class Combination:
def __init__(self, n_max, mod=10**9+7):
# O(n_max + log(mod))
self.mod = mod
f = 1
self.fac = fac = [f]
for i in range(1, n_max+1):
f = f * i % mod
fac.append(f)
f = pow(f, mod-2, mod)
self.facinv = facinv = [f]
for i in range(n_max, 0, -1):
f = f * i % mod
facinv.append(f)
facinv.reverse()
# "n 要素" は区別できる n 要素
# "k グループ" はちょうど k グループ
def __call__(self, n, r): # self.C と同じ
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def C(self, n, r):
if not 0 <= r <= n:
return 0
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def P(self, n, r):
if not 0 <= r <= n:
return 0
return self.fac[n] * self.facinv[n-r] % self.mod
def H(self, n, r):
if (n == 0 and r > 0) or r < 0:
return 0
return self.fac[n+r-1] * self.facinv[r] % self.mod * self.facinv[n-1] % self.mod
def rising_factorial(self, n, r): # 上昇階乗冪 n * (n+1) * ... * (n+r-1)
return self.fac[n+r-1] * self.facinv[n-1] % self.mod
def stirling_first(self, n, k): # 第 1 種スターリング数 lru_cache を使うと O(nk) # n 要素を k 個の巡回列に分割する場合の数
if n == k:
return 1
if k == 0:
return 0
return (self.stirling_first(n-1, k-1) + (n-1)*self.stirling_first(n-1, k)) % self.mod
def stirling_second(self, n, k): # 第 2 種スターリング数 O(k + log(n)) # n 要素を区別のない k グループに分割する場合の数
if n == k:
return 1 # n==k==0 のときのため
return self.facinv[k] * sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def balls_and_boxes_3(self, n, k): # n 要素を区別のある k グループに分割する場合の数 O(k + log(n))
return sum((-1)**(k-m) * self.C(k, m) * pow(m, n, self.mod) for m in range(1, k+1)) % self.mod
def bernoulli(self, n): # ベルヌーイ数 lru_cache を使うと O(n**2 * log(mod))
if n == 0:
return 1
if n % 2 and n >= 3:
return 0 # 高速化
return (- pow(n+1, self.mod-2, self.mod) * sum(self.C(n+1, k) * self.bernoulli(k) % self.mod for k in range(n))) % self.mod
def faulhaber(self, k, n): # べき乗和 0^k + 1^k + ... + (n-1)^k
# bernoulli に lru_cache を使うと O(k**2 * log(mod)) bernoulli が計算済みなら O(k * log(mod))
return pow(k+1, self.mod-2, self.mod) * sum(self.C(k+1, j) * self.bernoulli(j) % self.mod * pow(n, k-j+1, self.mod) % self.mod for j in range(k+1)) % self.mod
def lah(self, n, k): # n 要素を k 個の空でない順序付き集合に分割する場合の数 O(1)
return self.C(n-1, k-1) * self.fac[n] % self.mod * self.facinv[k] % self.mod
def bell(self, n, k): # n 要素を k グループ以下に分割する場合の数 O(k**2 + k*log(mod))
return sum(self.stirling_second(n, j) for j in range(1, k+1)) % self.mod
k = int(readline())
s = readline().rstrip().decode()
n = len(s)
ans = 0
mod = 10 ** 9 + 7
comb = Combination(n + k)
v = 1
for i in range(k + 1):
ans += comb(n + k, i) * v
ans %= mod
v *= 25
v %= mod
print(ans)
if __name__ == '__main__':
main()
| p02632 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
K = NI()
S = SI()
LS = len(S)
f = [1]
r = [1]
c = 1
for i in range(1, K + LS +1):
c = (c * i) % MOD
f.append(c)
r.append(pow(c, MOD - 2, MOD))
def comb(n, k):
return (f[n] * r[k] * r[n - k]) % MOD
ans = 0
for i in range(K+1):
ans = (ans + pow(25,i,MOD) * pow(26,K-i,MOD) * comb(i+LS-1,LS-1)) % MOD
print(ans)
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
K = NI()
S = SI()
LS = len(S)
f = [1] * (K+LS)
r = [1] * (K+LS)
c = 1
for i in range(1, K + LS):
c = (c * i) % MOD
f[i] = c
r[i] = pow(c, MOD - 2, MOD)
def comb(n, k):
return (f[n] * r[k] * r[n - k]) % MOD
ans = 0
for i in range(K+1):
ans = (ans + pow(25,i,MOD) * pow(26,K-i,MOD) * comb(i+LS-1,LS-1)) % MOD
print(ans)
if __name__ == '__main__':
main() | p02632 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
K = NI()
S = SI()
LS = len(S)
f = [1] * (K+LS)
r = [1] * (K+LS)
c = 1
for i in range(1, K + LS):
c = (c * i) % MOD
f[i] = c
r[i] = pow(c, MOD - 2, MOD)
def comb(n, k):
return (f[n] * r[k] * r[n - k]) % MOD
ans = 0
for i in range(K+1):
ans = (ans + pow(25,i,MOD) * pow(26,K-i,MOD) * comb(i+LS-1,LS-1)) % MOD
print(ans)
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
K = NI()
S = SI()
LS = len(S)
f = [0] * (K+LS)
r = [0] * (K+LS)
f[0] = 1
r[0] = 1
c = 1
for i in range(1, K + LS):
c = (c * i) % MOD
f[i] = c
r[i] = pow(c, MOD - 2, MOD)
def comb(n, k):
return (f[n] * r[k] * r[n - k]) % MOD
ans = 0
for i in range(K+1):
ans = (ans + pow(25,i,MOD) * pow(26,K-i,MOD) * comb(i+LS-1,LS-1)) % MOD
print(ans)
if __name__ == '__main__':
main() | p02632 |
import sys
K = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip('\n')
# ## COMBINATION (MOD) ###
N_MAX = 2*10**6 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
fac = [1, 1] # 元テーブル
facinv = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N_MAX + 1):
fac.append((fac[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
facinv.append((facinv[-1] * inv[-1]) % MOD)
def cmb(n, r):
if (r < 0 or r > n):
return 0
# r = min(r, n-r)
return fac[n] * facinv[r] * facinv[n - r] % MOD
# K 文字追加
ans = 0
ln = len(S)
for i in range(ln, ln+K+1):
# pre
p = i - 1
p1 = cmb(p, ln - 1)
p2 = pow(25, p - (ln - 1), MOD)
# suf
s = (ln + K) - i
s2 = pow(26, s, MOD)
ans += p1*p2*s2 % MOD
ans %= MOD
# print(p, p1,p2, s, s2)
print(ans) | import sys
K = int(sys.stdin.readline())
S = sys.stdin.readline().rstrip('\n')
# ## COMBINATION (MOD) ###
N_MAX = 10**6 # 問題サイズに合わせて変えておく
MOD = 10**9 + 7
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N_MAX + 2):
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
# K 文字追加
ans = 0
ln = len(S)
p1 = 1
p2 = 1
s2 = pow(26, K, MOD)
for i in range(1, K + 2):
ans += (p1 * p2 * s2) % MOD
ans %= MOD
# print(p1, p2, s2)
# pre
p1 = (p1 * (ln + i - 1) * inv[i]) % MOD
p2 = (p2 * 25) % MOD
# suf
s2 = (s2 * inv[26]) % MOD
print(ans)
| p02632 |
import sys
readline = sys.stdin.readline
P = 10 ** 9 + 7
def mod_prod(a,b):
return (a % P) * (b % P) % P
def mod_fact(a):
ret = 1
for i in range(a):
ret = ret * (i + 1) % P
return ret
def mod_pow(a, n):
ret = 1
while n > 0:
if n % 2 == 1:
ret = ret * a % P
a = a * a % P
n = n >> 1
return ret
def mod_div(a, b):
b_inv = mod_pow(b, P - 2)
return a * b_inv % P
def mod_comb(a,b):
ret = 1
b = min(b, a - b)
for i in range(b):
ret *= a - i
ret %= P
ret = mod_div(ret, mod_fact(b))
return ret
def solve():
K = int(readline())
S = readline().rstrip()
N = len(S)
ans = 0
for i in range(K + 1):
ans += mod_pow(25, i) * mod_comb(i+N-1, i) * mod_pow(26, K-i)
ans %= P
print(ans)
solve() | import sys
readline = sys.stdin.readline
P = 10 ** 9 + 7
def mod_prod(a,b):
return (a % P) * (b % P) % P
def mod_fact(a):
ret = 1
for i in range(a):
ret = ret * (i + 1) % P
return ret
def mod_pow(a, n):
ret = 1
while n > 0:
if n % 2 == 1:
ret = ret * a % P
a = a * a % P
n = n >> 1
return ret
def mod_div(a, b):
b_inv = mod_pow(b, P - 2)
return a * b_inv % P
def mod_comb(a,b):
ret = 1
b = min(b, a - b)
for i in range(b):
ret *= a - i
ret %= P
ret = mod_div(ret, mod_fact(b))
return ret
def solve():
K = int(readline())
S = readline().rstrip()
N = len(S)
ans = 0
cb = 1
for i in range(K + 1):
ans += mod_pow(25, i) * cb * mod_pow(26, K-i)
cb = cb * mod_div(i + N - 1 + 1, i + 1) % P
# mod_comb(i+N-1, i)
ans %= P
print(ans)
solve() | p02632 |
N,M,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
q = list(map(int,input().split()))
t = [ 1 for i in range(N) ]
i = 0
for m in range(M):
if a[m] % 2 == 1:
s = -1
else:
s = 1
aa = a[m]
while aa > 0:
i = (i + s) % N
if t[i] == 1:
aa -= 1
t[i] = 0
while True:
i = (i + 1) % N
if t[i] == 1:
break;
for i in q:
print((t[i]))
| N,M,Q = list(map(int,input().split()))
a = list(map(int,input().split()))
q = list(map(int,input().split()))
t = [ i for i in range(N) ]
n = N
i = 0
for aa in a:
if aa % 2 == 1:
i = (i - aa) % n
else:
i = (i + aa) % n
del t[i]
n -= 1
for i in q:
if i in t:
print((1))
else:
print((0))
| p00296 |
from bisect import bisect_left as bl
n, m, q = list(map(int, input().split()))
lst = [i for i in range(n)]
alst = list(map(int, input().split()))
ind = 0
for a in alst:
if a % 2 == 0:
ind += a
else:
ind -= a
ind = ind % len(lst)
lst.pop(ind)
ind = ind % len(lst)
qlst = list(map(int, input().split()))
for q in qlst:
qi = bl(lst, q)
if qi >= len(lst):
print((0))
else:
print((int(lst[qi] == q)))
| from bisect import bisect_left as bl
n, m, q = list(map(int, input().split()))
lst = [i for i in range(n)]
alst = list(map(int, input().split()))
ind = 0
for a in alst:
if a % 2 == 0:
ind += a
else:
ind -= a
ind = ind % len(lst)
lst.pop(ind)
ind = ind % len(lst)
qlst = list(map(int, input().split()))
for q in qlst:
print((int(q in lst)))
| p00296 |
import sys
f = sys.stdin
def is_odd(num):
return num % 2
n,_,_ = list(map(int,f.readline().split()))#_は読み飛ばし
a = list(map(int, f.readline().split()))
q = list(map(int, f.readline().split()))
students = list(range(n))
pos = 0
for ai in a:
pos += -ai if is_odd(ai) else ai
pos %= len(students)
students = students[:pos] + students[pos + 1:]
for qi in q:
print((1 if qi in students else 0)) | import sys
f = sys.stdin
def is_odd(num):
return num % 2
n,_,_ = list(map(int,f.readline().split()))#_は読み飛ばし
a = list(map(int, f.readline().split()))
q = list(map(int, f.readline().split()))
s = list(range(n))
pos = 0
for ai in a:
pos += -ai if is_odd(ai) else ai
pos %= len(s)
s.pop(pos)
for qi in q:
print((1 if qi in s else 0)) | p00296 |
n, m, _ = list(map(int, input().split()))
n0 = n
exem = [1] * n0
i = 0
for a in map(int, input().split()):
is_even = not a & 1
a %= n
if is_even: a = n - a
c = 0
while a:
c += 1
if exem[i - c]:
a -= 1
exem[i - c] = 0
i = (i - c + 1) % n0
n -= 1
for q in map(int, input().split()):
print((exem[q])) | n, m, _ = list(map(int, input().split()))
exem = list(range(n))
i = 0
for a in map(int, input().split()):
is_odd = a & 1
i += -a if a & 1 else a
i %= n
exem.pop(i)
n -= 1
for q in map(int, input().split()):
print((int(q in exem))) | p00296 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0301
WA
"""
import sys
from sys import stdin
from collections import deque
input = stdin.readline
def main(args):
# members = deque(list(range(10)))
# numbers = [2, 6, 5, 18, 3]
# queries = [3, 0, 5]
N, M, Q = list(map(int, input().split(' ')))
members = deque(list(range(N)))
numbers = [int(x) for x in input().split(' ')]
queries = [int(x) for x in input().split(' ')]
for n in numbers:
if n % 2 == 0:
n = n % N
members.rotate(-n)
members.popleft()
else:
n = n % N
members.rotate(n)
members.popleft()
N -= 1
for q in queries:
ans = 1 if q in members else 0
print(ans)
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0301
"""
import sys
from sys import stdin
from collections import deque
input = stdin.readline
def main(args):
# members = deque(list(range(10)))
# numbers = [2, 6, 5, 18, 3]
# queries = [3, 0, 5]
N, M, Q = list(map(int, input().split(' ')))
members = deque(list(range(N)))
numbers = [int(x) for x in input().split(' ')]
queries = [int(x) for x in input().split(' ')]
for n in numbers:
if n % 2 == 0:
# n = n % N
members.rotate(-n)
members.popleft()
else:
# n = n % N
members.rotate(n)
members.popleft()
N -= 1
for q in queries:
ans = 1 if q in members else 0
print(ans)
if __name__ == '__main__':
main(sys.argv[1:]) | p00296 |
from heapq import *
class MultisetBIT:
"""
最大値が小さい数について、その重複を許した集合を管理する。
最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
閉区間で管理する。
"""
# __slots__ = ["n", "k", "data"]
def __init__(self, maxvalue):
"内部では [1, maxvalue + 1] でもつ。"
self.n = maxvalue + 1
self.k = 1 << ((self.n + 1).bit_length() - 1)
self.data = [0] * (self.n + 1)
def add(self, value):
"""
与えられた引数を Multiset に加える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
while value <= self.n:
self.data[value] += 1
value += value & -value
def pop(self, value):
"""
Multiset から与えられた引数を取り除く。
与えられた引数が Multiset に入っているかのチェックは行わなず、
単にその個数を 1 減らすだけなので注意。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
while value <= self.n:
self.data[value] -= 1
value += value & -value
def count_le(self, value):
"""
Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
ret = 0
while value > 0:
ret += self.data[value]
value -= value & -value
return ret
def count(self, first, last):
"""
Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
last += 1
ret = 0
while first < last:
ret += self.data[last]
last -= last & -last
while last < first:
ret -= self.data[first]
first -= first & -first
return ret
def bisect(self, count):
"""
Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
ret = 0
k = self.k
while k > 0:
if ret + k <= self.n and self.data[ret + k] < count:
count -= self.data[ret + k]
ret += k
k >>= 1
return ret
def lower_bound(self, value):
"""
Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
return self.bisect(self.count_le(value - 1) + 1)
def upper_bound(self, value):
"""
Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
return self.bisect(self.count_le(value) + 1)
H, W = list(map(int, input().split()))
destination = MultisetBIT(W)
for i in range(W):
destination.add(i)
destination_to_cost = {i:0 for i in range(W)}
min_heapq = [0] * W
to_delete = []
for k in range(H):
# print([i for i in range(W) if destination.count(i, i)])
# print(destination_to_cost)
A, B = list(map(int, input().split()))
A -= 1
B -= 1
start_point = destination.lower_bound(A)
point = start_point
change_dest_flg = False
while point < W and point < B + 1:
change_dest_flg = True
cost = destination_to_cost.pop(point)
heappush(to_delete, cost)
if B + 1 != W:
if (B + 1 in destination_to_cost):
if destination_to_cost[B+1] > (B + 1 - point) + cost:
heappush(to_delete, destination_to_cost[B+1])
destination_to_cost[B+1] = (B + 1 - point) + cost
heappush(min_heapq, (B + 1 - point) + cost)
else:
destination_to_cost[B+1] = (B + 1 - point) + cost
heappush(min_heapq, (B + 1 - point) + cost)
destination.add(B+1)
destination.pop(point)
point = destination.upper_bound(point)
while to_delete and min_heapq[0] == to_delete[0]:
heappop(min_heapq)
heappop(to_delete)
if min_heapq:
print((k + min_heapq[0] + 1))
else:
for _ in range(H - k):
print((-1))
exit()
| from heapq import *
class MultisetBIT:
"""
最大値が小さい数について、その重複を許した集合を管理する。
最大値 maxvalue を受け取り、[0, maxvalue] を管理する。
閉区間で管理する。
"""
__slots__ = ["n", "k", "data"]
def __init__(self, maxvalue):
"内部では [1, maxvalue + 1] でもつ。"
self.n = maxvalue + 1
self.k = 1 << ((self.n + 1).bit_length() - 1)
self.data = [0] * (self.n + 1)
def add(self, value):
"""
与えられた引数を Multiset に加える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
while value <= self.n:
self.data[value] += 1
value += value & -value
def pop(self, value):
"""
Multiset から与えられた引数を取り除く。
与えられた引数が Multiset に入っているかのチェックは行わなず、
単にその個数を 1 減らすだけなので注意。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
while value <= self.n:
self.data[value] -= 1
value += value & -value
def count_le(self, value):
"""
Multiset 内の要素 elem のうち、0 <= elem <= value を満たすものを数える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
value += 1
ret = 0
while value > 0:
ret += self.data[value]
value -= value & -value
return ret
def count(self, first, last):
"""
Multiset 内の要素 elem のうち、first <= elem <= last を満たすものを数える。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
last += 1
ret = 0
while first < last:
ret += self.data[last]
last -= last & -last
while last < first:
ret -= self.data[first]
first -= first & -first
return ret
def bisect(self, count):
"""
Multiset 内の要素 elem のうち、count <= count_le(elem) を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
ret = 0
k = self.k
while k > 0:
if ret + k <= self.n and self.data[ret + k] < count:
count -= self.data[ret + k]
ret += k
k //= 2
return ret
def lower_bound(self, value):
"""
Multiset 内の要素 elem のうち、value <= elem を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
return self.bisect(self.count_le(value - 1) + 1)
def upper_bound(self, value):
"""
Multiset 内の要素 elem のうち、value < elem を満たす最小のelemを返す。
計算量は、n を要素の最大値として、 O(log n) となる。
"""
return self.bisect(self.count_le(value) + 1)
H, W = list(map(int, input().split()))
destination = MultisetBIT(W)
for i in range(W):
destination.add(i)
destination_to_cost = {i:0 for i in range(W)}
min_heapq = [0] * W
to_delete = []
for k in range(H):
# print([i for i in range(W) if destination.count(i, i)])
# print(destination_to_cost)
A, B = list(map(int, input().split()))
A -= 1
B -= 1
start_point = destination.lower_bound(A)
point = start_point
change_dest_flg = False
while point < W and point < B + 1:
change_dest_flg = True
cost = destination_to_cost.pop(point)
heappush(to_delete, cost)
if B + 1 != W:
if (B + 1 in destination_to_cost):
if destination_to_cost[B+1] > (B + 1 - point) + cost:
heappush(to_delete, destination_to_cost[B+1])
destination_to_cost[B+1] = (B + 1 - point) + cost
heappush(min_heapq, (B + 1 - point) + cost)
else:
destination_to_cost[B+1] = (B + 1 - point) + cost
heappush(min_heapq, (B + 1 - point) + cost)
destination.add(B+1)
destination.pop(point)
point = destination.upper_bound(point)
while to_delete and min_heapq[0] == to_delete[0]:
heappop(min_heapq)
heappop(to_delete)
if min_heapq:
print((k + min_heapq[0] + 1))
else:
for _ in range(H - k):
print((-1))
exit()
| p02575 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
H, W, *AB = list(map(int, read().split()))
AB_list = [(-1,-1)]
for i in range(H):
a, b = AB[2*i], AB[2*i+1]
AB_list.append((a,b))
min_list = [INF] * (H+3)
MAP = [[INF] * (W + 2) for _ in range(H + 3)]
def bfs(start):
queue = deque([(start + (0,))])
while queue:
ci,cj, count = queue.popleft()
if min_list[ci] > count:
min_list[ci] = count
if ci == H+1:continue
a, b = AB_list[ci]
if a <= cj <= b:
if b + 1 <= W:
queue.append((ci+1, b + 1, count + b- cj + 2))
elif ci + 1 <= H+1:
queue.append((ci+1, cj, count + 1))
def run():
for j in range(1, W+1):
bfs((1, j))
for v in min_list[2:-1]:
if v == INF:
print((-1))
else:
print(v)
#for m in MAP:
# print(m)
if __name__ == "__main__":
run() | # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
H, W, *AB = list(map(int, read().split()))
AB_list = [(-1,-1)]
for i in range(H):
a, b = AB[2*i], AB[2*i+1]
AB_list.append((a,b))
min_list = [INF] * (H+3)
MAP = [[INF] * (W + 2) for _ in range(H + 3)]
def bfs(start):
queue = deque([(start + (0,))])
while queue:
ci,cj, count = queue.popleft()
if min_list[ci] > count:
min_list[ci] = count
if ci == H+1:continue
a, b = AB_list[ci]
if a <= cj <= b:
if b + 1 <= W:
queue.append((ci+1, b + 1, count + b- cj + 2))
elif ci + 1 <= H+1:
queue.append((ci+1, cj, count + 1))
def run():
a1, b1 = AB_list[1]
for j in range(1, W+1):
if a1 <= j <= b1:continue
bfs((1, j))
for v in min_list[2:-1]:
if v == INF:
print((-1))
else:
print(v)
#for m in MAP:
# print(m)
if __name__ == "__main__":
run() | p02575 |
# coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
H, W, *AB = list(map(int, read().split()))
AB_list = [(-1,-1)]
for i in range(H):
a, b = AB[2*i], AB[2*i+1]
AB_list.append((a,b))
min_list = [INF] * (H+3)
MAP = [[INF] * (W + 2) for _ in range(H + 3)]
def bfs(start):
queue = deque([(start + (0,))])
while queue:
ci,cj, count = queue.popleft()
if min_list[ci] > count:
min_list[ci] = count
if ci == H+1:break
a, b = AB_list[ci]
if a <= cj <= b:
if b + 1 <= W:
queue.append((ci+1, b + 1, count + b- cj + 2))
elif ci + 1 <= H+1:
queue.append((ci+1, cj, count + 1))
def run():
a1, b1 = AB_list[1]
for j in range(1, W+1):
if a1 <= j <= b1:continue
bfs((1, j))
for v in min_list[2:-1]:
if v == INF:
print((-1))
else:
print(v)
#for m in MAP:
# print(m)
if __name__ == "__main__":
run() | # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
#from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7
H, W, *AB = list(map(int, read().split()))
AB_list = [(-1,-1)]
for i in range(H):
a, b = AB[2*i], AB[2*i+1]
AB_list.append((a,b))
min_list = [INF] * (H+3)
MAP = [[INF] * (W + 2) for _ in range(H + 3)]
def bfs(start):
queue = deque([(start + (0,))])
while queue:
ci,cj, count = queue.popleft()
if MAP[ci][cj] > count:
MAP[ci][cj] = count
if min_list[ci] > count:
min_list[ci] = count
else:
continue
if ci == H+1:break
a, b = AB_list[ci]
if a <= cj <= b:
if b + 1 <= W:
queue.append((ci+1, b + 1, count + b- cj + 2))
elif ci + 1 <= H+1:
queue.append((ci+1, cj, count + 1))
def run():
a1, b1 = AB_list[1]
for j in range(1, W+1):
if a1 <= j <= b1:continue
bfs((1, j))
for v in min_list[2:-1]:
if v == INF:
print((-1))
else:
print(v)
#for m in MAP:
# print(m)
if __name__ == "__main__":
run()
| p02575 |
from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(0, b+2)
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
for v in ans:
print(v)
if __name__ == "__main__":
main() | from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(0, b+2)
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main() | p02575 |
from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
L = 0
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(L, b+2)
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main() | from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(0, b+2)
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main() | p02575 |
from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
L = 0
for i in range(h):
a, b = wall[i][0], wall[i][1]
if L < b:
idx = segflag.getLargestIndex(L, b+2)
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
if a <= L+1:
L = b
segflag.update(L, 1)
tmp = segmin.query(L, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main()
| from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
L = 0
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(L, b+2)
if idx < b+1:
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main()
| p02575 |
from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
def main():
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
L = 0
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(L, b+2)
if idx < b+1:
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
b = idx-1
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v)
if __name__ == "__main__":
main()
| from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def searchIndexFunc(self, val):
return True
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def addition(self, idx, val):
idx += self.num-1
self.seg[idx] += val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def multiplication(self, idx, val):
idx += self.num-1
self.seg[idx] *= val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
h, w = list(map(int, input().split()))
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
tmp = [0]*(w+2)
tmp[0] = float("inf")
segmin = SegTreeMin(float("inf"), tmp)
wall = [list(map(int, input().split())) for _ in range(h)]
L = 0
for i in range(h):
a, b = wall[i][0], wall[i][1]
idx = segflag.getLargestIndex(L, b+2)
if idx < b+1:
segflag.update(b+1, 1)
segmin.update(b+1, segmin.query(idx, idx+1)+(b+1-idx))
cnt = segflag.query(a, b+1)
for _ in range(cnt):
idx = segflag.getLargestIndex(a, b+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v) | p02575 |
from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
h, w = list(map(int, input().split()))
wall = [list(map(int, input().split())) for _ in range(h)]
ans = [-1]*h
segflag = SegTreeFlag(0, [1]*(w+2))
segmin = SegTreeMin(float("inf"), [0]*(w+2))
segmin.update(0, float("inf"))
for i in range(h):
idx = segflag.getLargestIndex(0, wall[i][1]+2)
if idx < wall[i][1]+1:
segflag.update(wall[i][1]+1, 1)
segmin.update(wall[i][1]+1, segmin.query(idx, idx+1)+(wall[i][1]+1-idx))
cnt = segflag.query(wall[i][0], wall[i][1]+1)
for _ in range(cnt):
idx = segflag.getSmallestIndex(wall[i][0], wall[i][1]+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v) | from sys import stdin
input = stdin.readline
class SegTreeFlag():
def segFunc(self, x, y):
return x+y
def searchIndexFunc(self, val):
return val > 0
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
def getLargestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R)//2
if self.searchIndexFunc(self.query(P, R)):
L = P
else:
R = P
return L
def getSmallestIndex(self, begin, end):
L, R = begin, end
if not self.searchIndexFunc(self.query(begin, end)):
return None
while L+1 < R:
P = (L+R+1)//2
if self.searchIndexFunc(self.query(L, P)):
R = P
else:
L = P
return L
class SegTreeMin():
def segFunc(self, x, y):
if x < y:
return x
else:
return y
def __init__(self, ide, init_val):
n = len(init_val)
self.ide_ele = ide
self.num = 2**(n-1).bit_length()
self.seg = [self.ide_ele] * 2 * self.num
for i in range(n):
self.seg[i+self.num-1] = init_val[i]
for i in range(self.num-2,-1,-1):
self.seg[i] = self.segFunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, idx, val):
idx += self.num-1
self.seg[idx] = val
while idx:
idx = (idx-1)//2
self.seg[idx] = self.segFunc(self.seg[idx*2+1], self.seg[idx*2+2])
def query(self, begin, end):
if end <= begin:
return self.ide_ele
begin += self.num-1
end += self.num-2
res = self.ide_ele
while begin + 1 < end:
if begin&1 == 0:
res = self.segFunc(res, self.seg[begin])
if end&1 == 1:
res = self.segFunc(res, self.seg[end])
end -= 1
begin = begin//2
end = (end-1)//2
if begin == end:
res = self.segFunc(res, self.seg[begin])
else:
res = self.segFunc(self.segFunc(res, self.seg[begin]), self.seg[end])
return res
h, w = list(map(int, input().split()))
wall = [list(map(int, input().split())) for _ in range(h)]
ans = [-1 for _ in range(h)]
segflag = SegTreeFlag(0, [1 for _ in range(w+2)])
segmin = SegTreeMin(float("inf"), [0 for _ in range(w+2)])
segmin.update(0, float("inf"))
for i in range(h):
idx = segflag.getLargestIndex(0, wall[i][1]+2)
if idx < wall[i][1]+1:
segflag.update(wall[i][1]+1, 1)
segmin.update(wall[i][1]+1, segmin.query(idx, idx+1)+(wall[i][1]+1-idx))
cnt = segflag.query(wall[i][0], wall[i][1]+1)
for _ in range(cnt):
idx = segflag.getSmallestIndex(wall[i][0], wall[i][1]+1)
segflag.update(idx, 0)
segmin.update(idx, float("inf"))
tmp = segmin.query(0, w+1)
if tmp != float("inf"):
ans[i] = tmp + i + 1
else:
break
for v in ans:
print(v) | p02575 |
'''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7 #998244353
dir = [(-1,0),(0,-1),(1,0),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
class Binary_Indexed_Tree:
'''
Binary_Indexed_Tree
A1 ... AnのBIT(1-indexed)
std_mapを使うときには一緒に貼る
'''
def __init__(self,n):
self.N = n
self.BIT = [0]*(n+1)
self.l2 = 2**(len(format(n,'b'))-1)
#A1 ~ Aiまでの和 O(logN)
def get_sum(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Al ~ Arの和
def query(self,l,r):
return self.get_sum(r)-self.get_sum(l-1)
#Ai += x O(logN)
def add(self,idx,x):
while idx <= self.N:
self.BIT[idx] += x
idx += idx&(-idx)
return
# 和がw以上になる最小のindex
def lower_bound(self,w):
if w <= 0:
return 0
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] < w:
w -= self.BIT[x+k]
x += k
k //= 2
return x+1
# 和がwより大きくなる最小のindex
def upper_bound(self,w):
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] <= w:
w -= self.BIT[x+k]
x += k
k //= 2
return x+1
class std_map:
'''
c++のstd::map(平衡二分探索木)
dictにおいてkeyの範囲が限定されてkeyに順序が組み込まれたもの
念願のlower_boundとupper_boundができるようになった
'''
def __init__(self,n,init):
self.size = n
self.keys = set()
self.bit = Binary_Indexed_Tree(n+1)
self.dic = [init]*(n+1)
def __contains__(self,key): # keyを持つか
return key in self.keys
def __getitem__(self,key): # keyに対するvalueを返す
return self.dic[key]
def __setitem__(self,key,value): # dic[key]をvalueで置き換える
if not key in self.keys:
self.bit.add(key,1)
self.keys.add(key)
self.dic[key] = value
def remove(self,key): # keyをmapから取り除く
self.keys.remove(key)
self.bit.add(key,-1)
def lower_bound(self,k): # k以上の最小のkeyを返す
return self.bit.lower_bound(self.bit.get_sum(k))
def upper_bound(self,k): # kより大きい最小のkeyを返す
return self.bit.upper_bound(self.bit.get_sum(k))
def kth_key(self,k): # k番目に小さいkeyを返す
return self.bit.lower_bound(k)
def kth_value(self,k): # k番目に小さいkeyに対するvalueを返す
return self.dic[self.kth_key(k)]
def prev_k(self,k): # kの一つ前のkeyを返す
idx = self.bit.get_sum(k)
if idx == 0:
return -1
return self.bit.lower_bound(idx-1)
def prev_k(self,k): # kの一つ後のkeyを返す
idx = self.bit.get_sum(k)
if idx == self.size:
return -1
return self.bit.lower_bound(idx+1)
def main():
h,w = list(map(int,ipt().split()))
st = SegTree([10**18]+[0]*w+[10**18],min,10**18)
s = std_map(w+2,0)
for i in range(1,w+2):
s.bit.add(i,1)
s.keys = set(range(1,w+2))
for i in range(h):
a,b = list(map(int,ipt().split()))
pl = s.bit.get_sum(a-1)+1
# print(pl)
pa = s.kth_key(pl)
mv = 10**18
while pa <= b:
# print(pa)
st.update(pa,10**18)
mv = min(mv,s[pa]-pa)
s.remove(pa)
pa = s.kth_key(pl)
# print(st.tree)
mv += b+1
if b != w:
if (not b+1 in s) or s[b+1] > mv:
st.update(b+1,mv)
s[b+1] = mv
mv = st.tree[1]
if mv == 10**18:
print((-1))
else:
print((mv+i+1))
return None
if __name__ == '__main__':
main()
| '''
自宅用PCでの解答
'''
import math
#import numpy as np
import itertools
import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit
#from scipy.sparse.csgraph import dijkstra
#from scipy.sparse import csr_matrix
ipt = stdin.readline
setrecursionlimit(10**7)
mod = 10**9+7 #998244353
dir = [(-1,0),(0,-1),(1,0),(0,1)]
alp = "abcdefghijklmnopqrstuvwxyz"
INF = 1<<32-1
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
class Binary_Indexed_Tree:
'''
Binary_Indexed_Tree
A1 ... AnのBIT(1-indexed)
std_mapを使うときには一緒に貼る
'''
def __init__(self,n):
self.N = n
self.BIT = [0]*(n+1)
self.l2 = 2**(len(format(n,'b'))-1)
#A1 ~ Aiまでの和 O(logN)
def get_sum(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Al ~ Arの和
def query(self,l,r):
return self.get_sum(r)-self.get_sum(l-1)
#Ai += x O(logN)
def add(self,idx,x):
while idx <= self.N:
self.BIT[idx] += x
idx += idx&(-idx)
return
# 和がw以上になる最小のindex
def lower_bound(self,w):
if w <= 0:
return 0
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] < w:
w -= self.BIT[x+k]
x += k
k //= 2
return x+1
# 和がwより大きくなる最小のindex
def upper_bound(self,w):
x = 0
k = self.l2
while k > 0:
if x+k <= self.N and self.BIT[x+k] <= w:
w -= self.BIT[x+k]
x += k
k //= 2
return x+1
class std_map:
'''
c++のstd::map(平衡二分探索木)
dictにおいてkeyの範囲が限定されてkeyに順序が組み込まれたもの
念願のlower_boundとupper_boundができるようになった
'''
def __init__(self,n,init):
self.size = n
self.keys = set()
self.bit = Binary_Indexed_Tree(n+1)
self.dic = [init]*(n+1)
def __contains__(self,key): # keyを持つか
return key in self.keys
def __getitem__(self,key): # keyに対するvalueを返す
return self.dic[key]
def __setitem__(self,key,value): # dic[key]をvalueで置き換える
if not key in self.keys:
self.bit.add(key,1)
self.keys.add(key)
self.dic[key] = value
def remove(self,key): # keyをmapから取り除く
self.keys.remove(key)
self.bit.add(key,-1)
def lower_bound(self,k): # k以上の最小のkeyを返す
return self.bit.lower_bound(self.bit.get_sum(k))
def upper_bound(self,k): # kより大きい最小のkeyを返す
return self.bit.upper_bound(self.bit.get_sum(k))
def kth_key(self,k): # k番目に小さいkeyを返す
return self.bit.lower_bound(k)
def kth_value(self,k): # k番目に小さいkeyに対するvalueを返す
return self.dic[self.kth_key(k)]
def prev_k(self,k): # kの一つ前のkeyを返す
idx = self.bit.get_sum(k)
if idx == 0:
return -1
return self.bit.lower_bound(idx-1)
def prev_k(self,k): # kの一つ後のkeyを返す
idx = self.bit.get_sum(k)
if idx == self.size:
return -1
return self.bit.lower_bound(idx+1)
def main():
h,w = list(map(int,ipt().split()))
st = SegTree([INF]+[0]*w+[INF],min,INF)
s = std_map(w+2,0)
for i in range(1,w+2):
s.bit.add(i,1)
s.keys = set(range(1,w+2))
for i in range(h):
a,b = list(map(int,ipt().split()))
pl = s.bit.get_sum(a-1)+1
# print(pl)
pa = s.kth_key(pl)
mv = INF
while pa <= b:
# print(pa)
st.update(pa,INF)
mv = min(mv,s[pa]-pa)
s.remove(pa)
pa = s.kth_key(pl)
# print(st.tree)
mv += b+1
if b != w:
if (not b+1 in s) or s[b+1] > mv:
st.update(b+1,mv)
s[b+1] = mv
mv = st.tree[1]
if mv == INF:
print((-1))
else:
print((mv+i+1))
return None
if __name__ == '__main__':
main()
| p02575 |
import sys,heapq
input = sys.stdin.buffer.readline
h,w = list(map(int,input().split()))
#dp[i] : iの時の最小右移動回数
dp = [0]*(w+1)
#解候補
res = [0]*w
#解候補から消されるもの
anti = []
#Ai = {1:dp[i]はvalid 0:invalid}
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(w+100)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= w:
BIT[idx] += x
idx += idx&(-idx)
return
for i in range(1,w+1):
BIT_update(i,1)
flag = False
for i in range(1,h+1):
a,b = list(map(int,input().split()))
if flag:
print((-1))
continue
#a-1,b+1の値を計算
for x in [a-1,b+1]:
#端で操作不可能
if x in (0,w+1):
continue
#validな値の場合そのまま下に行く
if dp[x] != -1:
continue
#x以下のvalidな個数
k = BIT_query(x-1)
#k番目のvalidな位置okからXに行く
if k == 0:
continue
ok = x
ng = 0
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) == k:
ok = mid
else:
ng = mid
#xをvalidにする
dp[x] = dp[ok] + (x-ok)
BIT_update(x,1)
heapq.heappush(res,dp[x])
k = BIT_query(a-1)+1
while True:
ng = 0
ok = w
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) >= k:
ok = mid
else:
ng = mid
if ok > b or dp[ok] == -1:
break
heapq.heappush(anti,dp[ok])
dp[ok] = -1
BIT_update(ok,-1)
while anti and anti[0] == res[0]:
heapq.heappop(anti)
heapq.heappop(res)
if res:
print((res[0]+i))
else:
flag = True
print((-1))
| import sys,heapq
input = sys.stdin.buffer.readline
h,w = list(map(int,input().split()))
#dp[i] : iの時の最小右移動回数
dp = [0]*(w+1)
dp[0] = -1
#解候補
res = [0]*w
#解候補から消されるもの
anti = []
#Ai = {1:dp[i]はvalid 0:invalid}
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(w+1)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= w:
BIT[idx] += x
idx += idx&(-idx)
return
for i in range(1,w+1):
BIT_update(i,1)
for i in range(1,h+1):
a,b = list(map(int,input().split()))
#a-1,b+1の値を計算
for x in [a-1,b+1]:
#端で操作不可能
if x in (0,w+1):
continue
#validな値の場合そのまま下に行く
if dp[x] != -1:
continue
#x以下のvalidな個数
k = BIT_query(x-1)
#k番目のvalidな位置okからXに行く
if k == 0:
continue
ok = x
ng = 0
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) == k:
ok = mid
else:
ng = mid
#xをvalidにする
dp[x] = dp[ok] + (x-ok)
BIT_update(x,1)
heapq.heappush(res,dp[x])
k = BIT_query(a-1)+1
while True:
ng = 0
ok = w
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) >= k:
ok = mid
else:
ng = mid
if ok > b or dp[ok] == -1:
break
heapq.heappush(anti,dp[ok])
dp[ok] = -1
BIT_update(ok,-1)
while anti and anti[0] == res[0]:
heapq.heappop(anti)
heapq.heappop(res)
if res:
print((res[0]+i))
else:
print((-1))
| p02575 |
import sys,heapq
input = sys.stdin.buffer.readline
def main():
h,w = list(map(int,input().split()))
#dp[i] : iの時の最小右移動回数
dp = [0]*(w+1)
#解候補
res = [0]*w
#解候補から消されるもの
anti = []
#Ai = {1:dp[i]はvalid 0:invalid}
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(w+100)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= w:
BIT[idx] += x
idx += idx&(-idx)
return
for i in range(1,w+1):
BIT_update(i,1)
for i in range(1,h+1):
a,b = list(map(int,input().split()))
#a-1,b+1の値を計算
for x in [a-1,b+1]:
#端で操作不可能
if x in (0,w+1):
continue
#validな値の場合そのまま下に行く
if dp[x] != -1:
continue
#x以下のvalidな個数
k = BIT_query(x-1)
#k番目のvalidな位置okからXに行く
if k == 0:
continue
ok = x
ng = 0
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) == k:
ok = mid
else:
ng = mid
#xをvalidにする
dp[x] = dp[ok] + (x-ok)
BIT_update(x,1)
heapq.heappush(res,dp[x])
k = BIT_query(a-1)+1
while True:
ng = 0
ok = w
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) >= k:
ok = mid
else:
ng = mid
if ok > b or dp[ok] == -1:
break
heapq.heappush(anti,dp[ok])
dp[ok] = -1
BIT_update(ok,-1)
while anti and res and anti[0] == res[0]:
heapq.heappop(anti)
heapq.heappop(res)
if res:
print((res[0]+i))
else:
print((-1))
if __name__ == '__main__':
main() | import sys,heapq
input = sys.stdin.buffer.readline
def main():
h,w = list(map(int,input().split()))
#dp[i] : iの時の最小右移動回数
dp = [0]*(w+1)
#解候補
res = [0]*w
#解候補から消されるもの
anti = []
#Ai = {1:dp[i]はvalid 0:invalid}
#A1 ... AnのBIT(1-indexed)
BIT = [0]*(w+100)
#A1 ~ Aiまでの和 O(logN)
def BIT_query(idx):
res_sum = 0
while idx > 0:
res_sum += BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def BIT_update(idx,x):
while idx <= w:
BIT[idx] += x
idx += idx&(-idx)
return
for i in range(1,w+1):
BIT_update(i,1)
for i in range(1,h+1):
a,b = list(map(int,input().split()))
#a-1,b+1の値を計算
for x in [a-1,b+1]:
#端で操作不可能
if x in (0,w+1):
continue
#validな値の場合そのまま下に行く
if dp[x] != -1:
continue
#x以下のvalidな個数
k = BIT_query(x-1)
#k番目のvalidな位置okからXに行く
if k == 0:
continue
ok = x
ng = 0
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) == k:
ok = mid
else:
ng = mid
#xをvalidにする
dp[x] = dp[ok] + (x-ok)
BIT_update(x,1)
heapq.heappush(res,dp[x])
k = BIT_query(a-1)+1
while True:
ng = a-1
ok = w
while ok-ng > 1:
mid = (ok+ng)//2
if BIT_query(mid) >= k:
ok = mid
else:
ng = mid
if ok > b or dp[ok] == -1:
break
heapq.heappush(anti,dp[ok])
dp[ok] = -1
BIT_update(ok,-1)
while anti and res and anti[0] == res[0]:
heapq.heappop(anti)
heapq.heappop(res)
if res:
print((res[0]+i))
else:
print((-1))
if __name__ == '__main__':
main() | p02575 |
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 LazySegMin:
def __init__(self, aa):
inf = 10 ** 16
n = 1 << (len(aa) - 1).bit_length()
tree = [inf] * (2 * n)
lazy = [None] * (2 * n)
tree[n:n + len(aa)] = aa
for u in range(n - 1, -1, -1):
tree[u] = min(tree[u * 2], tree[u * 2 + 1])
self.tree = tree
self.lazy = lazy
self.n = n
self.inf = inf
def update(self, l, r, a, u=1, tl=0, tr=-1):
if tr == -1: tr = self.n
self._eval(u, tl, tr)
if r <= tl or tr <= l: return
if l <= tl and tr <= r:
self.lazy[u] = a
self._eval(u, tl, tr)
return
tm = (tl + tr) // 2
self.update(l, r, a, u * 2, tl, tm)
self.update(l, r, a, u * 2 + 1, tm, tr)
self.tree[u] = min(self.tree[u * 2], self.tree[u * 2 + 1])
def min(self, l, r, u=1, tl=0, tr=-1):
if tr == -1: tr = self.n
if r <= tl or tr <= l: return self.inf
self._eval(u, tl, tr)
if l <= tl and tr <= r: return self.tree[u]
tm = (tl + tr) // 2
return min(self.min(l, r, u * 2, tl, tm), self.min(l, r, u * 2 + 1, tm, tr))
def _eval(self, u, l, r):
if self.lazy[u] == None: return
self.tree[u] = self.lazy[u]
if l + 1 < r:
self.lazy[u * 2] = self.lazy[u]
self.lazy[u * 2 + 1] = self.lazy[u]
self.lazy[u] = None
from heapq import *
inf=10**9
h,w=MI()
cost=[0]*w
invaid=0
hp=[(0,i) for i in range(w)]
heapify(hp)
st=LazySegMin(list(range(0,-w,-1)))
to0=lambda a,k:(a>>(k+1))<<(k+1)|(a&((1<<k)-1))
for i in range(h):
l,r=MI()
l-=1
if r<w:
mn=st.min(l,r+1)
st.update(r,r+1,mn)
invaid=to0(invaid,r)
cost[r]=mn+r
heappush(hp,(mn+r,r))
st.update(l,r,inf)
invaid|=((1<<r-l)-1)<<l
while hp:
c,j=hp[0]
if invaid>>j&1 or cost[j]!=c:heappop(hp)
else:
print(c+i+1)
break
else:print(-1)
# print(l,r,cost,bin(invaid),hp)
| from heapq import *
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 BitSum:
def __init__(self, n):
self.n = n + 1
self.table = [0] * self.n
def add(self, i, x):
i += 1
while i < self.n:
self.table[i] += x
i += i & -i
def sum(self, i):
i += 1
res = 0
while i > 0:
res += self.table[i]
i -= i & -i
return res
# 数列を度数分布とみたときに、x番目がどのインデックスにあるかを返す
def rank(self, x):
idx = 0
for lv in range((self.n - 1).bit_length() - 1, -1, -1):
mid = idx + (1 << lv)
if mid >= self.n: continue
if self.table[mid] < x:
x -= self.table[mid]
idx += 1 << lv
return idx
def solve():
bit = BitSum(w + 1)
for j in range(w): bit.add(j + 1, 1)
cost = [0] * (w + 1)
hp = [0] * w
heapify(hp)
rem = []
for i in range(h):
l, r = MI()
r += 1
# cost[r]の更新
if r <= w:
cnt = bit.sum(r)
if cnt:
j = bit.rank(cnt)
if l <= j < r:
bit.add(r, 1)
cost[r] = cost[j] + r - j
heappush(hp, cost[r])
# 区間[l,r)を無効にする
cnt = bit.sum(l - 1)
while 1:
j = bit.rank(cnt + 1)
if j >= r: break
heappush(rem, cost[j])
bit.add(j, -1)
# ヒープからの削除
while hp and rem and hp[0] == rem[0]:
heappop(hp)
heappop(rem)
# 出力
if hp: print(hp[0] + i + 1)
else: print(-1)
h,w=MI()
solve()
| p02575 |
from heapq import *
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 BitSum:
def __init__(self, n):
self.n = n + 1
self.table = [0] * self.n
def add(self, i, x):
i += 1
while i < self.n:
self.table[i] += x
i += i & -i
def sum(self, i):
i += 1
res = 0
while i > 0:
res += self.table[i]
i -= i & -i
return res
# 数列を度数分布とみたときに、x番目がどのインデックスにあるかを返す
def rank(self, x):
idx = 0
for lv in range((self.n - 1).bit_length() - 1, -1, -1):
mid = idx + (1 << lv)
if mid >= self.n: continue
if self.table[mid] < x:
x -= self.table[mid]
idx += 1 << lv
return idx
def solve():
bit = BitSum(w + 1)
for j in range(w): bit.add(j + 1, 1)
cost = [0] * (w + 1)
hp = [0] * w
heapify(hp)
rem = []
for i in range(h):
l, r = MI()
r += 1
# cost[r]の更新
if r <= w:
cnt = bit.sum(r)
if cnt:
j = bit.rank(cnt)
if l <= j < r:
bit.add(r, 1)
cost[r] = cost[j] + r - j
heappush(hp, cost[r])
# 区間[l,r)を無効にする
cnt = bit.sum(l - 1)
while 1:
j = bit.rank(cnt + 1)
if j >= r: break
heappush(rem, cost[j])
bit.add(j, -1)
# ヒープからの削除
while hp and rem and hp[0] == rem[0]:
heappop(hp)
heappop(rem)
# 出力
if hp: print(hp[0] + i + 1)
else: print(-1)
h,w=MI()
solve()
| from heapq import *
import sys
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 BitSum:
def __init__(self, n):
self.n = n + 1
self.table = [0] * self.n
def add(self, i, x):
i += 1
while i < self.n:
self.table[i] += x
i += i & -i
def sum(self, i):
i += 1
res = 0
while i > 0:
res += self.table[i]
i -= i & -i
return res
# 数列を度数分布とみたときに、x番目がどのインデックスにあるかを返す
def rank(self, x):
idx = 0
for lv in range((self.n - 1).bit_length() - 1, -1, -1):
mid = idx + (1 << lv)
if mid >= self.n: continue
if self.table[mid] < x:
x -= self.table[mid]
idx += 1 << lv
return idx
def solve():
bit = BitSum(w + 1)
for j in range(w): bit.add(j + 1, 1)
cost = [0] * (w + 1)
hp = [0] * w
heapify(hp)
rem = []
for i in range(h):
l, r = MI()
r += 1
# cost[r]の更新
if r <= w:
cnt = bit.sum(r)
if cnt:
j = bit.rank(cnt)
if l <= j < r:
bit.add(r, 1)
cost[r] = cost[j] + r - j
heappush(hp, cost[r])
# 区間[l,r)を無効にする
cnt = bit.sum(l - 1)
while 1:
j = bit.rank(cnt + 1)
if j >= r: break
heappush(rem, cost[j])
bit.add(j, -1)
# ヒープからの削除
while hp and rem and hp[0] == rem[0]:
heappop(hp)
heappop(rem)
# 出力
if hp: print(hp[0] + i + 1)
else: print(-1)
h,w=MI()
solve()
| p02575 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
H,W = IL()
data = ILL(H)
class BIT:
def __init__(self, logn):
self.n = 1<<logn
self.data = [0]*(self.n+1)
self.el = [0]*(self.n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def bisect(self, x):
w = i = 0
k = self.n
while k:
if i+k <= self.n and w + self.data[i+k] < x:
w += self.data[i+k]
i += k
k >>= 1
return i+1
dic = DD(int)
for i in range(W):
dic[i+1] = i+1
members = DD(int)
for i in range(W):
members[i+1] = 1
B = BIT(int_log(W,2)+1)
for i in range(W):
B.add(i+1,1)
def calc_prev_valid(x):
s = B.sum(x-1)
if s == 0:
return -1
else:
return B.bisect(s)
#print(calc_prev_valid(0))
#exit()
count_score = DD(int)
count_score[0] = W
score = 0
for i in range(H):
a,b = data[i]
now = b
while now >= a:
if B.el[now]:
#print("shorisita",now)
count_score[now-dic[now]] -= members[now]
if not B.el[b+1]:
dic[b+1] = dic[now]
B.add(b+1,1)
if b+1 < W+1:
#print((b+1),dic[b+1])
count_score[(b+1)-dic[b+1]] += members[now]
B.add(now,-1)
members[b+1] += members[now]
members[now] = 0
now = calc_prev_valid(now)
#print(dic)
#print(members)
#print(prev_valid)
#print(count_score)
while True:
if count_score[score]:
print((score+i+1))
break
else:
score += 1
if score == W:
for _ in range(H-i):
print((-1))
exit()
| import sys
input = sys.stdin.readline
from collections import defaultdict
def DD(arg): return defaultdict(arg)
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
H,W = list(map(int,input().split()))
data = [list(map(int, input().split())) for _ in range(H)]
class BIT:
def __init__(self, logn):
self.n = 1<<logn
self.data = [0]*(self.n+1)
self.el = [0]*(self.n+1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def bisect(self, x):
w = i = 0
k = self.n
while k:
if i+k <= self.n and w + self.data[i+k] < x:
w += self.data[i+k]
i += k
k >>= 1
return i+1
dic = DD(int)
for i in range(W):
dic[i+1] = i+1
members = DD(int)
for i in range(W):
members[i+1] = 1
B = BIT(int_log(W,2)+1)
for i in range(W):
B.add(i+1,1)
def calc_prev_valid(x):
s = B.sum(x-1)
if s == 0:
return 0
else:
return B.bisect(s)
count_score = DD(int)
count_score[0] = W
score = 0
for i in range(H):
a,b = data[i]
now = b
while now >= a:
if B.el[now]:
count_score[now-dic[now]] -= members[now]
if not B.el[b+1]:
dic[b+1] = dic[now]
B.add(b+1,1)
if b+1 < W+1:
count_score[(b+1)-dic[b+1]] += members[now]
B.add(now,-1)
members[b+1] += members[now]
members[now] = 0
now = calc_prev_valid(now)
while True:
if count_score[score]:
print((score+i+1))
break
else:
score += 1
if score == W:
for _ in range(H-i):
print((-1))
exit()
# if i == 1500:
# exit() | p02575 |
import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
H,W=list(map(int,input().split()))
D=[tuple(map(int,input().split())) for i in range(H)]
# 範囲更新、最大値取得の遅延セグ木と、範囲更新、最小値取得の遅延セグ木
seg_el=1<<((W+3).bit_length()) # Segment treeの台の要素数
SEG=[1<<30]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
LAZY=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
SEG2=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
LAZY2=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def indexes(L,R):
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def updates(l,r,x): # 区間[l,r)をxに更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
LAZY[ind<<1]=LAZY[1+(ind<<1)]=SEG[ind<<1]=SEG[1+(ind<<1)]=LAZY[ind]
LAZY[ind]=None
while L!=R:
if L > R:
SEG[L]=x
LAZY[L]=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG[R]=x
LAZY[R]=x
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=max(SEG[ind<<1],SEG[1+(ind<<1)])
def updates2(l,r,x): # 区間[l,r)をxに更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY2[ind]!=None:
LAZY2[ind<<1]=LAZY2[1+(ind<<1)]=SEG2[ind<<1]=SEG2[1+(ind<<1)]=LAZY2[ind]
LAZY2[ind]=None
while L!=R:
if L > R:
SEG2[L]=x
LAZY2[L]=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG2[R]=x
LAZY2[R]=x
R//=(R & (-R))
for ind in UPIND:
SEG2[ind]=min(SEG2[ind<<1],SEG2[1+(ind<<1)])
def getvalues(l,r): # 区間[l,r)に関するmaxを調べる
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
LAZY[ind<<1]=LAZY[1+(ind<<1)]=SEG[ind<<1]=SEG[1+(ind<<1)]=LAZY[ind]
LAZY[ind]=None
ANS=-1<<30
while L!=R:
if L > R:
ANS=max(ANS , SEG[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANS=max(ANS , SEG[R])
R//=(R & (-R))
return ANS
def getvalues2(l,r): # 区間[l,r)に関するminを調べる
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY2[ind]!=None:
LAZY2[ind<<1]=LAZY2[1+(ind<<1)]=SEG2[ind<<1]=SEG2[1+(ind<<1)]=LAZY2[ind]
LAZY2[ind]=None
ANS=1<<31
while L!=R:
if L > R:
ANS=min(ANS , SEG2[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANS=min(ANS , SEG2[R])
R//=(R & (-R))
return ANS
for i in range(W+1):
updates(i,i+1,i)
for i in range(H):
x,y = D[i]
if x==1:
updates(x,y+1,-(1<<30))
else:
MAX=getvalues(1,x)
updates(x,y+1,MAX)
updates2(x,y+1,1<<30)
updates2(y+1,y+2,y+1-getvalues(y+1,y+2))
ANS=getvalues2(1,W+1)+i+1
if ANS>1<<28:
sys.stdout.write(str(-1)+"\n")
else:
sys.stdout.write(str(ANS)+"\n") | import sys
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
H,W=list(map(int,input().split()))
# 範囲更新、最大値取得の遅延セグ木と、範囲更新、最小値取得の遅延セグ木
seg_el=1<<((W+3).bit_length()) # Segment treeの台の要素数
SEG=[1<<30]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
LAZY=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
SEG2=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
LAZY2=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def indexes(L,R):
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def updates(l,r,x): # 区間[l,r)をxに更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
LAZY[ind<<1]=LAZY[1+(ind<<1)]=SEG[ind<<1]=SEG[1+(ind<<1)]=LAZY[ind]
LAZY[ind]=None
while L!=R:
if L > R:
SEG[L]=x
LAZY[L]=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG[R]=x
LAZY[R]=x
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=max(SEG[ind<<1],SEG[1+(ind<<1)])
def updates2(l,r,x): # 区間[l,r)をxに更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY2[ind]!=None:
LAZY2[ind<<1]=LAZY2[1+(ind<<1)]=SEG2[ind<<1]=SEG2[1+(ind<<1)]=LAZY2[ind]
LAZY2[ind]=None
while L!=R:
if L > R:
SEG2[L]=x
LAZY2[L]=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG2[R]=x
LAZY2[R]=x
R//=(R & (-R))
for ind in UPIND:
SEG2[ind]=min(SEG2[ind<<1],SEG2[1+(ind<<1)])
def getvalues(l,r): # 区間[l,r)に関するmaxを調べる
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY[ind]!=None:
LAZY[ind<<1]=LAZY[1+(ind<<1)]=SEG[ind<<1]=SEG[1+(ind<<1)]=LAZY[ind]
LAZY[ind]=None
ANS=-1<<30
while L!=R:
if L > R:
ANS=max(ANS , SEG[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANS=max(ANS , SEG[R])
R//=(R & (-R))
return ANS
def getvalues2(l,r): # 区間[l,r)に関するminを調べる
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]:
if LAZY2[ind]!=None:
LAZY2[ind<<1]=LAZY2[1+(ind<<1)]=SEG2[ind<<1]=SEG2[1+(ind<<1)]=LAZY2[ind]
LAZY2[ind]=None
ANS=1<<31
while L!=R:
if L > R:
ANS=min(ANS , SEG2[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANS=min(ANS , SEG2[R])
R//=(R & (-R))
return ANS
for i in range(W+1):
updates(i,i+1,i)
for i in range(H):
x,y = list(map(int,input().split()))
if x==1:
updates(x,y+1,-(1<<30))
else:
MAX=getvalues(1,x)
updates(x,y+1,MAX)
updates2(x,y+1,1<<30)
updates2(y+1,y+2,y+1-getvalues(y+1,y+2))
ANS=getvalues2(1,W+1)+i+1
if ANS>1<<28:
sys.stdout.write(str(-1)+"\n")
else:
sys.stdout.write(str(ANS)+"\n") | p02575 |
class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = [self.me]*self.n + monoid_data
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length()-1, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(l0.bit_length()-1, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(r0.bit_length()-1, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(l0.bit_length()-1, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(r0.bit_length()-1, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
import sys
input = sys.stdin.readline
INF = 10**7
h, w = list(map(int, input().split()))
def fmo(m1, o1):
if o1 == -1:
return m1
return o1
def foo(o1, o2):
if o2 == -1:
return o1
return o2
lst_max = LazySegmentTree(list(range(w+1)), -INF, -1, max, fmo, foo)
lst_min = LazySegmentTree([0]*(w+1), INF, -1, min, fmo, foo)
for i in range(h):
a, b = list(map(int, input().split()))
a -= 1
l_max = lst_max.folded(a, b)
lst_max.effect(a, b, -float("inf"))
x = lst_max.folded(b, b+1)
lst_max.replace(b, max(l_max, x))
lst_min.effect(a, b, float("inf"))
y = lst_min.folded(b, b+1)
lst_min.replace(b, min(b, y))
ans = lst_min.folded(0, w)
if ans >= 10**6:
print((-1))
else:
ans += i+1
print(ans)
| class LazySegmentTree:
__slots__ = ["n", "data", "lazy", "me", "oe", "fmm", "fmo", "foo"]
def __init__(self, monoid_data, monoid_identity, operator_identity, func_monoid_monoid, func_monoid_operator, func_operator_operator):
self.me = monoid_identity
self.oe = operator_identity
self.fmm = func_monoid_monoid
self.fmo = func_monoid_operator
self.foo = func_operator_operator
self.n = len(monoid_data)
self.data = monoid_data * 2
for i in range(self.n-1, 0, -1):
self.data[i] = self.fmm(self.data[2*i], self.data[2*i+1])
self.lazy = [self.oe] * (self.n * 2)
def replace(self, index, value):
index += self.n
# propagation
for shift in range(index.bit_length()-1, 0, -1):
i = index >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# update
self.data[index] = value
self.lazy[index] = self.oe
# recalculation
i = index
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def effect(self, l, r, operator):
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(l0.bit_length()-1, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(r0.bit_length()-1, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# effect
while l < r:
if l % 2:
self.lazy[l] = self.foo(self.lazy[l], operator)
l += 1
if r % 2:
r -= 1
self.lazy[r] = self.foo(self.lazy[r], operator)
l //= 2
r //= 2
# recalculation
i = l0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
i = r0
while i > 1:
i //= 2
self.data[i] = self.fmm( self.fmo(self.data[2*i], self.lazy[2*i]), self.fmo(self.data[2*i+1], self.lazy[2*i+1]) )
self.lazy[i] = self.oe
def folded(self, l, r):
l += self.n
r += self.n
l0 = l
r0 = r - 1
while l0 % 2 == 0:
l0 //= 2
while r0 % 2 == 1:
r0 //= 2
# propagation
for shift in range(l0.bit_length()-1, 0, -1):
i = l0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
for shift in range(r0.bit_length()-1, 0, -1):
i = r0 >> shift
self.lazy[2*i] = self.foo(self.lazy[2*i], self.lazy[i])
self.lazy[2*i+1] = self.foo(self.lazy[2*i+1], self.lazy[i])
self.data[i] = self.fmo(self.data[i], self.lazy[i])
self.lazy[i] = self.oe
# fold
left_folded = self.me
right_folded = self.me
while l < r:
if l % 2:
left_folded = self.fmm(left_folded, self.fmo(self.data[l], self.lazy[l]))
l += 1
if r % 2:
r -= 1
right_folded = self.fmm(self.fmo(self.data[r], self.lazy[r]), right_folded)
l //= 2
r //= 2
return self.fmm(left_folded, right_folded)
import sys
input = sys.stdin.readline
h, w = list(map(int, input().split()))
def fmo(m1, o1):
if o1 == -1:
return m1
return o1
def foo(o1, o2):
if o2 == -1:
return o1
return o2
INF = 10**6
lst_max = LazySegmentTree(list(range(w)), -INF, -1, max, fmo, foo)
lst_min = LazySegmentTree([0]*w, INF, -1, min, fmo, foo)
for i in range(h):
a, b = list(map(int, input().split()))
a -= 1
l_max = lst_max.folded(a, b)
lst_max.effect(a, b, -INF)
lst_min.effect(a, b, INF)
if b < w:
x = lst_max.folded(b, b+1)
lst_max.replace(b, max(l_max, x))
y = lst_min.folded(b, b+1)
lst_min.replace(b, min(b-l_max, y))
ans = lst_min.folded(0, w)
if ans == INF:
print((-1))
else:
ans += i+1
print(ans) | p02575 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 20
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = 1 << 18
st1 = SegmentTree([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < 1 << 19 else -1))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree1():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
return
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 20
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = 1 << 18
st1 = SegmentTree1([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < 1 << 19 else -1))
| p02575 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree1():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
return
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 20
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = 1 << 18
st1 = SegmentTree1([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < 1 << 19 else -1))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree1():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
# for i in range(self.n-1, 0, -1):
# self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
return
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
return
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 20
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = 1 << 18
st1 = SegmentTree1([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < 1 << 19 else -1))
| p02575 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree1():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
# for i in range(self.n-1, 0, -1):
# self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
return
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
return
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 18
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = 1 << 18
st1 = SegmentTree1([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < 202020 else -1))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTree1():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
# for i in range(self.n-1, 0, -1):
# self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
return
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
return
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 18
f = lambda x, y: x
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
N = W + 2
st1 = SegmentTree1([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1) , 0, -1, f, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), 0, -1, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < inf else -1))
| p02575 |
import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTreeDual():
def __init__(self, init, unitX, unitA, g, h):
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitA = unitA
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 18
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
unitA = -1
unitX = inf
N = W + 2
st1 = SegmentTreeDual([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1), unitX, unitA, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
unitX = inf
unitA = -1
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), unitX, unitA, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
t = st2.getrange(0, N)
print((t + i + 1 if t < inf else -1))
| import sys
input = lambda: sys.stdin.readline().rstrip()
class SegmentTreeDual():
def __init__(self, init, unitX, unitA, g, h):
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitA = unitA
if type(init) == int:
self.n = init
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
class SegmentTree():
def __init__(self, init, unitX, unitA, f, g, h):
self.f = f # (X, X) -> X
self.g = g # (X, A, size) -> X
self.h = h # (A, A) -> A
self.unitX = unitX
self.unitA = unitA
self.f = f
if type(init) == int:
self.n = init
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * (self.n * 2)
self.size = [1] * (self.n * 2)
else:
self.n = len(init)
# self.n = 1 << (self.n - 1).bit_length()
self.X = [unitX] * self.n + init + [unitX] * (self.n - len(init))
self.size = [0] * self.n + [1] * len(init) + [0] * (self.n - len(init))
for i in range(self.n-1, 0, -1):
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
for i in range(self.n - 1, 0, -1):
self.size[i] = self.size[i*2] + self.size[i*2|1]
self.A = [unitA] * (self.n * 2)
def update(self, i, x):
i += self.n
self.X[i] = x
i >>= 1
while i:
self.X[i] = self.f(self.X[i*2], self.X[i*2|1])
i >>= 1
def calc(self, i):
return self.g(self.X[i], self.A[i], self.size[i])
def calc_above(self, i):
i >>= 1
while i:
self.X[i] = self.f(self.calc(i*2), self.calc(i*2|1))
i >>= 1
def propagate(self, i):
self.X[i] = self.g(self.X[i], self.A[i], self.size[i])
self.A[i*2] = self.h(self.A[i*2], self.A[i])
self.A[i*2|1] = self.h(self.A[i*2|1], self.A[i])
self.A[i] = self.unitA
def propagate_above(self, i):
H = i.bit_length()
for h in range(H, 0, -1):
self.propagate(i >> h)
def propagate_all(self):
for i in range(1, self.n):
self.propagate(i)
def getrange(self, l, r):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
al = self.unitX
ar = self.unitX
while l < r:
if l & 1:
al = self.f(al, self.calc(l))
l += 1
if r & 1:
r -= 1
ar = self.f(self.calc(r), ar)
l >>= 1
r >>= 1
return self.f(al, ar)
def getvalue(self, i):
i += self.n
self.propagate_above(i)
return self.calc(i)
def operate_range(self, l, r, a):
l += self.n
r += self.n
l0, r0 = l // (l & -l), r // (r & -r) - 1
self.propagate_above(l0)
self.propagate_above(r0)
while l < r:
if l & 1:
self.A[l] = self.h(self.A[l], a)
l += 1
if r & 1:
r -= 1
self.A[r] = self.h(self.A[r], a)
l >>= 1
r >>= 1
self.calc_above(l0)
self.calc_above(r0)
def debug(self):
print(("self.n =", self.n))
deX = []
deA = []
deS = []
a, b = self.n, self.n * 2
while b:
deX.append(self.X[a:b])
deA.append(self.A[a:b])
deS.append(self.size[a:b])
a, b = a//2, a
print("--- debug ---")
for d in deX[::-1]:
print(d)
print("--- ---")
for d in deA[::-1]:
print(d)
print("--- ---")
for d in deS[::-1]:
print(d)
print("--- ---")
H, W = list(map(int, input().split()))
inf = 1 << 18
g = lambda x, a, s: x if a == -1 else a
h = lambda a, b: a if b == -1 else b
unitA = -1
unitX = inf
N = W + 2
st1 = SegmentTreeDual([-inf] + [i for i in range(1, W + 1)] + [-inf] * (N - W - 1), unitX, unitA, g, h)
f2 = lambda x, y: min(x, y)
g2 = lambda x, a, s: x if a == -1 else a
h2 = lambda a, b: a if b == -1 else b
unitX = inf
unitA = -1
st2 = SegmentTree([inf] + [0 for i in range(1, W + 1)] + [inf] * (N - W - 1), unitX, unitA, f2, g2, h2)
for i in range(H):
a, b = list(map(int, input().split()))
b += 1
l = st1.getvalue(a-1)
st2.operate_range(a, a+1, a - l)
st2.operate_range(a+1, b, inf)
r = st1.getvalue(b)
st2.operate_range(b, b+1, b - r)
st1.operate_range(a, b, l)
print((st2.X[1] + i + 1 if st2.X[1] < inf else -1))
| p02575 |
def collatz(n):
c = 0
while n > 1:
if n%2: n = 3*n+1
else: n /= 2
c += 1
return c
while True:
n = int(input())
if n == 0: break
print(collatz(n)) | def f(n):
c=0
while n>1:
if n%2:n=3*n+1
else:n /= 2
c += 1
print(c)
while 1:
n=eval(input())
if n==0:break
f(n) | p00158 |
import sys
for line in sys.stdin:
l = [int(i) for i in line.split(' ')]
print(len(str(l[0] + l[1]))) | import sys
for s in sys.stdin:
a,b = list(map(int,s.split()))
print(len(str(a+b))) | p00002 |
import math
while True:
try:
line = input().split(" ")
a = int(line[0])
b = int(line[1])
print((int(math.log10(a+b))+1))
except:
break | import math
while True:
try:
line = input().split(" ")
print((int(math.log10(int(line[0])+int(line[1])))+1))
except:
break | p00002 |
while True:
try:
print((len(str(sum(map(int, input().split()))))))
except EOFError:
break | import sys
[print(len(str(y[0] + y[1]))) for y in [[int(z) for z in x.split()] for x in sys.stdin]]
| p00002 |
import sys
from math import log10
for line in sys.stdin:
a, b = list(map(int, line.split()))
digitNumber = int(log10((a + b))) + 1
print(digitNumber) | import sys
for line in sys.stdin:
a, b = list(map(int, line.split()))
digitNumber = len(str(a + b))
print(digitNumber) | p00002 |
import sys
strs = sys.stdin.readlines()
for s in strs:
a, b = list(map(int, s.split()))
print((len(str(a + b)))) | import sys
for line in sys.stdin:
a, b = list(map(int, line.split()))
print((len(str(a + b)))) | p00002 |
import sys
a=[map(int,i.split()) for i in sys.stdin]
[print(len(str(b+c))) for b,c in a]
| import sys
for a in sys.stdin:
b,c=list(map(int,a.split()))
d=len(str(b+c))
print(d) | p00002 |
import sys
for a in sys.stdin:
b,c=list(map(int,a.split()))
d=len(str(b+c))
print(d) | import sys
a=[map(int,i.split())for i in sys.stdin]
[print(len(str(b+c)))for b,c in a]
| p00002 |
import sys
for line in sys.stdin:
x, y = list(map(int, line.split()))
print((len(str(x+y)))) | import sys
[print(len(str(sum(map(int, line.split()))))) for line in sys.stdin]
| p00002 |
import sys
for s in sys.stdin:
print(len(str(sum(map(int,s.split()))))) | import sys
for s in sys.stdin:
x=len(str(sum(map(int,s.split()))))
print(x) | p00002 |
while 1:
try:
a, b = list(map(int, input().split()))
c = str(a + b)
print((len(c)))
except:
break | import sys
def solve():
while True:
try:
a, b = list(map(int, sys.stdin.readline().split()))
c = a + b
if c == 0:
print((1))
else:
ans = 0
while c > 0:
ans += 1
c //= 10
print(ans)
except:
return
if __name__ == '__main__':
solve() | p00002 |
from collections import defaultdict
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
S = sum(A)
DP = [defaultdict(int)]
DP[0][0] = 2
DP[0][A[0]] = 1
DP2 = [defaultdict(int)] # R=G=S/2, B=0
DP2[0][0] = 1
DP2[0][A[0]] = 1
for i in range(1, N):
curr = defaultdict(int)
curr2 = defaultdict(int)
for (key, val) in list(DP[-1].items()):
curr[key] += val*2 # B,G
curr[key+A[i]] += val # R
for (key, val) in list(DP2[-1].items()):
curr2[key] += val # G
curr2[key+A[i]] += val # R
DP.append(curr)
DP2.append(curr2)
# print(DP)
# print(DP2)
ans = 3**N
for (key, val) in list(DP[-1].items()):
if key >= S/2:
ans -= 3*val
if S % 2 == 0:
ans += 3*DP2[-1][S//2]
print((ans % 998244353))
| from collections import defaultdict
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
S = sum(A)
DP = [[0]*(S+1) for _ in range(2)]
DP[0][0] = 2
DP[0][A[0]] = 1
# R=G=S/2, B=0
DP2 = [[0]*(S+1) for _ in range(2)]
DP2[0][0] = 1
DP2[0][A[0]] = 1
max_A = A[0]
for i in range(1, N):
a = A[i]
max_A += a
curr_dp = DP[i % 2]
prev_dp = DP[(i+1) % 2]
curr_dp2 = DP2[i % 2]
prev_dp2 = DP2[(i+1) % 2]
for r in range(max_A+1):
if r >= a:
curr_dp[r] = prev_dp[r]*2 + prev_dp[r-a]
curr_dp2[r] = prev_dp2[r] + prev_dp2[r-a]
else:
curr_dp[r] = prev_dp[r]*2
curr_dp2[r] = prev_dp2[r]
#print(DP)
#print(DP2)
half_S = (S+1)//2
ans = (3**N) - 3*sum(DP[(N-1) % 2][half_S:])
if S % 2 == 0:
ans += 3*DP2[(N-1) % 2][S//2]
print((ans % 998244353))
| p03064 |
from collections import defaultdict
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
S = sum(A)
DP = [[0]*(S+1) for _ in range(2)]
DP[0][0] = 2
DP[0][A[0]] = 1
# R=G=S/2, B=0
DP2 = [[0]*(S+1) for _ in range(2)]
DP2[0][0] = 1
DP2[0][A[0]] = 1
max_A = A[0]
for i in range(1, N):
a = A[i]
max_A += a
curr_dp = DP[i % 2]
prev_dp = DP[(i+1) % 2]
curr_dp2 = DP2[i % 2]
prev_dp2 = DP2[(i+1) % 2]
for r in range(max_A+1):
if r >= a:
curr_dp[r] = prev_dp[r]*2 + prev_dp[r-a]
curr_dp2[r] = prev_dp2[r] + prev_dp2[r-a]
else:
curr_dp[r] = prev_dp[r]*2
curr_dp2[r] = prev_dp2[r]
#print(DP)
#print(DP2)
half_S = (S+1)//2
ans = (3**N) - 3*sum(DP[(N-1) % 2][half_S:])
if S % 2 == 0:
ans += 3*DP2[(N-1) % 2][S//2]
print((ans % 998244353))
| from collections import defaultdict
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
S = sum(A)
DP = [[0]*(S+1) for _ in range(2)]
DP[0][0] = 2
DP[0][A[0]] = 1
# R=G=S/2, B=0
DP2 = [[0]*(S+1) for _ in range(2)]
DP2[0][0] = 1
DP2[0][A[0]] = 1
max_A = A[0]
for i in range(1, N):
a = A[i]
max_A += a
curr_dp = DP[i % 2]
prev_dp = DP[(i+1) % 2]
curr_dp2 = DP2[i % 2]
prev_dp2 = DP2[(i+1) % 2]
for r in range(max_A+1):
if r >= a:
curr_dp[r] = prev_dp[r]*2 + prev_dp[r-a]
curr_dp2[r] = prev_dp2[r] + prev_dp2[r-a]
else:
curr_dp[r] = prev_dp[r]*2
curr_dp2[r] = prev_dp2[r]
curr_dp[r] %= 998244353
curr_dp2[r] %= 998244353
# print(DP)
# print(DP2)
half_S = (S+1)//2
ans = pow(3, N, 998244353)
ans -= 3*sum(DP[(N-1) % 2][half_S:])
if S % 2 == 0:
ans += 3*DP2[(N-1) % 2][S//2]
print((ans % 998244353))
| p03064 |
from collections import defaultdict
MOD = 998244353
def main():
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
total = sum(A)
half = -(-total//2)
dp1 = [defaultdict(lambda: 0) for _ in range(N+1)]
dp1[0][0] = 1
dp2 = [defaultdict(lambda: 0) for _ in range(N+1)]
dp2[0][0] = 1
for i in range(N):
for j in dp1[i]:
nj = min(j+A[i], half+1)
dp1[i+1][j] = (dp1[i+1][j] + dp1[i][j] * 2) % MOD
dp1[i+1][nj] = (dp1[i+1][nj] + dp1[i][j]) % MOD
dp2[i+1][j] = (dp2[i+1][j] + dp2[i][j]) % MOD
dp2[i+1][nj] = (dp2[i+1][nj] + dp2[i][j]) % MOD
ans = (3**N) % MOD
for t in dp1[N]:
if t >= -(-total//2):
ans = (ans - dp1[N][t] * 3) % MOD
if total % 2 == 0 and t == total // 2:
ans = (ans + dp2[N][t] * 3) % MOD
print(ans)
if __name__ == "__main__":
main()
| from collections import defaultdict
MOD = 998244353
def main():
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
total = sum(A)
half = -(-total//2)
dp1 = [defaultdict(lambda: 0) for _ in range(2)]
dp1[0][0] = 1
dp2 = [defaultdict(lambda: 0) for _ in range(2)]
dp2[0][0] = 1
for i in range(N):
dp1[(i+1) & 1] = defaultdict(lambda: 0)
dp2[(i+1) & 1] = defaultdict(lambda: 0)
for j in dp1[i & 1]:
nj = min(j+A[i], half+1)
dp1[(i+1) & 1][j] = (dp1[(i+1) & 1][j] + dp1[i & 1][j] * 2) % MOD
dp1[(i+1) & 1][nj] = (dp1[(i+1) & 1][nj] + dp1[i & 1][j]) % MOD
dp2[(i+1) & 1][j] = (dp2[(i+1) & 1][j] + dp2[i & 1][j]) % MOD
dp2[(i+1) & 1][nj] = (dp2[(i+1) & 1][nj] + dp2[i & 1][j]) % MOD
ans = (3**N) % MOD
for t in dp1[N & 1]:
if t >= -(-total//2):
ans = (ans - dp1[N & 1][t] * 3) % MOD
if total % 2 == 0 and t == total // 2:
ans = (ans + dp2[N & 1][t] * 3) % MOD
print(ans)
if __name__ == "__main__":
main()
| p03064 |
N, *A = list(map(int, open(0).read().split()))
MOD = 998244353
S = sum(A)
dp0 = [0]*(S+1)
dp0[0] = 1
dp1 = [0]*(S+1)
dp1[0] = 1
for a in A:
for i in range(S, a-1, -1):
dp0[i] = (dp0[i] + dp0[i-a]*2) % MOD
dp1[i] = (dp1[i] + dp1[i-a]) % MOD
ans = pow(3, N, MOD)
for L in range(0, S+1):
if L <= S-L:
ans = (ans - dp0[L]*3) % MOD
if S % 2 == 0:
ans = (ans + dp1[S//2]*3) % MOD
print(ans) | N, *A = list(map(int, open(0).read().split()))
MOD = 998244353
S = sum(A)
dp0 = [0]*(S+1)
dp0[0] = 1
for a in A:
for i in range(S, a-1, -1):
dp0[i] = (dp0[i] + dp0[i-a]*2) % MOD
dp1 = [0]*(S+1)
dp1[0] = 1
for a in A:
for i in range(S, a-1, -1):
dp1[i] = (dp1[i] + dp1[i-a]) % MOD
ans = pow(3, N, MOD)
for L in range(0, S//2+1):
ans = (ans - dp0[L]*3) % MOD
if S % 2 == 0:
ans = (ans + dp1[S//2]*3) % MOD
print(ans) | p03064 |
M=998244353
N,*A=open(0)
d=[0]*90001
d[0]=1
e=[0]*90001
e[0]=1
z=1
s=0
for a in A:
i=s;a=int(a);s+=a;z*=3
while~i:d[i+a]+=d[i]%M;d[i]*=2;e[i+a]+=e[i]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print(([(z+e[s//2]*3)%M,z][s%2])) | M=998244353
N,*A=open(0)
d=[0]*90001
d[0]=1
e=[0]*90001
e[0]=1
z=1
s=0
for a in A:
i=s;a=int(a);s+=a;z*=3
while~i:d[i+a]+=d[i]%M;d[i]*=2;e[i+a]+=e[i]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
if~s%2:z+=e[s//2]*3
print((z%M)) | p03064 |
M=998244353
N,*A=open(0)
d=[0]*90301
d[0]=1
e=[0]*90301
e[0]=1
z=1
s=0
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]=d[i]*2+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
z+=~s%2*e[s//2]*3
print((z%M)) | M=998244353
N,*A=open(0)
d=[0]*90301
d[0]=1
e=[0]*90301
e[0]=1
z=1
s=0
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
z+=~s%2*e[s//2]*3
print((z%M)) | p03064 |
M=998244353
N,*A=open(0)
d=[1]+[0]*7**6
e=[1]+[0]*7**6
z=1
s=0
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
z+=~s%2*e[s//2]*3
print((z%M)) | M=998244353
N,*A=open(0)
d=[1]+[0]*7**6
e=[1]+[0]*7**6
z=1
s=0
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print(((z+~s%2*e[s//2]*3)%M)) | p03064 |
M=998244353
N,*A=open(0)
d=[1]+[0]*7**6
e=[1]+[0]*7**6
z=1
s=0
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print(((z+~s%2*e[s//2]*3)%M)) | M,z,s=998244353,1,0
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for _ in'_'*eval(input()):
a=eval(input());s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print((z+~s%2*e[s//2]*3)%M) | p03064 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
w = sum(a)
mod =998244353
dp = [[0]*(w+1) for i in range(n)]
cnt = a[0]
dp[0][a[0]] = 1
dp[0][0] = 2
for i in range(1,n):
cnt += a[i]
for j in range(cnt+1):
dp[i][j] = dp[i-1][j]*2
if j >= a[i]:
dp[i][j] += dp[i-1][j-a[i]]
#sより大きいのはブー
s = w//2+1
if w %2 == 0:
d = [[0]*(s+1) for i in range(n)]
d[0][0] = 1
d[0][a[0]] = 1
cnt = a[0]
for i in range(1,n):
cnt += a[i]
for j in range(min(cnt+1,s+1)):
d[i][j] = d[i-1][j]
if j >= a[i]:
d[i][j] += d[i-1][j-a[i]]
d[i][j] = d[i][j]%mod
mns = d[-1][w//2]
if w%2 == 0:
s -= 1
cnt = 0
for i in range(s,w+1):
cnt += dp[-1][i]
cnt = cnt%mod
res = (pow(3,n,mod)-cnt*3)%mod
if w % 2 == 0:
res = (res+mns*3)%mod
print(res) | import sys
input = sys.stdin.readline
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
w = sum(a)
mod =998244353
dp = [[0]*(w+1) for i in range(n)]
cnt = a[0]
dp[0][a[0]] = 1
dp[0][0] = 2
for i in range(1,n):
cnt += a[i]
for j in range(cnt+1):
dp[i][j] = dp[i-1][j]*2
if j >= a[i]:
dp[i][j] += dp[i-1][j-a[i]]
dp[i][j] = dp[i][j]%mod
#sより大きいのはブー
s = w//2+1
if w %2 == 0:
d = [[0]*(s+1) for i in range(n)]
d[0][0] = 1
d[0][a[0]] = 1
cnt = a[0]
for i in range(1,n):
cnt += a[i]
for j in range(min(cnt+1,s+1)):
d[i][j] = d[i-1][j]
if j >= a[i]:
d[i][j] += d[i-1][j-a[i]]
d[i][j] = d[i][j]%mod
mns = d[-1][w//2]
if w%2 == 0:
s -= 1
cnt = 0
for i in range(s,w+1):
cnt += dp[-1][i]
cnt = cnt%mod
res = (pow(3,n,mod)-cnt*3)%mod
if w % 2 == 0:
res = (res+mns*3)%mod
print(res)
| p03064 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sum_A = sum(A)
MOD = 998244353
dp1 = [0] * (sum_A + 1)
dp2 = [0] * (sum_A + 1)
dp1[0] = dp2[0] = 1
for a in A:
dp1_ = [0] * (sum_A + 1)
dp2_ = [0] * (sum_A + 1)
for i in range(sum_A + 1):
if i - a >= 0:
# R に塗れる場合
dp1_[i] = (dp1[i - a] + dp1[i] * 2) % MOD
dp2_[i] = (dp2[i - a] + dp2[i]) % MOD
else:
dp1_[i] = (dp1[i] * 2) % MOD
dp2_[i] = dp2[i]
dp1, dp2 = dp1_, dp2_
ans = pow(3, N, MOD)
for i in range(sum_A + 1):
if i * 2 >= sum_A:
ans = (ans - dp1[i] * 3 + MOD * 3) % MOD
if i * 2 == sum_A:
ans = (ans + dp2[i] * 3) % MOD
print(ans)
| N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sum_A = sum(A)
MOD = 998244353
dp1 = [0] * (sum_A + 1)
dp2 = [0] * (sum_A + 1)
dp1[0] = dp2[0] = 1
for a in A:
for i in reversed(list(range(sum_A + 1))):
if i - a >= 0:
# R に塗れる場合
dp1[i] = (dp1[i - a] + dp1[i] * 2) % MOD
dp2[i] = (dp2[i - a] + dp2[i]) % MOD
else:
dp1[i] = (dp1[i] * 2) % MOD
dp2[i] = dp2[i]
ans = pow(3, N, MOD)
for i in range(sum_A + 1):
if i * 2 >= sum_A:
ans = (ans - dp1[i] * 3 + MOD * 3) % MOD
if i * 2 == sum_A:
ans = (ans + dp2[i] * 3) % MOD
print(ans)
| p03064 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sum_A = sum(A)
MOD = 998244353
dp1 = [0] * (sum_A + 1)
dp2 = [0] * (sum_A + 1)
dp1[0] = dp2[0] = 1
for a in A:
for i in reversed(list(range(sum_A + 1))):
if i - a >= 0:
# R に塗れる場合
dp1[i] = (dp1[i - a] + dp1[i] * 2) % MOD
dp2[i] = (dp2[i - a] + dp2[i]) % MOD
else:
dp1[i] = (dp1[i] * 2) % MOD
dp2[i] = dp2[i]
ans = pow(3, N, MOD)
for i in range(sum_A + 1):
if i * 2 >= sum_A:
ans = (ans - dp1[i] * 3 + MOD * 3) % MOD
if i * 2 == sum_A:
ans = (ans + dp2[i] * 3) % MOD
print(ans)
| N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
sum_A = sum(A)
MOD = 998244353
dp1 = [0] * (sum_A + 1)
dp2 = [0] * (sum_A + 1)
dp1[0] = dp2[0] = 1
tmp_sum = 0
for a in A:
tmp_sum += a
for i in reversed(list(range(tmp_sum + 1))):
if i - a >= 0:
# R に塗れる場合
dp1[i] = (dp1[i - a] + dp1[i] * 2) % MOD
dp2[i] = (dp2[i - a] + dp2[i]) % MOD
else:
dp1[i] = (dp1[i] * 2) % MOD
dp2[i] = dp2[i]
ans = pow(3, N, MOD)
for i in range(sum_A + 1):
if i * 2 >= sum_A:
ans = (ans - dp1[i] * 3 + MOD * 3) % MOD
if i * 2 == sum_A:
ans = (ans + dp2[i] * 3) % MOD
print(ans)
| p03064 |
MOD = 998244353
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
total = sum(a)
sup = (total - 1) // 2
# total > 2 * max(R,G,B)
# を満たすR,G,Bの場合の数
# (total - 1) // 2 >= max(R,G,B)
dp = [[[0 for _ in range(total + 1)] for _ in range(total + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
# dp[i][R][G]:=i番目まででRGとなる総数
# 枝刈り
# sup = (total - 1) // 2
# sup >= max(R,G,B)
# supを超えるRGBはdp遷移時にカット
for i in range(N):
# a[i]はRGBのいずれかに加算
for s in range(2 * sup + 1):
for r in range(a[i], min(s, sup) + 1):
g = s - r
dp[i + 1][r][g] += dp[i][r - a[i]][g]
dp[i + 1][r][g] %= MOD
for g in range(a[i], min(s, sup) + 1):
r = s - g
dp[i + 1][r][g] += dp[i][r][g - a[i]]
dp[i + 1][r][g] %= MOD
for r in range(min(s, sup) + 1):
g = s - r
dp[i + 1][r][g] += dp[i][r][g]
dp[i + 1][r][g] %= MOD
# Bに対応
ans = sum(dp[N][r][g] for r in range(sup + 1) for g in range(sup + 1) if total - r - g <= sup)
ans %= MOD
print(ans)
| # https://atcoder.jp/contests/tenka1-2019/submissions/5065329
import sys
input = sys.stdin.readline
N = int(eval(input()))
a = [int(eval(input())) for _ in range(N)]
total = sum(a)
MOD = 998244353
'''(1)全体'''
U = pow(3, N, MOD) # 三角形を構成できない場合を含むRGBの組み合わせ総数
'''(2)単円'''
dp = [[0] * (total + 1) for _ in range(N + 1)]
dp[0][0] = 1
# dp[i][R]:=i番目まででRとなる場合の数
for i in range(N):
for r in range(total + 1):
if r - a[i] >= 0:
dp[i + 1][r] += dp[i][r - a[i]]
dp[i + 1][r] += 2 * dp[i][r]
# g, bに加算する分で、2回起こる
# print(dp)
single_circle = 0
for r in range(total + 1):
if r >= (total / 2):
single_circle += dp[N][r]
# print(single_circle)
'''(3)２円の積集合'''
if total % 2 == 0:
dp2 = [[0] * (total + 1) for _ in range(N + 1)]
dp2[0][0] = 1
# dp[i][R]:=i番目まででRとなる場合の数
for i in range(N):
for r in range(int(total / 2) + 1):
if r - a[i] >= 0:
dp2[i + 1][r] += dp2[i][r - a[i]]
dp2[i + 1][r] += dp2[i][r]
# print(dp2)
two_circle_intersect = dp2[N][int(total / 2)] if total % 2 == 0 else 0
'''(3)３円の積集合'''
three_circle_intersect = 0
'''(4)解答'''
ans = 0
ans += U
ans %= MOD
ans -= 3 * single_circle
ans %= MOD
ans += 3 * two_circle_intersect
ans %= MOD
ans -= three_circle_intersect
ans %= MOD
print(ans) | p03064 |
from math import ceil
# 入力
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
MOD = 998244353
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
S = sum(A)
# 赤色の整数の和がiとなるような塗り方の個数
dp = [ModInt(0) for _ in range(S + 1)]
dp[0] = ModInt(1)
# 赤色の整数の和がi, 他の整数がすべて青色となるような塗り方の個数
dp2 = [ModInt(0) for _ in range(S // 2 + 1)]
dp2[0] = ModInt(1)
# 動的計画法により、dp, dp2を求める
for a in A:
for i in range(S, a - 1, -1):
dp[i] = dp[i] * 2 + dp[i - a]
for i in range(a - 1, -1, -1):
dp[i] = dp[i] * 2
for i in range(S // 2, a - 1, -1):
dp2[i] = dp2[i] + dp2[i - a]
# 全ての塗り方の個数から、条件を満たさない塗り方の個数を差し引いて解を求める
ans = 3**N - 3 * sum(dp[ceil(S / 2):]) + (
3 * dp2[S // 2] if S % 2 == 0 else
0
)
# 出力
print(ans)
| from math import ceil
# 入力
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
MOD = 998244353
S = sum(A)
# 赤色の整数の和がiとなるような塗り方の個数
dp = [0 for _ in range(S + 1)]
dp[0] = 1
# 赤色の整数の和がi, 他の整数がすべて青色となるような塗り方の個数
dp2 = [0 for _ in range(S // 2 + 1)]
dp2[0] = 1
# 動的計画法により、dp, dp2を求める
for a in A:
for i in range(S, a - 1, -1):
dp[i] = (2 * dp[i] + dp[i - a]) % MOD
for i in range(a - 1, -1, -1):
dp[i] = (2 * dp[i]) % MOD
for i in range(S // 2, a - 1, -1):
dp2[i] = (dp2[i] + dp2[i - a]) % MOD
# 全ての塗り方の個数から、条件を満たさない塗り方の個数を差し引いて解を求める
ans = (3**N - 3 * sum(dp[ceil(S / 2):]) + (
3 * dp2[S // 2] if S % 2 == 0 else
0
)) % MOD
# 出力
print(ans)
| p03064 |
import sys
input = sys.stdin.readline
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
SUM=sum(A)
MAX=(SUM-1)//2
mod=998244353
from collections import Counter
DPLIST=[[0]*301 for i in range(MAX+2)]
DPLIST[0][0]=1
ANS=0
for a in A:
for i in range(299,-1,-1):
for j in range(MAX+1,-1,-1):
DPLIST[min(j+a,MAX+1)][i+1]+=DPLIST[j][i]
ANS=(pow(3,N,mod)-3*pow(2,N,mod))%mod
MINUS=0
for i in range(N-1):
MINUS+=3*(pow(2,(N-i),mod)-2)*DPLIST[MAX+1][i]
print(((ANS-MINUS+3)%mod)) | import sys
input = sys.stdin.readline
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
SUM=sum(A)
MAX=(SUM-1)//2
mod=998244353
DPLIST=[0]*(MAX+2)
DPLIST[0]=1
for a in A:
for i in range(MAX+1,-1,-1):
if i==MAX+1:
DPLIST[i]=DPLIST[i]*3%mod
else:
DPLIST[min(i+a,MAX+1)]=(DPLIST[min(i+a,MAX+1)]+DPLIST[i])%mod
DPLIST[i]=DPLIST[i]*2%mod
if SUM%2==1:
print(((sum(DPLIST)-DPLIST[-1]*3)%mod))
sys.exit()
MAX=SUM//2
DPLIST2=[0]*(MAX+2)
DPLIST2[0]=1
for a in A:
for i in range(MAX+1,-1,-1):
DPLIST2[min(i+a,MAX+1)]=(DPLIST2[min(i+a,MAX+1)]+DPLIST2[i])%mod
print(((sum(DPLIST)-DPLIST[-1]*3+DPLIST2[-2]*3)%mod)) | p03064 |
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
MOD = 998244353
S = sum(A)
dp = [[0]*(S+1) for _ in range(N+1)]
dp[0][0] = 1
dp2 = [[0]*(S+1) for _ in range(N+1)]
dp2[0][0] = 1
for i in range(N):
a = A[i]
x = 0
while x <= S:
if x + a <= S:
dp[i+1][x+a] += dp[i][x]
dp2[i+1][x+a] += dp2[i][x]
dp[i+1][x] += dp[i][x] * 2
dp2[i+1][x] += dp2[i][x]
x += 1
if S % 2 == 0:
ans = 3 ** N - sum(dp[N][S//2:]) * 3
ans += 3 * dp2[N][S//2]
else:
ans = 3 ** N - sum(dp[N][S//2 + 1:]) * 3
print((ans % MOD)) | N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
MOD = 998244353
S = sum(A)
dp = [[0]*(S+1) for _ in range(N+1)]
dp[0][0] = 1
dp2 = [[0]*(S+1) for _ in range(N+1)]
dp2[0][0] = 1
for i in range(N):
a = A[i]
x = 0
while x <= S:
if x + a <= S:
dp[i+1][x+a] += dp[i][x] % MOD
dp2[i+1][x+a] += dp2[i][x] % MOD
dp[i+1][x] += dp[i][x] * 2 % MOD
dp2[i+1][x] += dp2[i][x] % MOD
x += 1
if S % 2 == 0:
ans = 3 ** N - sum(dp[N][S//2:]) * 3
ans += 3 * dp2[N][S//2]
else:
ans = 3 ** N - sum(dp[N][S//2 + 1:]) * 3
print((ans % MOD))
| p03064 |
MOD = 998244353
def pow(n,k,m):#n^k mod m
ans = 1
while k>0:
if(k & 1):ans = (ans*n) % m
n = (n*n)%m
k >>= 1
return ans
n = int(eval(input()))
a =[int(eval(input())) for i in range(n)]
s = sum(a)
dp1 = [0 for i in range(s+1)] #dp1[x]:Bの和=xとなるような塗り方の総数
dp1[0] = 1
for i in range(n):
dpp1 = [0 for i in range(s+1)]
for j in range(s+1):
if j+a[i] <= s:dpp1[j+a[i]] = (dp1[j]+dpp1[j+a[i]]) % MOD
dpp1[j] = (dp1[j]*2 + dpp1[j]) % MOD
dp1 = dpp1[:]
if s % 2 == 1:
ans1 = sum(dp1[(s//2) + 1:]) % MOD
print(((pow(3,n,MOD)-ans1*3) % MOD))
exit()
ans1 = sum(dp1[(s//2):]) % MOD
dp2 = [0 for i in range(s+1)]
dp2[0] = 1
for i in range(n):
dpp2 = [0 for i in range(s+1)]
for j in range(s+1):
if j+a[i] <= s:dpp2[j+a[i]] = (dp2[j]+dpp2[j+a[i]]) % MOD
dpp2[j] = (dp2[j] + dpp2[j]) % MOD
dp2 = dpp2[:]
print(((pow(3,n,MOD)-(ans1*3 - dp2[s//2]*3)) % MOD)) | MOD = 998244353
def pow(n,k,m):#n^k mod m
ans = 1
while k>0:
if(k & 1):ans = (ans*n) % m
n = (n*n)%m
k >>= 1
return ans
n = int(eval(input()))
a =[int(eval(input())) for i in range(n)]
s = sum(a)
dp1 = [0 for i in range(s+1)] #dp1[x]:Bの和=xとなるような塗り方の総数
dp1[0] = 1
for i in a:
dpp1 = [0 for i in range(s+1)]
for j in range(s+1):
if j+i <= s:dpp1[j+i] = (dp1[j]+dpp1[j+i]) % MOD
dpp1[j] = (dp1[j]*2 + dpp1[j]) % MOD
dp1 = dpp1[:]
if s % 2 == 1:
ans1 = sum(dp1[(s//2) + 1:]) % MOD
print(((pow(3,n,MOD)-ans1*3) % MOD))
exit()
ans1 = sum(dp1[(s//2):]) % MOD
dp2 = [0 for i in range(s+1)]
dp2[0] = 1
for i in a:
dpp2 = [0 for i in range(s+1)]
for j in range(s+1):
if j+i <= s:dpp2[j+i] = (dp2[j]+dpp2[j+i]) % MOD
dpp2[j] = (dp2[j] + dpp2[j]) % MOD
dp2 = dpp2[:]
print(((pow(3,n,MOD)-(ans1*3 - dp2[s//2]*3)) % MOD)) | p03064 |
M,z,s=998244353,1,0
N,*A=list(map(int,open(0)))
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for a in A:
i=s;s+=a;z*=3
while~i:d[i+a]+=d[i]%M;d[i]*=2;e[i+a]+=e[i]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print(((z+~s%2*e[s//2]*3)%M)) | M,z,s=998244353,1,0
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for _ in'_'*eval(input()):
a=eval(input());s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z=(z-d[i]*3)%M;i-=1
print((z+~s%2*e[s//2]*3)%M) | p03064 |
M,z,s=998244353,1,0
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for _ in'_'*eval(input()):
a=eval(input());s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a];i-=1
i=s
while i*2>=s:z-=d[i]*3;i-=1
print((z+~s%2*e[s//2]*3)%M) | M,z,s=998244353,1,0
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for _ in'_'*eval(input()):
a=eval(input());s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
i=s
while i*2>=s:z-=d[i]*3;i-=1
print((z+~s%2*e[s//2]*3)%M) | p03064 |
M,z,s=998244353,1,0
N,*A=open(0)
d=[1]+[0]*7**6
e=[1]+[0]*7**6
for a in A:
a=int(a);s+=a;i=s;z*=3
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
print(((z+~s%2*e[s//2]*3-3*sum(d[-~s//2:]))%M)) | M,s=998244353,0
d=[1]+[0]*7**6
e=d[:]
n=eval(input())
for _ in'_'*n:
a=eval(input());s+=a;i=s
while~i:d[i]+=d[i]+d[i-a]%M;e[i]+=e[i-a]%M;i-=1
print((3**n+~s%2*e[s//2]*3-3*sum(d[-~s//2:]))%M) | p03064 |
mod = 998244353
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
A.sort()
S = sum(A)
PS = [0 for i in range(N+1)]
for i in range(N):
PS[i+1] = PS[i] + A[i]
# D[i][r]: i個塗った時点でR=rとなる場合の数
D = [[0 for _ in range(PS[i]+1)] for i in range(N+1)]
D[0][0] = 1
# D2[i][r]: i個塗った時点でR=r, B=0となる場合の数
D2 = [[0 for _ in range(PS[i]+1)] for i in range(N+1)]
D2[0][0] = 1
for i in range(N):
for j in range(PS[i]+1):
if D[i][j] == 0:
continue
D[i+1][j] += D[i][j] * 2
D[i+1][j+A[i]] += D[i][j]
for i in range(N):
for j in range(PS[i]+1):
if D2[i][j] == 0:
continue
D2[i+1][j] += D2[i][j]
D2[i+1][j+A[i]] += D2[i][j]
border = (S + 1) // 2
result = 3 ** N
result -= 3 * sum(D[N][border:])
if border * 2 == S:
result += 3 * D2[N][border]
print((result % mod))
| mod = 998244353
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
A.sort()
S = sum(A)
PS = [0 for i in range(N+1)]
for i in range(N):
PS[i+1] = PS[i] + A[i]
# D[i][r]: i個塗った時点でR=rとなる場合の数
D = [[0 for _ in range(PS[i]+1)] for i in range(N+1)]
D[0][0] = 1
# D2[i][r]: i個塗った時点でR=r, B=0となる場合の数
D2 = [[0 for _ in range(PS[i]+1)] for i in range(N+1)]
D2[0][0] = 1
for i in range(N):
for j in range(PS[i]+1):
if D[i][j] == 0:
continue
D[i+1][j] = (D[i+1][j] + D[i][j] * 2) % mod
D[i+1][j+A[i]] = (D[i+1][j+A[i]] + D[i][j]) % mod
for i in range(N):
for j in range(PS[i]+1):
if D2[i][j] == 0:
continue
D2[i+1][j] = (D2[i+1][j] + D2[i][j]) % mod
D2[i+1][j+A[i]] = (D2[i+1][j+A[i]] + D2[i][j]) % mod
border = (S + 1) // 2
result = 3 ** N
result -= 3 * sum(D[N][border:])
if border * 2 == S:
result += 3 * D2[N][border]
print((result % mod))
| p03064 |
from collections import deque
import sys
def bfs(M, sy, sx, gy, gx):
queue = deque([[sy, sx]])
M[sy][sx] = 0
while queue:
# queueには訪れた地点が入っている。そこから、4方向に移動できるか考え、queueから消す。
y, x = queue.popleft() # queueに入っていたものを消す。
if [y, x] == [gy, gx]: # もしゴールについていたならば、そのときの手数を出す。
return M[y][x]
for dx, dy in ([1, 0], [-1, 0], [0, 1], [0, -1]):
for k in range(1, K + 1):
new_x = x + dx * k
new_y = y + dy * k
if (0 <= new_y < H) and (0 <= new_x < W):
if m[new_y][new_x] == "@":
break
elif M[new_y][new_x] == -1: # まだ来たことない点だったという条件
M[new_y][new_x] = M[y][x] + 1
queue.append([new_y, new_x]) # 新しい点を足す。
elif M[new_y][new_x] < M[y][x] + 1:
break
else:
break
H, W, K = list(map(int, input().split()))
# K = min(K, max(H, W))
x1, y1, x2, y2 = list(map(int, input().split()))
x1, y1, x2, y2 = x1 - 1, y1 - 1, x2 - 1, y2 - 1
m = []
for i in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for i in range(H)]
bfs(M, x1, y1, x2, y2)
print((M[x2][y2]))
| from collections import deque
import sys
def bfs(M, sy, sx):
queue = deque([[xs, ys]])
M[sy][sx] = 0
while queue:
# queueには訪れた地点が入っている。そこから、4方向に移動できるか考え、queueから消す。
x1, y1 = queue.popleft() # queueに入っていたものを消す。
if [x1, y1] == [xg, yg]: # もしゴールについていたならば、そのときの手数を出す。
return M[x1][y1]
for dx, dy in ([1, 0], [-1, 0], [0, 1], [0, -1]):
for k in range(1, K + 1):
new_x = x1 + dx * k
new_y = y1 + dy * k
if (0 <= new_x < H) and (0 <= new_y < W):
if m[new_x][new_y] == "@":
break
elif M[new_x][new_y] == -1: # まだ来たことない点だったという条件
M[new_x][new_y] = M[x1][y1] + 1
queue.append([new_x, new_y]) # 新しい点を足す。
elif M[new_x][new_y] < M[x1][y1] + 1:
break
else:
break
H, W, K = list(map(int, input().split()))
# K = min(K, max(H, W))
xs, ys, xg, yg = list(map(int, input().split()))
xs, ys, xg, yg = xs - 1, ys - 1, xg - 1, yg - 1
m = []
for i in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for i in range(H)]
bfs(M, xs, ys)
print((M[xg][yg]))
| p02644 |
from collections import deque
import sys
def bfs(xs, ys):
queue = deque([[xs, ys]])
M[xs][ys] = 0
while queue:
# queueには訪れた地点が入っている。そこから、4方向に移動できるか考え、queueから消す。
x1, y1 = queue.popleft() # queueに入っていたものを消す。
if [x1, y1] == [xg, yg]: # もしゴールについていたならば、そのときの手数を出す。
return M[x1][y1]
for dx, dy in ([1, 0], [-1, 0], [0, 1], [0, -1]):
for k in range(1, K + 1):
new_x = x1 + dx * k
new_y = y1 + dy * k
if (0 <= new_x < H) and (0 <= new_y < W):
if m[new_x][new_y] == "@":
break
elif M[new_x][new_y] == -1: # まだ来たことない点だったという条件
M[new_x][new_y] = M[x1][y1] + 1
queue.append([new_x, new_y]) # 新しい点を足す。
elif M[new_x][new_y] < M[x1][y1] + 1:
break
else:
break
H, W, K = list(map(int, input().split()))
# K = min(K, max(H, W))
xs, ys, xg, yg = list(map(int, input().split()))
xs, ys, xg, yg = xs - 1, ys - 1, xg - 1, yg - 1
m = []
for i in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for i in range(H)]
bfs(xs, ys)
print((M[xg][yg]))
| from collections import deque
import sys
def bfs(xs, ys, d):
queue = deque()
queue.append((xs, ys, d))
M[xs][ys] = d
while queue:
# queueには訪れた地点が入っている。そこから、4方向に移動できるか考え、queueから消す。
x1, y1, d = queue.popleft() # queueに入っていたものを消す。
if [x1, y1] == [xg, yg]: # もしゴールについていたならば、そのときの手数を出す。
return
for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
for k in range(1, K + 1):
x2 = x1 + dx * k
y2 = y1 + dy * k
if (0 <= x2 < H) and (0 <= y2 < W):
if m[x2][y2] == "@":
break
elif M[x2][y2] == -1: # まだ来たことない点だったという条件
M[x2][y2] = d + 1
queue.append((x2, y2, d + 1)) # 新しい点を足す。
elif M[x2][y2] < d + 1:
break
else:
break
H, W, K = list(map(int, input().split()))
# K = min(K, max(H, W))
xs, ys, xg, yg = list(map(int, input().split()))
xs, ys, xg, yg = xs - 1, ys - 1, xg - 1, yg - 1
m = []
for i in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for i in range(H)]
bfs(xs, ys, 0)
print((M[xg][yg]))
| p02644 |
import sys
from collections import deque
def bfs(x1, y1, d):
q = deque([])
q.append((d, x1, y1))
M[x1][y1] = d
while q:
d, x1, y1 = q.popleft()
if [x1, y1] == [xg, yg]:
print(d)
return
for dx, dy in ((0, 1), (1, 0), (0, -1), (-1, 0)):
for k in range(1, K + 1):
x2 = x1 + dx * k
y2 = y1 + dy * k
# if m[x2][y2] == '@':
# break
# if x2 < 0 or x2 >= H:
# break
# if y2 < 0 or y2 >= W:
# break
# if M[x2][y2] < d + 1:
# break
# if M[x2][y2] == d + 1:
# continue
if (0 <= x2 < H) and (0 <= y2 < W):
if m[x2][y2] == '@':
break
elif M[x2][y2] == -1:
M[x2][y2] = d + 1
q.append((d + 1, x2, y2))
elif M[x2][y2] <= d:
break
elif M[x2][y2] == d + 1:
continue
else:
break
print((-1))
H, W, K = list(map(int, sys.stdin.readline().strip().split()))
xs, ys, xg, yg = list(map(int, sys.stdin.readline().strip().split()))
xg -= 1
yg -= 1
m = []
for _ in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for _ in range(H)]
bfs(xs - 1, ys - 1, 0)
| import sys
from collections import deque
def bfs(x1, y1, d):
q = deque([])
q.append((d, x1, y1))
M[x1][y1] = d
while q:
d, x1, y1 = q.popleft()
if [x1, y1] == [xg, yg]:
print(d)
return
for dx, dy in ((0, 1), (1, 0), (0, -1), (-1, 0)):
for k in range(1, K + 1):
x2 = x1 + dx * k
y2 = y1 + dy * k
# if m[x2][y2] == '@':
# break
# if x2 < 0 or x2 >= H:
# break
# if y2 < 0 or y2 >= W:
# break
# if M[x2][y2] < d + 1:
# break
# if M[x2][y2] == d + 1:
# continue
if (0 <= x2 < H) and (0 <= y2 < W):
if m[x2][y2] == '@':
break
elif M[x2][y2] == -1:
M[x2][y2] = d + 1
q.append((d + 1, x2, y2))
elif M[x2][y2] <= d:
break
elif M[x2][y2] == d + 1:
continue
else:
break
else:
break
print((-1))
H, W, K = list(map(int, sys.stdin.readline().strip().split()))
xs, ys, xg, yg = list(map(int, sys.stdin.readline().strip().split()))
xg -= 1
yg -= 1
m = []
for _ in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[-1] * W for _ in range(H)]
bfs(xs - 1, ys - 1, 0)
| p02644 |
import sys
from collections import deque
def bfs(x1, y1, d):
q = deque([])
q.append((d, x1, y1))
M[x1][y1] = d
while q:
d, x1, y1 = q.popleft()
if [x1, y1] == [xg, yg]:
print(d)
return
for dx, dy in ((0, 1), (1, 0), (0, -1), (-1, 0)):
for k in range(1, K + 1):
x2 = x1 + dx * k
y2 = y1 + dy * k
if x2 < 0 or x2 >= H: # 枠外
break
if y2 < 0 or y2 >= W: # 枠外
break
if m[x2][y2] == '@': # 蓮の葉
break
if M[x2][y2] < d + 1: # より良い経路を探索済み。
break
if M[x2][y2] == d + 1: # 同等の良さの経路を探索済み。 飛び越えて次のマスを探索する。
continue
q.append((d + 1, x2, y2))
M[x2][y2] = d + 1
print((-1))
H, W, K = list(map(int, sys.stdin.readline().strip().split()))
xs, ys, xg, yg = list(map(int, sys.stdin.readline().strip().split()))
xg -= 1
yg -= 1
m = []
for _ in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[float('inf')] * W for _ in range(H)]
bfs(xs - 1, ys - 1, 0)
| import sys
from collections import deque
def bfs(x1, y1, d):
q = deque([])
q.append((d, x1, y1))
M[x1][y1] = d
while q:
d, x1, y1 = q.popleft()
M[x1][y1] = d
if [x1, y1] == [xg, yg]:
print(d)
return
for dx, dy in ((0, 1), (1, 0), (0, -1), (-1, 0)):
for k in range(1, K + 1):
x2 = x1 + dx * k
y2 = y1 + dy * k
if x2 < 0 or x2 >= H: # 枠外
break
if y2 < 0 or y2 >= W: # 枠外
break
if m[x2][y2] == '@': # 蓮の葉
break
if M[x2][y2] < d + 1: # より良い経路を探索済み。
break
if M[x2][y2] == d + 1: # 同等の良さの経路を探索済み。 飛び越えて次のマスを探索する。
continue
q.append((d + 1, x2, y2))
M[x2][y2] = d + 1
print((-1))
H, W, K = list(map(int, sys.stdin.readline().strip().split()))
xs, ys, xg, yg = list(map(int, sys.stdin.readline().strip().split()))
xg -= 1
yg -= 1
m = []
for _ in range(H):
m.append(list(map(str, sys.stdin.readline().strip())))
M = [[float('inf')] * W for _ in range(H)]
bfs(xs - 1, ys - 1, 0)
| p02644 |
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
from collections import deque
INF = float('inf')
def main():
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
from collections import deque
H, W, K = list(map(int, readline().split()))
x1, y1, x2, y2 = list(map(int, readline().split()))
x1 -= 1;
y1 -= 1;
x2 -= 1;
y2 -= 1
C = read().split()
dist = [[-1] * W for i in range(H)]
dist[x1][y1] = 0
d = deque([[x1, y1]])
dxy = [[1, 0], [0, 1], [-1, 0], [0, -1]]
while d:
x, y = d.popleft()
if (x, y) == (x2, y2):
print((dist[x][y]))
quit()
for dx, dy in dxy:
xx = x;
yy = y
for i in range(K):
xx += dx;
yy += dy
if 0 <= xx < H and 0 <= yy < W and C[xx][yy] != '@':
if 0 <= dist[xx][yy] <= dist[x][y]:
break
if dist[xx][yy] == -1:
d.append([xx, yy])
dist[xx][yy] = dist[x][y] + 1
else:
break
print((-1))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
from collections import deque
INF = float('inf')
def main():
H, W, K = list(map(int, readline().split()))
x1, y1, x2, y2 = list(map(int, readline().split()))
x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1
C = read().split()
dist = [[-1] * W for i in range(H)]
dist[x1][y1] = 0
d = deque([[x1, y1]])
dxy = [[1, 0], [0, 1], [-1, 0], [0, -1]]
while d:
x, y = d.popleft()
if (x, y) == (x2, y2):
print((dist[x][y]))
quit()
for dx, dy in dxy:
xx = x
yy = y
for i in range(K):
xx += dx;
yy += dy
if 0 <= xx < H and 0 <= yy < W and C[xx][yy] != '@':
if 0 <= dist[xx][yy] <= dist[x][y]:
break
if dist[xx][yy] == -1:
d.append([xx, yy])
dist[xx][yy] = dist[x][y] + 1
else:
break
print((-1))
if __name__ == '__main__':
main()
| p02644 |
from functools import lru_cache
from heapq import heappop, heappush
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x)-1 for x in input().split()]
S = [input()[:-1] for _ in [0]*H]
dirs = [(-1, 0), (0, -1), (0, 1), (1, 0)]
@lru_cache(None)
def f(x, y):
return abs(x-x2)+abs(y-y2)
INF = 1<<30
D = [[INF]*W for _ in [0]*H]
q = []
heappush(q, (f(x1, x2), 0, x1, y1))
while q:
h, d, x, y = heappop(q)
if d >= D[x][y]:
continue
D[x][y] = d
for sgn in (1, -1):
for dx in range(1, K+1):
_x = x+dx*sgn
if _x < 0 or _x >= H or S[_x][y] == '@':
break
if d+1 >= D[_x][y]:
continue
heappush(q, (d+f(_x, y), d+1, _x, y))
for dy in range(1, K+1):
_y = y+dy*sgn
if _y < 0 or _y >= W or S[x][_y] == '@':
break
if d+1 >= D[x][_y]:
continue
heappush(q, (d+f(x, _y), d+1, x, _y))
ans = D[x2][y2]
print((-1 if ans == INF else ans)) | from heapq import heappop, heappush
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
x1, y1, x2, y2 = [int(x)-1 for x in input().split()]
S = [input()[:-1] for _ in [0]*H]
def geth(x, y, z):
return (x*W+y)*4+z
def push(x, y, z, d):
h = geth(x, y, z)
if D[h] <= d:
return
D[h] = d
heappush(q, (d, h))
INF = 10**10
MAX = H*W*4
D = [INF]*MAX
dirs = [(-1, 0), (0, -1), (1, 0), (0, 1)]
q = []
for z in range(4):
heappush(q, (0, geth(x1, y1, z)))
while q:
d, h = heappop(q)
z = h % 4
x, y = divmod((h//4), W)
if d > D[h]:
continue
D[h] = d
for _z, (dx, dy) in enumerate(dirs):
if _z == z:
_x, _y = x+dx, y+dy
if 0 <= _x < H and 0 <= _y < W and S[_x][_y] == '.':
push(_x, _y, z, d+1)
else:
_h = geth(x, y, _z)
_d = (d+K-1)//K*K
push(x, y, _z, _d)
g = geth(x2, y2, 0)
ans = min(D[g:g+4])
if ans == INF:
print((-1))
else:
ans = (ans-1+K)//K
print(ans) | p02644 |
import sys
input=sys.stdin.readline
h,w,k=map(int,input().split())
si,sj,ti,tj=map(int,input().split())
si-=1
sj-=1
ti-=1
tj-=1
b=[input()for _ in range(h)]
ans=[[-1]*w for _ in range(h)]
ans[si][sj]=0
from collections import deque
d=deque()
d.append((si,sj))
while d:
x,y=d.popleft()
if x==ti and y==tj:
exit(print(ans[x][y]))
for dx,dy in [[1,0],[-1,0],[0,-1],[0,1]]:
for i in range(1,k+1):
xx=x+dx*i
yy=y+dy*i
if not(0<=xx<h and 0<=yy<w) or b[xx][yy]=="@":break
if 0<=ans[xx][yy]<=ans[x][y]:break
if ans[xx][yy]==-1:d.append((xx,yy))
ans[xx][yy]=ans[x][y]+1
print(-1)
| def main():
import sys
input=sys.stdin.readline
h,w,k=map(int,input().split())
sx,sy,tx,ty=map(int,input().split())
b=[[-1]*(w+2)]
for i in range(h):
s=input()
bb=[-1]
for j in s:
if j==".":bb.append(0)
else:bb.append(-1)
bb.append(-1)
b.append(bb)
b.append([-1]*(w+2))
d=[]
d.append((sx,sy))
for ss in d:
x,y=ss
if x==tx and y==ty:
exit(print(b[x][y]))
for i in range(1,k+1):
if b[x+i][y]<=b[x][y] and b[x+i][y]!=0:break
if b[x+i][y]==0:d.append((x+i,y))
b[x+i][y]=b[x][y]+1
for i in range(1,k+1):
if b[x-i][y]<=b[x][y] and b[x-i][y]!=0:break
if b[x-i][y]==0:d.append((x-i,y))
b[x-i][y]=b[x][y]+1
for j in range(1,k+1):
if b[x][y+j]<=b[x][y] and b[x][y+j]!=0:break
if b[x][y+j]==0:d.append((x,y+j))
b[x][y+j]=b[x][y]+1
for j in range(1,k+1):
if b[x][y-j]<=b[x][y] and b[x][y-j]!=0:break
if b[x][y-j]==0:d.append((x,y-j))
b[x][y-j]=b[x][y]+1
print(-1)
if __name__ == "__main__":
main()
| p02644 |
from queue import Queue
def main():
h, w, k = list(map(int, input().split()))
sx, sy, gx, gy = [int(z) - 1 for z in input().split()]
c = [list(input().replace('\n', '')) for _ in range(h)]
c[sx][sy] = 0
q = Queue()
q.put((sx, sy))
while not q.empty():
x, y = q.get()
d = c[x][y]
# 南へ移動
for i in range(1, k + 1):
if x + i >= h:
break
if c[x + i][y] == '@':
break
elif isinstance(c[x + i][y], int) and c[x + i][y] < d + 1:
break
elif isinstance(c[x + i][y], int) and c[x + i][y] == d + 1:
continue
else:
c[x + i][y] = d + 1
q.put((x + i, y))
# 北へ移動
for i in range(1, k + 1):
if x - i < 0:
break
if c[x - i][y] == '@':
break
elif isinstance(c[x - i][y], int) and c[x - i][y] < d + 1:
break
elif isinstance(c[x - i][y], int) and c[x - i][y] == d + 1:
continue
else:
c[x - i][y] = d + 1
q.put((x - i, y))
# 東へ移動
for i in range(1, k + 1):
if y + i >= w:
break
if c[x][y + i] == '@':
break
elif isinstance(c[x][y + i], int) and c[x][y + i] < d + 1:
break
elif isinstance(c[x][y + i], int) and c[x][y + i] == d + 1:
continue
else:
c[x][y + i] = d + 1
q.put((x, y + i))
# 西へ移動
for i in range(1, k + 1):
if y - i < 0:
break
if c[x][y - i] == '@':
break
elif isinstance(c[x][y - i], int) and c[x][y - i] < d + 1:
break
elif isinstance(c[x][y - i], int) and c[x][y - i] < d + 1:
continue
else:
c[x][y - i] = d + 1
q.put((x, y - i))
print((-1 if c[gx][gy] == '.' else c[gx][gy]))
if __name__ == '__main__':
main()
| from queue import Queue
def main():
h, w, k = list(map(int, input().split()))
sx, sy, gx, gy = [int(z) - 1 for z in input().split()]
c = [list(input().replace('\n', '')) for _ in range(h)]
c[sx][sy] = 0
q = Queue()
q.put((sx, sy))
while not q.empty():
x, y = q.get()
d = c[x][y]
# 南へ移動
for i in range(1, k + 1):
if x + i >= h:
break
if c[x + i][y] == '@':
break
elif isinstance(c[x + i][y], int) and c[x + i][y] < d + 1:
break
elif isinstance(c[x + i][y], int) and c[x + i][y] == d + 1:
continue
else:
c[x + i][y] = d + 1
q.put((x + i, y))
# 北へ移動
for i in range(1, k + 1):
if x - i < 0:
break
if c[x - i][y] == '@':
break
elif isinstance(c[x - i][y], int) and c[x - i][y] < d + 1:
break
elif isinstance(c[x - i][y], int) and c[x - i][y] == d + 1:
continue
else:
c[x - i][y] = d + 1
q.put((x - i, y))
# 東へ移動
for i in range(1, k + 1):
if y + i >= w:
break
if c[x][y + i] == '@':
break
elif isinstance(c[x][y + i], int) and c[x][y + i] < d + 1:
break
elif isinstance(c[x][y + i], int) and c[x][y + i] == d + 1:
continue
else:
c[x][y + i] = d + 1
q.put((x, y + i))
# 西へ移動
for i in range(1, k + 1):
if y - i < 0:
break
if c[x][y - i] == '@':
break
elif isinstance(c[x][y - i], int) and c[x][y - i] < d + 1:
break
elif isinstance(c[x][y - i], int) and c[x][y - i] == d + 1:
continue
else:
c[x][y - i] = d + 1
q.put((x, y - i))
print((-1 if c[gx][gy] == '.' else c[gx][gy]))
if __name__ == '__main__':
main()
| p02644 |
# -*- coding: utf-8 -*-
from collections import Counter, defaultdict, deque
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
@mt
def slv(H, W, K, XY1XY2, C):
q = deque()
s = (XY1XY2[0]-1)*W + XY1XY2[1]-1
go = (XY1XY2[2]-1)*W + XY1XY2[3]-1
q.append(s)
d = {s: 0}
rem = set()
for i in range(H):
for j in range(W):
if C[i][j] == '.':
rem.add(i*W+j)
rem.remove(s)
while q and rem:
u = q.popleft()
i = u // W
j = u % W
e = list()
for k in range(1, K+1):
if i - k >= 0 and C[i-k][j] != '@':
n = (i-k)*W + j
if n not in d:
e.append(n)
else:
break
for k in range(1, K+1):
if i + k < H and C[i+k][j] != '@':
n = (i+k)*W + j
if n not in d:
e.append(n)
else:
break
for k in range(1, K+1):
if j - k >= 0 and C[i][j-k] != '@':
n = i*W + j-k
if n not in d:
e.append(n)
else:
break
for k in range(1, K+1):
if j + k < W and C[i][j+k] != '@':
n = i*W + j+k
if n not in d:
e.append(n)
else:
break
for v in e:
q.append(v)
d[v] = d[u] + 1
rem.remove(v)
if v == go:
return d[v]
return -1
def main():
H, W, K = read_int_n()
XY1XY2 = read_int_n()
C = [read_str() for _ in range(H)]
print(slv(H, W, K, XY1XY2, C))
# H = 1000
# W = 1000
# K = 1000
# XY1XY2 = [1, 1, H, W]
# C = [['.'] * W] * H
# C[H-2][W-1] = '@'
# C[H-1][W-2] = '@'
# print(slv(H, W, K, XY1XY2, C))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
from collections import Counter, defaultdict, deque
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
@mt
def slv(H, W, K, XY1XY2, C):
q = deque()
s = (XY1XY2[0]-1)*W + XY1XY2[1]-1
go = (XY1XY2[2]-1)*W + XY1XY2[3]-1
q.append(s)
d = {s: 0}
while q:
u = q.popleft()
i = u // W
j = u % W
e = list()
for k in range(1, K+1):
if i - k >= 0 and C[i-k][j] != '@':
n = (i-k)*W + j
if n not in d:
e.append(n)
elif d[u] +1 > d[n]:
break
else:
break
for k in range(1, K+1):
if i + k < H and C[i+k][j] != '@':
n = (i+k)*W + j
if n not in d:
e.append(n)
elif d[u] + 1 > d[n]:
break
else:
break
for k in range(1, K+1):
if j - k >= 0 and C[i][j-k] != '@':
n = i*W + j-k
if n not in d:
e.append(n)
elif d[u] + 1 > d[n]:
break
else:
break
for k in range(1, K+1):
if j + k < W and C[i][j+k] != '@':
n = i*W + j+k
if n not in d:
e.append(n)
elif d[u] + 1 > d[n]:
break
else:
break
for v in e:
q.append(v)
d[v] = d[u] + 1
if v == go:
return d[v]
return -1
def main():
H, W, K = read_int_n()
XY1XY2 = read_int_n()
C = [read_str() for _ in range(H)]
print(slv(H, W, K, XY1XY2, C))
# H = 1000
# W = 1000
# K = 1000
# XY1XY2 = [1, 1, H, W]
# C = [['.'] * W for _ in range(H)]
# for i in range(1, H, 2):
# if ((i + 1) // 2) % 2 == 1:
# for j in range(W-1):
# C[i][j] = '@'
# else:
# for j in range(1, W):
# C[i][j] = '@'
# # for r in C:
# # print(r)
# print(slv(H, W, K, XY1XY2, C))
if __name__ == '__main__':
main()
| p02644 |
from collections import deque
import sys
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 MI1(): return map(int1, 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]
def main():
inf=10**9
h,w,k=MI()
x1,y1,x2,y2=MI1()
aa=[[0 if c=="@" else inf for c in SI()] for _ in range(h)]
#p2D(aa)
aa[x1][y1]=0
q=deque()
q.append((x1,y1,0))
while q:
x,y,d=q.popleft()
for nx in range(x+1,min(x+k+1,h)):
if aa[nx][y]<d+1:break
aa[nx][y]=d+1
q.append((nx,y,d+1))
for nx in range(x-1,max(x-k-1,-1),-1):
if aa[nx][y]<d+1:break
aa[nx][y]=d+1
q.append((nx,y,d+1))
for ny in range(y+1,min(y+k+1,w)):
if aa[x][ny]<d+1:break
aa[x][ny]=d+1
q.append((x,ny,d+1))
for ny in range(y-1,max(y-k-1,-1),-1):
if aa[x][ny]<d+1:break
aa[x][ny]=d+1
q.append((x,ny,d+1))
#p2D(aa)
#print()
ans=aa[x2][y2]
if ans==inf:print(-1)
else:print(ans)
main()
| from collections import deque
import sys
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 MI1(): return map(int1, 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]
def main():
inf=10**9
h,w,k=MI()
x1,y1,x2,y2=MI1()
aa=[[0 if c=="@" else inf for c in SI()] for _ in range(h)]
#p2D(aa)
aa[x1][y1]=0
q=deque()
q.append((x1,y1,0))
while q:
x,y,d=q.popleft()
for nx in range(x+1,min(x+k+1,h)):
if aa[nx][y] == d + 1:continue
if aa[nx][y]<d+1:break
aa[nx][y]=d+1
q.append((nx,y,d+1))
for nx in range(x-1,max(x-k-1,-1),-1):
if aa[nx][y] == d + 1:continue
if aa[nx][y]<d+1:break
aa[nx][y]=d+1
q.append((nx,y,d+1))
for ny in range(y+1,min(y+k+1,w)):
if aa[x][ny] == d + 1:continue
if aa[x][ny]<d+1:break
aa[x][ny]=d+1
q.append((x,ny,d+1))
for ny in range(y-1,max(y-k-1,-1),-1):
if aa[x][ny] == d + 1:continue
if aa[x][ny]<d+1:break
aa[x][ny]=d+1
q.append((x,ny,d+1))
#p2D(aa)
#print()
ans=aa[x2][y2]
if ans==inf:print(-1)
else:print(ans)
main()
| p02644 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
mxy = [(0, 1), (1, 0), (-1, 0), (0, -1)]
h, w, K = LI()
y1, x1, y2, x2 = LI()
c = SR(h)
q = deque()
field = [[False] * (w + 2)] + [None] * h + [[False] * (w + 2)]
for i in range(1,h+1):
field[i] = [False] + [True] * w + [False]
for i in range(1, h + 1):
for j in range(1, w + 1):
if c[i-1][j-1] == "@":
field[i][j] = False
q.append((x1, y1))
ans = 0
while q:
next_q = deque()
while q:
x, y = q.popleft()
if (x, y) == (x2, y2):
print(ans)
return
if field[y][x]:
for i in range(1, K + 1):
if field[y + i][x]:
next_q.append((x, y + i))
else:
break
for i in range(1, K + 1):
if field[y][x + i]:
next_q.append((x + i, y))
else:
break
for i in range(1, K + 1):
if field[y - i][x]:
next_q.append((x, y - i))
else:
break
for i in range(1, K + 1):
if field[y][x - i]:
next_q.append((x - i, y))
else:
break
field[y][x] = False
ans += 1
q = next_q
print((-1))
return
#main
if __name__ == '__main__':
solve()
| #!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
mxy = [(0, 1), (1, 0), (-1, 0), (0, -1)]
h, w, K = LI()
y1, x1, y2, x2 = LI()
c = SR(h)
q = deque()
field = [[False] * (w + 2)] + [None] * h + [[False] * (w + 2)]
for i in range(1,h+1):
field[i] = [False] + [True] * w + [False]
for i in range(1, h + 1):
for j in range(1, w + 1):
if c[i-1][j-1] == "@":
field[i][j] = False
q.append((x1, y1))
ans = 0
c = defaultdict(int)
while q:
next_q = deque()
while q:
x, y = q.popleft()
if (x, y) == (x2, y2):
print(ans)
return
if field[y][x]:
for i in range(1, K + 1):
if field[y + i][x]:
if not c[(y + i, x)]:
next_q.append((x, y + i))
c[(y + i, x)] = 1
else:
break
for i in range(1, K + 1):
if field[y][x + i]:
if not c[(y, x + i)]:
next_q.append((x + i, y))
c[(y, x + i)] = 1
else:
break
for i in range(1, K + 1):
if field[y - i][x]:
if not c[(y - i, x)]:
next_q.append((x, y - i))
c[(y - i, x)] = 1
else:
break
for i in range(1, K + 1):
if field[y][x - i]:
if not c[(y, x - i)]:
next_q.append((x - i, y))
c[(y, x - i)] = 1
else:
break
field[y][x] = False
ans += 1
q = next_q
print((-1))
return
#main
if __name__ == '__main__':
solve()
| p02644 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
mxy = [(0, 1), (1, 0), (-1, 0), (0, -1)]
h, w, K = LI()
y1, x1, y2, x2 = LI()
q = deque()
field = [[False] * (w + 2)] + [None] * h + [[False] * (w + 2)]
for i in range(1, h + 1):
field[i] = [False] + [True] * w + [False]
for i in range(1, h + 1):
s = input().rstrip()
for j in range(1, w + 1):
if s[j-1] == "@":
field[i][j] = False
q.append((x1, y1))
ans = 0
c = defaultdict(int)
while q:
next_q = deque()
while q:
x, y = q.pop()
if (x, y) == (x2, y2):
print(ans)
return
if field[y][x]:
for i in range(1, K + 1):
if field[y + i][x]:
if not c[(y + i, x)]:
next_q.append((x, y + i))
c[(y + i, x)] = 1
else:
break
for i in range(1, K + 1):
if field[y][x + i]:
if not c[(y, x + i)]:
next_q.append((x + i, y))
c[(y, x + i)] = 1
else:
break
for i in range(1, K + 1):
if field[y - i][x]:
if not c[(y - i, x)]:
next_q.append((x, y - i))
c[(y - i, x)] = 1
else:
break
for i in range(1, K + 1):
if field[y][x - i]:
if not c[(y, x - i)]:
next_q.append((x - i, y))
c[(y, x - i)] = 1
else:
break
field[y][x] = False
ans += 1
q = next_q
print((-1))
return
#main
if __name__ == '__main__':
solve()
| #!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
mxy = [(0, 1), (1, 0), (-1, 0), (0, -1)]
h, w, K = LI()
y1, x1, y2, x2 = LI()
q = deque()
field = [[False] * (w + 2)] + [None] * h + [[False] * (w + 2)]
for i in range(1, h + 1):
field[i] = [False] + [True] * w + [False]
for i in range(1, h + 1):
s = input().rstrip()
for j in range(1, w + 1):
if s[j-1] == "@":
field[i][j] = False
q.append((x1, y1))
ans = 0
c = [[0] * (w + 2) for i in range(h + 2)]
while q:
next_q = deque()
while q:
x, y = q.pop()
if (x, y) == (x2, y2):
print(ans)
return
if field[y][x]:
for i in range(1, K + 1):
if field[y + i][x]:
if not c[y + i][x]:
next_q.append((x, y + i))
c[y + i][x] = 1
else:
break
for i in range(1, K + 1):
if field[y][x + i]:
if not c[y][x + i]:
next_q.append((x + i, y))
c[y][x + i] = 1
else:
break
for i in range(1, K + 1):
if field[y - i][x]:
if not c[y - i][x]:
next_q.append((x, y - i))
c[y - i][x] = 1
else:
break
for i in range(1, K + 1):
if field[y][x - i]:
if not c[y][x - i]:
next_q.append((x - i, y))
c[y][x - i] = 1
else:
break
field[y][x] = False
ans += 1
q = next_q
print((-1))
return
#main
if __name__ == '__main__':
solve()
| p02644 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h,w,k=MI()
x1,y1,x2,y2=MI()
G=["@"]*(w+2)
for _ in range(h):
G.append("@")
G+=(list(map(str,input().rstrip())))
G.append("@")
G+=["@"]*(w+2)
#print(G)
G[x1*(w+2)+y1]=0
#print(G)
Q=deque()
Q.append((x1*(w+2)+y1,0))
while Q:
#print(Q)
now,d=Q.popleft()
#print(Q)
for i in range(1,k+1):
if G[now+i]==d or G[now+i]=="@":
break
elif G[now+i]==".":
G[now+i]=d+1
Q.append([now+i,d+1])
elif G[now+i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now-i]==d or G[now-i]=="@":
break
elif G[now-i]==".":
G[now-i]=d+1
Q.append([now-i,d+1])
elif G[now-i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now+(w+2)*i]==d or G[now+(w+2)*i]=="@":
break
elif G[now+(w+2)*i]==".":
G[now+(w+2)*i]=d+1
Q.append([now+(w+2)*i,d+1])
elif G[now+(w+2)*i]==d+1:
continue
else:
break
for i in range(1,k+1):
if G[now-(w+2)*i]==d or G[now-(w+2)*i]=="@":
break
elif G[now-(w+2)*i]==".":
G[now-(w+2)*i]=d+1
Q.append([now-(w+2)*i,d+1])
elif G[now-(w+2)*i]==d+1:
continue
else:
break
#print(Q)
#print(G)
if G[x2*(w+2)+y2]==".":
print((-1))
else:
print((G[x2*(w+2)+y2]))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
from collections import deque
def main():
h,w,k=MI()
x1,y1,x2,y2=MI()
G=["@"]*(w+2)
for _ in range(h):
G.append("@")
G+=(list(map(str,input().rstrip())))
G.append("@")
G+=["@"]*(w+2)
#print(G)
G[x1*(w+2)+y1]=0
#print(G)
Q=deque()
Q.append((x1*(w+2)+y1,0))
while Q:
#print(Q)
now,d=Q.popleft()
#print(Q)
for m in [1,-1,w+2,-w-2]:
for i in range(1,k+1):
if G[now+m*i]==d or G[now+m*i]=="@":
break
elif G[now+m*i]==".":
G[now+m*i]=d+1
Q.append([now+m*i,d+1])
elif G[now+m*i]==d+1:
continue
else:
break
#print(Q)
#print(G)
if G[x2*(w+2)+y2]==".":
print((-1))
else:
print((G[x2*(w+2)+y2]))
if __name__ == "__main__":
main()
| p02644 |
import sys
from collections import deque
input = iter(sys.stdin.readlines()).__next__
R, C, K = [int(x) for x in input().split()]
X1, Y1, X2, Y2 = [int(x) - 1 for x in input().split()] # 0 indexed
grid = [input().rstrip() for r in range(R)]
source = (X1, Y1)
q = deque([source])
dist = {source: 0}
def getNbr(node):
r, c = node
ret = []
for dr, dc in [(0, 0), (-1, 0), (0, -1), (0, 1), (1, 0)]:
for k in range(1, K + 1):
nr = r + dr * k
nc = c + dc * k
if not (0 <= nr < R and 0 <= nc < C):
break
if grid[nr][nc] == "@":
break
ret.append((nr, nc))
return ret
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node):
if nbr not in dist:
q.append(nbr)
dist[nbr] = d + 1
if False:
for row in grid:
print(row)
print()
for r in range(R):
for c in range(C):
print(dist.get((r, c), "?"), end=" ")
print()
if (X2, Y2) in dist:
print(dist[(X2, Y2)])
else:
print(-1)
| import sys
from collections import deque
input = iter(sys.stdin.readlines()).__next__
R, C, K = [int(x) for x in input().split()]
X1, Y1, X2, Y2 = [int(x) - 1 for x in input().split()] # 0 indexed
grid = [input().rstrip() for r in range(R)]
source = (X1, Y1)
q = deque([source])
dist = {source: 0}
def getNbr(node, currDist):
r, c = node
ret = []
for dr, dc in [(0, 0), (-1, 0), (0, -1), (0, 1), (1, 0)]:
for k in range(1, K + 1):
nr = r + dr * k
nc = c + dc * k
if not (0 <= nr < R and 0 <= nc < C):
break
if grid[nr][nc] == "@" or ((nr, nc) in dist and dist[(nr, nc)] <= d):
break
ret.append((nr, nc))
return ret
while q:
node = q.popleft()
d = dist[node]
for nbr in getNbr(node, d):
if nbr not in dist:
q.append(nbr)
dist[nbr] = d + 1
if False:
for row in grid:
print(row)
print()
for r in range(R):
for c in range(C):
print(dist.get((r, c), "?"), end=" ")
print()
if (X2, Y2) in dist:
print(dist[(X2, Y2)])
else:
print(-1)
| p02644 |
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AtoZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b:
a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n -1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n:
return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
H,W,K = IL()
y1,x1,y2,x2 = IL()
data = SLs(H)
d = [[INF for i in range(W)] for j in range(H)]
flag = [[0 for i in range(W)] for j in range(H)]
dd = [i+1 for i in range(K)]
d[y1-1][x1-1] = 0
q = deque([(y1-1,x1-1)])
while q:
y,x = q.popleft()
for i in range(K):
ny,nx = y+dd[i],x
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] >= d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
else:
break
else:
break
for i in range(K):
ny,nx = y-dd[i],x
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] >= d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
else:
break
else:
break
for i in range(K):
ny,nx = y,x+dd[i]
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] >= d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
else:
break
else:
break
for i in range(K):
ny,nx = y,x-dd[i]
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] >= d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
else:
break
else:
break
if d[y2-1][x2-1]!=INF:
print((d[y2-1][x2-1]))
else:
print((-1))
| # -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AtoZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(eval(input())) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n):
return kaijo_memo[n]
if(len(kaijo_memo) == 0):
kaijo_memo.append(1)
while(len(kaijo_memo) <= n):
kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n):
return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0):
gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n):
gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if(n == r):
return 1
if(n < r or r < 0):
return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b:
a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n -1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n:
return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
H,W,K = IL()
y1,x1,y2,x2 = IL()
data = SLs(H)
for i in range(H):
data[i] = list(data[i])
d = [[INF for i in range(W)] for j in range(H)]
flag = [[0 for i in range(W)] for j in range(H)]
dd = [i+1 for i in range(K)]
d[y1-1][x1-1] = 0
q = deque([(y1-1,x1-1)])
now = 0
temp = []
while q:
y,x = q.popleft()
if now < d[y][x]:
for w,z in temp:
data[w][z] = "@"
now = d[y][x]
temp = []
for i in range(K):
ny,nx = y+dd[i],x
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] > d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
temp.append((ny,nx))
else:
break
for i in range(K):
ny,nx = y-dd[i],x
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] > d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
temp.append((ny,nx))
else:
break
for i in range(K):
ny,nx = y,x+dd[i]
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] > d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
temp.append((ny,nx))
else:
break
for i in range(K):
ny,nx = y,x-dd[i]
if 0<=ny<H and 0<=nx<W:
if data[ny][nx] == ".":
if d[ny][nx] > d[y][x]+1:
d[ny][nx] = d[y][x]+1
q.append((ny,nx))
temp.append((ny,nx))
else:
break
if d[y2-1][x2-1]!=INF:
print((d[y2-1][x2-1]))
else:
print((-1))
| p02644 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
sx -= 1
sy -= 1
gx -= 1
gy -= 1
grid = SRL(h)
def solve():
grid[sy][sx] = 0
que = deque([(sy, sx)])
while que:
cy, cx = que.popleft()
for i, j in ((1, 0), (-1, 0), (0, 1), (0, -1)):
for l in range(1, k + 1):
ny = cy + i * l
nx = cx + j * l
if 0 <= ny < h and 0 <= nx < w:
if grid[ny][nx] == "@":
break
elif grid[ny][nx] == '.' or grid[cy][cx] + 1 <= grid[ny][nx]:
grid[ny][nx] = grid[cy][cx] + 1
que += [(ny, nx)]
else:
break
else:
break
return grid[gy][gx]
ans = solve()
if ans == ".":
print((-1))
else:
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
cost = [[INF] * w for _ in range(h)]
cost[sy - 1][sx - 1] = 0
grid = SR(h)
q = deque([(sy - 1, sx - 1)])
while q:
cy, cx = q.popleft()
for i, j in ((1, 0), (0, 1), (-1, 0), (0, -1)):
for l in range(1, k + 1):
ny, nx = cy + i * l, cx + j * l
if 0 > nx or nx >= w or 0 > ny or ny >= h or grid[ny][nx] == "@":
break
if 0 <= cost[ny][nx] <= cost[cy][cx]:
break
if cost[ny][nx] == INF:
q.append((ny, nx))
cost[ny][nx] = cost[cy][cx] + 1
print((cost[gy - 1][gx - 1] if cost[gy - 1][gx - 1] != INF else -1))
| p02644 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
cost = [[INF] * w for _ in range(h)]
cost[sy - 1][sx - 1] = 0
grid = SR(h)
q = deque([(sy - 1, sx - 1)])
while q:
cy, cx = q.popleft()
for i, j in ((1, 0), (0, 1), (-1, 0), (0, -1)):
for l in range(1, k + 1):
ny, nx = cy + i * l, cx + j * l
if 0 > nx or nx >= w or 0 > ny or ny >= h or grid[ny][nx] == "@":
break
if 0 <= cost[ny][nx] <= cost[cy][cx]:
break
if cost[ny][nx] == INF:
q.append((ny, nx))
cost[ny][nx] = cost[cy][cx] + 1
print((cost[gy - 1][gx - 1] if cost[gy - 1][gx - 1] != INF else -1))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
cost = [[INF] * w for _ in range(h)]
cost[sy - 1][sx - 1] = 0
grid = SR(h)
q = deque([(sy - 1, sx - 1)])
while q:
cy, cx = q.popleft()
for i, j in ((1, 0), (0, 1), (-1, 0), (0, -1)):
for l in range(1, k + 1):
ny, nx = cy + i * l, cx + j * l
if 0 <= nx < w and 0 <= ny < h and grid[ny][nx] == "." and cost[ny][nx] >= cost[cy][cx] + 1:
if cost[ny][nx] == INF:
q.append((ny, nx))
cost[ny][nx] = cost[cy][cx] + 1
else:
break
print((cost[gy - 1][gx - 1] if cost[gy - 1][gx - 1] != INF else -1))
| p02644 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
cost = [[INF] * w for _ in range(h)]
cost[sy - 1][sx - 1] = 0
grid = SR(h)
q = deque([(sy - 1, sx - 1)])
while q:
cy, cx = q.popleft()
for i, j in ((1, 0), (0, 1), (-1, 0), (0, -1)):
for l in range(1, k + 1):
ny, nx = cy + i * l, cx + j * l
if 0 <= nx < w and 0 <= ny < h and grid[ny][nx] == "." and cost[ny][nx] >= cost[cy][cx] + 1:
if cost[ny][nx] == INF:
q.append((ny, nx))
cost[ny][nx] = cost[cy][cx] + 1
else:
break
print((cost[gy - 1][gx - 1] if cost[gy - 1][gx - 1] != INF else -1))
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gcd
from operator import mul
from functools import reduce
from operator import mul
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
h, w, k = LI()
sy, sx, gy, gx = LI()
cost = [[INF] * w for _ in range(h)]
cost[sy - 1][sx - 1] = 0
grid = SR(h)
q = deque([(sy - 1, sx - 1)])
while q:
cy, cx = q.popleft()
for i, j in ((1, 0), (0, 1), (-1, 0), (0, -1)):
for l in range(1, k + 1):
ny, nx = cy + i * l, cx + j * l
if 0 <= nx < w and 0 <= ny < h and grid[ny][nx] == "." and cost[ny][nx] >= cost[cy][cx] + 1:
if cost[ny][nx] == INF:
q.append((ny, nx))
cost[ny][nx] = cost[cy][cx] + 1
else:
break
print((cost[gy - 1][gx - 1] if cost[gy - 1][gx - 1] != INF else -1))
| p02644 |
#関数リスト
import sys
input = sys.stdin.readline
from collections import defaultdict, deque
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
h, w, k = MI()
x1, y1, x2, y2 = MI()
x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1
mylist = dict()
#tableの読み込み
for i in range(h):
temp = input().rstrip()
temp2 = dict()
for j in range(w):
temp2[j] = temp[j]
mylist[i] = temp
#初期化
distance = [[float('inf') for i in range(w)] for j in range(h)]
distance[x1][y1] = 0
d = deque()
start = (x1, y1)
goal = [x2, y2]
d.append(start)
move = ([-1,0],[1,0],[0,1],[0,-1])
while d:
pos = d.pop()
x = pos[0]
y = pos[1]
dist = distance[x][y]
for i in move:
#tempxの初期化
tempx = x
tempy = y
for l in range(k):
tempx += i[0]
tempy += i[1]
if not ((tempx >= 0 and tempx <= h-1) and (tempy >= 0 and tempy <= w - 1)):
break
if dist + 1 < distance[tempx][tempy] and mylist[tempx][tempy] == ".":
distance[tempx][tempy] = dist + 1
d.append((tempx, tempy))
else:
break
if distance[x2][y2] == float('inf'):
print((-1))
else:
print((distance[x2][y2]))
main() | #関数リスト
import sys
input = sys.stdin.readline
from collections import defaultdict, deque
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
h, w, k = MI()
x1, y1, x2, y2 = MI()
x1 -= 1
y1 -= 1
x2 -= 1
y2 -= 1
mylist = [0] * h
#tableの読み込み
for i in range(h):
temp = input().rstrip()
temp = [temp[j] for j in range(w)]
mylist[i] = temp
#初期化
distance = [[-1 for i in range(w)] for j in range(h)]
distance[x1][y1] = 0
d = deque()
start = (x1, y1)
goal = [x2, y2]
d.append(start)
move = ([-1,0],[1,0],[0,1],[0,-1])
while d:
pos = d.popleft()
x = pos[0]
y = pos[1]
if x == x2 and y == y2:
print((distance[x2][y2]))
exit()
dist = distance[x][y]
for i in move:
#tempxの初期化
tempx = x
tempy = y
for l in range(k):
tempx += i[0]
tempy += i[1]
if not ((tempx >= 0 and tempx <= h-1) and (tempy >= 0 and tempy <= w - 1)):
break
elif mylist[tempx][tempy] == "." and distance[tempx][tempy] == -1:
distance[tempx][tempy] = dist + 1
d.append((tempx, tempy))
elif dist + 1 <= distance[tempx][tempy] and mylist[tempx][tempy] == ".":
distance[tempx][tempy] = dist + 1
else:
break
print((-1))
main()
| p02644 |
def examA():
X = LI()
for i in range(len(X)):
if X[i]==0:
ans = i+1
print(ans)
return
def examB():
X, Y = LI()
ans = "No"
for i in range(X+1):
if i*2+(X-i)*4==Y:
ans = "Yes"
print(ans)
return
def examC():
X, N = LI()
P = LI()
P = set(P)
cur = inf
ans = -1
for i in range(-1,102):
if i in P:
continue
now = abs(i-X)
if now<cur:
ans = i
cur = now
print(ans)
return
def examD():
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
N = I()
A = LI()
C = set()
n = 10**6+1
D = [False]*n
ans = 0
for a in A:
if a in D:
D[a] = False
continue
D[a] = True
C.add(a)
for a in C:
for i in range(2,1+n//a):
D[i*a] = False
ans = sum(D)
print(ans)
return
def examE():
N, Q = LI()
AB = [LI()for _ in range(N)]
ans = 0
print(ans)
return
def examF():
H, W, K = LI()
x1,y1,x2,y2 = LI()
x1 -= 1; y1 -= 1; x2 -= 1; y2 -= 1
C = [SI()for _ in range(H)]
def bfs_grid(h, w, s, maze):
distance = [[inf] * w for _ in range(h)]
def bfsg():
queue = deque()
queue.append(s)
distance[s[0]][s[1]] = 0
while len(queue):
y, x = queue.popleft()
for i in range(4):
for k in range(1,K+1):
nx, ny = x + k*[1, 0, -1, 0][i], y + k*[0, 1, 0, -1][i]
if (0 <= nx < w and 0 <= ny < h and maze[ny][nx] != '@'):
if distance[ny][nx] <= distance[y][x] + 1:
continue
queue.append((ny, nx))
distance[ny][nx] = distance[y][x] + 1
else:
break
return distance
return bfsg()
L = bfs_grid(H,W,(x1,y1),C)
#print(L)
ans = L[x2][y2]
if ans==inf:
ans = -1
print(ans)
return
from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examF()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | def examA():
X = LI()
for i in range(len(X)):
if X[i]==0:
ans = i+1
print(ans)
return
def examB():
X, Y = LI()
ans = "No"
for i in range(X+1):
if i*2+(X-i)*4==Y:
ans = "Yes"
print(ans)
return
def examC():
X, N = LI()
P = LI()
P = set(P)
cur = inf
ans = -1
for i in range(-1,102):
if i in P:
continue
now = abs(i-X)
if now<cur:
ans = i
cur = now
print(ans)
return
def examD():
def make_divisors(n):
divisors = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
# divisors.sort()
return divisors
N = I()
A = LI()
C = set()
n = 10**6+1
D = [False]*n
ans = 0
for a in A:
if a in D:
D[a] = False
continue
D[a] = True
C.add(a)
for a in C:
for i in range(2,1+n//a):
D[i*a] = False
ans = sum(D)
print(ans)
return
def examE():
N, Q = LI()
AB = [LI()for _ in range(N)]
ans = 0
print(ans)
return
def examF():
H, W, K = LI()
x1,y1,x2,y2 = LI()
x1 -= 1; y1 -= 1; x2 -= 1; y2 -= 1
C = [SI()for _ in range(H)]
def bfs_grid(h, w, s, maze):
distance = [[inf] * w for _ in range(h)]
def bfsg():
queue_up = deque()
queue_d = deque()
queue_r = deque()
queue_l = deque()
queue_up.append(s)
queue_d.append(s)
queue_r.append(s)
queue_l.append(s)
distance[s[0]][s[1]] = 0
while (len(queue_up) or len(queue_r) or len(queue_d) or len(queue_l)):
if queue_up:
y, x = queue_up.popleft()
for k in range(1, K + 1):
nx, ny = x, y + k
if (0 <= nx < w and 0 <= ny < h and maze[ny][nx] != '@'):
if distance[ny][nx] <= distance[y][x] + 1:
continue
queue_r.append((ny, nx))
queue_l.append((ny, nx))
distance[ny][nx] = distance[y][x] + 1
else:
break
if k == K:
queue_up.append((ny, nx))
if queue_d:
y, x = queue_d.popleft()
for k in range(1, K + 1):
nx, ny = x, y - k
if (0 <= nx < w and 0 <= ny < h and maze[ny][nx] != '@'):
if distance[ny][nx] <= distance[y][x] + 1:
continue
queue_r.append((ny, nx))
queue_l.append((ny, nx))
distance[ny][nx] = distance[y][x] + 1
else:
break
if k == K:
queue_d.append((ny, nx))
if queue_r:
y, x = queue_r.popleft()
for k in range(1, K + 1):
nx, ny = x + k, y
if (0 <= nx < w and 0 <= ny < h and maze[ny][nx] != '@'):
if distance[ny][nx] <= distance[y][x] + 1:
continue
queue_up.append((ny, nx))
queue_d.append((ny, nx))
distance[ny][nx] = distance[y][x] + 1
else:
break
if k == K:
queue_r.append((ny, nx))
if queue_l:
y, x = queue_l.popleft()
for k in range(1, K + 1):
nx, ny = x - k, y
if (0 <= nx < w and 0 <= ny < h and maze[ny][nx] != '@'):
if distance[ny][nx] <= distance[y][x] + 1:
continue
queue_up.append((ny, nx))
queue_d.append((ny, nx))
distance[ny][nx] = distance[y][x] + 1
else:
break
if k == K:
queue_l.append((ny, nx))
return distance
return bfsg()
L = bfs_grid(H,W,(x1,y1),C)
#print(L)
ans = L[x2][y2]
if ans==inf:
ans = -1
print(ans)
return
from decimal import Decimal as dec
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(eval(input()))
def LI(): return list(map(int,sys.stdin.readline().split()))
def DI(): return dec(eval(input()))
def LDI(): return list(map(dec,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examF()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
""" | p02644 |
import sys
input = sys.stdin.readline
from collections import deque
H,W,K=list(map(int,input().split()))
x1,y1,x2,y2=list(map(int,input().split()))
MAP2=[list(input().strip()) for i in range(H)]
MAP=[-1]*(H*W)
for i in range(H):
for j in range(W):
if MAP2[i][j]==".":
MAP[i*W+j]=1<<25
def ch(x,y,tf):
return (x*W+y)*4+tf
def back(x):
tf=x%4
x//=4
return x//W,x%W,tf
Q=deque()
Q.append(ch(x1-1,y1-1,0))
Q.append(ch(x1-1,y1-1,1))
Q.append(ch(x1-1,y1-1,2))
Q.append(ch(x1-1,y1-1,3))
MAP[(x1-1)*W+y1-1]=0
while Q:
x,y,tf=back(Q.popleft())
if tf==0:
if 0<=x+1<H and MAP[(x+1)*W+y]>MAP[x*W+y]:
for i in range(1,K):
if 0<=x+i<H and MAP[(x+i)*W+y]>MAP[x*W+y]:
MAP[(x+i)*W+y]=MAP[x*W+y]+1
Q.append(ch(x+i,y,2))
Q.append(ch(x+i,y,3))
else:
break
else:
if 0<=x+K<H and MAP[(x+K)*W+y]>MAP[x*W+y]:
MAP[(x+K)*W+y]=MAP[x*W+y]+1
Q.append(ch(x+K,y,0))
Q.append(ch(x+K,y,2))
Q.append(ch(x+K,y,3))
elif tf==1:
if 0<=x-1<H and MAP[(x-1)*W+y]>MAP[x*W+y]:
for i in range(1,K):
if 0<=x-i<H and MAP[(x-i)*W+y]>MAP[x*W+y]:
MAP[(x-i)*W+y]=MAP[x*W+y]+1
Q.append(ch(x-i,y,2))
Q.append(ch(x-i,y,3))
else:
break
else:
if 0<=x-K<H and MAP[(x-K)*W+y]>MAP[x*W+y]:
MAP[(x-K)*W+y]=MAP[x*W+y]+1
Q.append(ch(x-K,y,1))
Q.append(ch(x-K,y,2))
Q.append(ch(x-K,y,3))
elif tf==2:
if 0<=y+1<W and MAP[x*W+y+1]>MAP[x*W+y]:
for i in range(1,K):
if 0<=y+i<W and MAP[x*W+y+i]>MAP[x*W+y]:
MAP[x*W+y+i]=MAP[x*W+y]+1
Q.append(ch(x,y+i,0))
Q.append(ch(x,y+i,1))
else:
break
else:
if 0<=y+K<W and MAP[x*W+y+K]>MAP[x*W+y]:
MAP[x*W+y+K]=MAP[x*W+y]+1
Q.append(ch(x,y+K,0))
Q.append(ch(x,y+K,1))
Q.append(ch(x,y+K,2))
else:
if 0<=y-1<W and MAP[x*W+y-1]>MAP[x*W+y]:
for i in range(1,K):
if 0<=y-i<W and MAP[x*W+y-i]>MAP[x*W+y]:
MAP[x*W+y-i]=MAP[x*W+y]+1
Q.append(ch(x,y-i,0))
Q.append(ch(x,y-i,1))
else:
break
else:
if 0<=y-K<W and MAP[x*W+y-K]>MAP[x*W+y]:
MAP[x*W+y-K]=MAP[x*W+y]+1
Q.append(ch(x,y-K,0))
Q.append(ch(x,y-K,1))
Q.append(ch(x,y-K,3))
if MAP[(x2-1)*W+y2-1]==1<<25:
print((-1))
else:
print((MAP[(x2-1)*W+y2-1]))
| import sys
input = sys.stdin.readline
from collections import deque
H,W,K=list(map(int,input().split()))
x1,y1,x2,y2=list(map(int,input().split()))
MAP=[list(input().strip()) for i in range(H)]
for i in range(H):
for j in range(W):
if MAP[i][j]==".":
MAP[i][j]=1<<30
else:
MAP[i][j]=-1
Q=deque()
Q.append((x1-1,y1-1))
MAP[x1-1][y1-1]=0
while Q:
x,y=Q.pop()
for i in range(1,K+1):
if 0<=x+i<H and 0<=y<W and (MAP[x+i][y]==1<<30 or MAP[x+i][y]>MAP[x][y]):
if MAP[x+i][y]==1<<30:
MAP[x+i][y]=MAP[x][y]+1
Q.appendleft((x+i,y))
else:
break
for i in range(1,K+1):
if 0<=x-i<H and 0<=y<W and (MAP[x-i][y]==1<<30 or MAP[x-i][y]>MAP[x][y]):
if MAP[x-i][y]==1<<30:
MAP[x-i][y]=MAP[x][y]+1
Q.appendleft((x-i,y))
else:
break
for i in range(1,K+1):
if 0<=x<H and 0<=y+i<W and (MAP[x][y+i]==1<<30 or MAP[x][y+i]>MAP[x][y]):
if MAP[x][y+i]==1<<30:
MAP[x][y+i]=MAP[x][y]+1
Q.appendleft((x,y+i))
else:
break
for i in range(1,K+1):
if 0<=x<H and 0<=y-i<W and (MAP[x][y-i]==1<<30 or MAP[x][y-i]>MAP[x][y]):
if MAP[x][y-i]==1<<30:
MAP[x][y-i]=MAP[x][y]+1
Q.appendleft((x,y-i))
else:
break
if MAP[x2-1][y2-1]==1<<30:
print((-1))
else:
print((MAP[x2-1][y2-1]))
| p02644 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
H,W,K = LI()
x1,y1,x2,y2 = _LI()
p = [SI() for _ in range(H)]
d = [[INF] * W for _ in range(H)]
for i in range(4):
d[x1][y1] = 0
q = collections.deque()
q.append((x1,y1))
while q:
x,y = q.pop()
for dx,dy in DD:
for n in range(1,K+1):
nx = x + dx * n
ny = y + dy * n
if not(0<=nx<H and 0<=ny<W): break
if p[nx][ny] == '@': break
if d[nx][ny] <= d[x][y] + 1: break
if d[nx][ny] == d[x][y] + 1: continue
d[nx][ny] = d[x][y] + 1
q.append((nx,ny))
if d[x2][y2] < float('inf'):
print((d[x2][y2]))
else:
print((-1))
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
H,W,K = LI()
x1,y1,x2,y2 = _LI()
p = [SI() for _ in range(H)]
d = [[INF] * W for _ in range(H)]
d[x1][y1] = 0
q = []
q.append((0,x1,y1))
while q:
n,x,y = heapq.heappop(q)
if d[x][y] < n: continue
for dx,dy in DD:
for n in range(1,K+1):
nx = x + dx * n
ny = y + dy * n
if not(0<=nx<H and 0<=ny<W): break
if p[nx][ny] == '@': break
if d[nx][ny] < d[x][y] + 1: break
if d[nx][ny] == d[x][y] + 1: continue
d[nx][ny] = d[x][y] + 1
q.append((d[nx][ny],nx,ny))
if d[x2][y2] < INF:
print((d[x2][y2]))
else:
print((-1))
if __name__ == '__main__':
main() | p02644 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
H,W,K = LI()
x1,y1,x2,y2 = _LI()
p = [SI() for _ in range(H)]
d = [[INF] * W for _ in range(H)]
#d[x1][y1] = 0
q = []
q.append((0,x1,y1))
while q:
m,x,y = heapq.heappop(q)
if d[x][y] <= m: continue
d[x][y] = m
for dx,dy in DD:
for n in range(1,K+1):
nx = x + dx * n
ny = y + dy * n
if not(0<=nx<H and 0<=ny<W): break
if p[nx][ny] == '@': break
if d[nx][ny] < d[x][y] + 1: break
if d[nx][ny] == d[x][y] + 1: continue
#d[nx][ny] = d[x][y] + 1
q.append((m+1,nx,ny))
if d[x2][y2] < INF:
print((d[x2][y2]))
else:
print((-1))
if __name__ == '__main__':
main() | import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
DD = ((1,0),(0,1),(-1,0),(0,-1))
H,W,K = LI()
x1,y1,x2,y2 = _LI()
p = [SI() for _ in range(H)]
d = [[INF] * W for _ in range(H)]
d[x1][y1] = 0
q = []
q.append((0,x1,y1))
while q:
m,x,y = heapq.heappop(q)
if d[x][y] < m: continue
d[x][y] = m
for dx,dy in DD:
for n in range(1,K+1):
nx = x + dx * n
ny = y + dy * n
if not(0<=nx<H and 0<=ny<W): break
if p[nx][ny] == '@': break
if d[nx][ny] < m + 1: break
if d[nx][ny] == m + 1: continue
d[nx][ny] = m + 1
q.append((m+1,nx,ny))
if d[x2][y2] < INF:
print((d[x2][y2]))
else:
print((-1))
if __name__ == '__main__':
main() | p02644 |
# -*- coding: utf-8 -*-
import sys
from collections import deque
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
H,W,K=map(int,input().split())
sy,sx,gy,gx=map(int,input().split())
st=sx+sy*(W+2)
gl=gx+gy*(W+2)
c=['@']*(W+2)
for i in range(H):
c.extend(['@']+list(input())+['@'])
c.extend(['@']*(W+2))
que=deque()
dist=[INF]*(W+2)*(H+2)
que.append(st)
dist[st]=0
d=(-1,1,W+2,-(W+2))
while que:
v=que.popleft()
tmp_dist=dist[v]
for k in range(4):
nv=v
for _ in range(K):
nv+=+d[k]
if c[nv]=='.' and dist[nv]>tmp_dist:
dist[nv]=tmp_dist+1
que.append(nv)
else:
break
print(dist[gl] if dist[gl]!=INF else -1)
| # -*- coding: utf-8 -*-
import sys
from collections import deque
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
H,W,K=map(int,input().split())
sy,sx,gy,gx=map(int,input().split())
st=sx+sy*(W+2)
gl=gx+gy*(W+2)
c=['@']*(W+2)
for i in range(H):
c.extend(['@']+list(input())+['@'])
c.extend(['@']*(W+2))
que=deque()
dist=[INF]*(W+2)*(H+2)
que.append(st)
dist[st]=0
d=(-1,1,W+2,-(W+2))
while que:
v=que.popleft()
for k in range(4):
nv=v
for _ in range(K):
nv+=+d[k]
if c[nv]=='.' and dist[nv]>dist[v]:
if dist[nv]==INF:
dist[nv]=dist[v]+1
que.append(nv)
else:
break
print(dist[gl] if dist[gl]!=INF else -1)
| p02644 |
from collections import deque
import sys
N_MAX = 200000 + 5
H, W, K = list(map(int, input().split()))
sth, stw, glh, glw = list(map(int, input().split()))
INF = 10**6 * K
dp = [[INF for _ in range(W+2)] for _ in range(H+2)]
dp[0] = [-1]*(W+2)
dp[H+1] = [-1]*(W+2)
for h in range(1, H+1):
s = sys.stdin.readline()
dp[h][0] = -1
dp[h][W+1] = -1
for w in range(1, W+1):
if s[w-1] == "@":
dp[h][w] = -1
dp[sth][stw] = 0
# Seen = [[INF]*W for _ in range(H)]
XY = {(1, 0), (-1, 0), (0, 1), (0, -1)}
def bfs(sth, stw, glh, glw):
next_q = deque()
next_q.append((sth, stw))
while len(next_q) != 0:
# キュー取り出し(先頭)
h, w = next_q.popleft()
for dh, dw in XY:
for sk in range(1, K+1):
hs, ws = h + dh*sk, w + dw*sk
if dp[hs][ws] == -1:
break
if dp[hs][ws] == INF:
next_q.append((hs, ws))
dp[hs][ws] = dp[h][w] + 1
# elif dp[hs][ws] <= dp[h][w]:
# break
if hs == glh and ws == glw:
return dp[h][w] + 1
return -1
def main():
ret = bfs(sth, stw, glh, glw)
print(ret)
if __name__ == '__main__':
main()
| from collections import deque
import sys
N_MAX = 200000 + 5
H, W, K = list(map(int, input().split()))
sth, stw, glh, glw = list(map(int, input().split()))
INF = 10**6 * K
dp = [[INF for _ in range(W + 2)] for _ in range(H + 2)]
dp[0] = [-1] * (W + 2)
dp[H + 1] = [-1] * (W + 2)
for h in range(1, H + 1):
s = sys.stdin.readline()
dp[h][0] = -1
dp[h][W + 1] = -1
for w in range(1, W + 1):
if s[w - 1] == "@":
dp[h][w] = -1
dp[sth][stw] = 0
# Seen = [[INF]*W for _ in range(H)]
XY = {(1, 0), (-1, 0), (0, 1), (0, -1)}
def bfs(sth, stw, glh, glw):
next_q = deque()
next_q.append((sth, stw))
while len(next_q) != 0:
# キュー取り出し(先頭)
h, w = next_q.popleft()
for dh, dw in XY:
for sk in range(1, K + 1):
hs, ws = h + dh * sk, w + dw * sk
if dp[hs][ws] == -1:
break
if dp[hs][ws] == INF:
next_q.append((hs, ws))
dp[hs][ws] = dp[h][w] + 1
elif dp[hs][ws] <= dp[h][w]:
# もし、dp[hs][ws] が 今の値以下なら
# その先はdp[hs][ws]をもとに 書き込まれている or 今後書き込まれる ので止める
break
# if hs == glh and ws == glw:
# return dp[h][w] + 1
# return -1
def main():
bfs(sth, stw, glh, glw)
if dp[glh][glw] == INF:
print((-1))
else:
print((dp[glh][glw]))
if __name__ == '__main__':
main()
| p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
a=~w+a*w+b
d[a]=1
q=[a]
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
i,j=s//w+y*~z,s%w+x*~z;t=i*w+j;p=d[s]+1
if(h>i>-1<j<w)-1or'.'<m[i][j]or d[t]<p:break
if d[t]==I:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
a=~w+a*w+b
d[a]=1
q=[a]
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
i,j=s//w+y*~z,s%w+x*~z;t=i*w+j;p=d[s]+1
if(h>i>-1<j<w)-1or'.'<m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
a=~w+a*w+b
d[a]=1
q=[a]
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
i,j=s//w+y*~z,s%w+x*~z;t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
m+=d,
a=~w+a*w+b
d[a]=1
q=[a]
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
i,j=s//w+y*~z,s%w+x*~z;t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
m+=d,
a=~w+a*w+b
d[a]=1
q=[a]
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
i,j=s//w+y*~z,s%w+x*~z;t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
if'.'!=m[(i:=s//w+y*~z)][(j:=s%w+x*~z)]or(p:=d[s]+1)>d[(t:=i*w+j)]:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
if'.'!=m[(i:=s//w+y*~z)][(j:=s%w+x*~z)]or(p:=d[s]+1)>d[(t:=i*w+j)]:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for y,x in(1,0),(-1,0),(0,1),(0,-1):
for z in range(k):
if'.'!=m[(i:=s//w+y*~z)][(j:=s%w+x*~z)]or d[s]>=d[(t:=i*w+j)]:break
if-~d[s]<d[t]:q+=t,;d[t]=d[s]+1
print((d[~w+f*w+g]%I-1)) | p02644 |
y=1,0,-1,0,1
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for x in range(4):
for z in range(k):
if'.'!=m[(i:=s//w+y[x]*~z)][(j:=s%w+y[x+1]*~z)]or(p:=d[s]+1)>d[(t:=i*w+j)]:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
m+=d,
a=~w+a*w+b
q=[a]
d[a]=1
for s in q:
for x in range(4):
for z in range(k):
y=~z,0,z+1,0,~z;i,j=s//w+y[x],s%w+y[x+1];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for x in 0,1,2,3:
for z in range(k):
y=~z,0,z+1,0,~z;i,j=s//w+y[x],s%w+y[x+1];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
m+=d,
a=~w+a*w+b
q=[a]
d[a]=1
for s in q:
for x in 0,1,2,3:
for z in range(k):
y=~z,0,z+1,0;i,j=s//w+y[x],s%w+y[x^1];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
d=[I:=h*w]*I
m+=d,
q=[a:=~w+a*w+b]
d[a]=1
for s in q:
for x in range(4):
for z in range(k):
y=~z,0,z+1,0;i,j=s//w+y[x],s%w+y[x^1];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | h,a,*m=open(0)
h,w,k,a,b,f,g=list(map(int,(h+a).split()))
I=h*w
d=[I]*I
m+=d,
a=~w+a*w+b
q=[a]
d[a]=1
for s in q:
for x in 0,1,2,3:
for z in range(k):
y=~z,0,z+1,0;i,j=s//w+y[x],s%w+y[~x];t=i*w+j;p=d[s]+1
if'.'!=m[i][j]or d[t]<p:break
if d[t]>p:q+=t,;d[t]=p
print((d[~w+f*w+g]%I-1)) | p02644 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.