結果
| 問題 | No.875 Range Mindex Query |
| ユーザー |
 sgsw
|
| 提出日時 | 2021-05-23 02:37:03 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
AC
|
| 実行時間 | 455 ms / 2,000 ms |
| コード長 | 5,862 bytes |
| コンパイル時間 | 185 ms |
| コンパイル使用メモリ | 82,304 KB |
| 実行使用メモリ | 100,780 KB |
| 最終ジャッジ日時 | 2024-04-19 10:16:53 |
| 合計ジャッジ時間 | 6,285 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 54 ms
67,456 KB |
| testcase_01 | AC | 88 ms
78,468 KB |
| testcase_02 | AC | 107 ms
78,192 KB |
| testcase_03 | AC | 64 ms
71,040 KB |
| testcase_04 | AC | 90 ms
77,748 KB |
| testcase_05 | AC | 61 ms
71,552 KB |
| testcase_06 | AC | 87 ms
78,328 KB |
| testcase_07 | AC | 88 ms
78,464 KB |
| testcase_08 | AC | 74 ms
78,428 KB |
| testcase_09 | AC | 77 ms
78,336 KB |
| testcase_10 | AC | 101 ms
78,464 KB |
| testcase_11 | AC | 450 ms
96,652 KB |
| testcase_12 | AC | 408 ms
93,172 KB |
| testcase_13 | AC | 390 ms
97,256 KB |
| testcase_14 | AC | 381 ms
96,452 KB |
| testcase_15 | AC | 441 ms
100,272 KB |
| testcase_16 | AC | 443 ms
99,780 KB |
| testcase_17 | AC | 449 ms
100,780 KB |
| testcase_18 | AC | 455 ms
100,652 KB |
ソースコード
import types
_atcoder_code = """
# Python port of AtCoder Library.
__all__ = ["string","lazysegtree","convolution","maxflow","modint"
,"mincostflow","segtree","_scc","_math","math","dsu","twosat","fenwicktree","scc","_bit","lca","unverified"]
__version__ = '0.0.1'
"""
atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)
_atcoder__bit_code = """
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
"""
atcoder._bit = types.ModuleType('atcoder._bit')
exec(_atcoder__bit_code, atcoder._bit.__dict__)
_atcoder_segtree_code = """
import typing
# import atcoder._bit
class SegTree:
'''
Segment Tree Library.
op(S,S) -> S
e = Identity element
SegTree(op,e,n) := Initialized by [e]*(n)
SegTree(op,e,vector) := Initialized by vector
'''
def __init__(self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = atcoder._bit._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
'''
a[p] -> x in O(logN).
'''
assert 0 <= p < self._n
p += self._size
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
'''
return a[p] in O(1).
'''
assert 0 <= p < self._n
return self._d[p + self._size]
def prod(self, left: int, right: int) -> typing.Any:
'''
return op(a[l...r)) in O(logN).
'''
assert 0 <= left <= right <= self._n
sml = self._e
smr = self._e
left += self._size
right += self._size
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def max_right(self, left: int,
f: typing.Callable[[typing.Any], bool]) -> int:
'''
let f(S) -> bool and l is const.
return maximum r for which f(op[l...r)) == true is satisfied, in O(logN).
'''
assert 0 <= left <= self._n
# assert f(self._e)
if left == self._n:
return self._n
left += self._size
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not f(self._op(sm, self._d[left])):
while left < self._size:
left *= 2
if f(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int,
f: typing.Callable[[typing.Any], bool]) -> int:
'''
let f(S) -> bool and r is const.
return minimum l for which f(op[l...r)) == true is satisfied, in O(logN).
'''
assert 0 <= right <= self._n
# assert f(self._e)
if right == 0:
return 0
right += self._size
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not f(self._op(self._d[right], sm)):
while right < self._size:
right = 2 * right + 1
if f(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
"""
atcoder.segtree = types.ModuleType('atcoder.segtree')
atcoder.segtree.__dict__['atcoder'] = atcoder
atcoder.segtree.__dict__['atcoder._bit'] = atcoder._bit
exec(_atcoder_segtree_code, atcoder.segtree.__dict__)
SegTree = atcoder.segtree.SegTree
# from atcoder.segtree import SegTree
import sys
#Library Info(ACL for Python/Pypy) -> https://github.com/not522/ac-library-python
def input():
return sys.stdin.readline().rstrip()
INF = 1 << 64
def main():
n, q = map(int, input().split())
a = list(map(int, input().split()))
S = SegTree(lambda x, y: min(x, y), INF,a)
Query = [tuple(map(int,input().split())) for i in range(q)]
for i in range(q):
t,*args = Query[i]
if t == 1:
l,r = args
l -= 1
r -= 1
lval,rval = S.get(l),S.get(r)
S.set(r,lval)
S.set(l,rval)
else:
l,r = args
l -= 1
res = S.prod(l,r)
#print(res,"<-",l,r,[S.get(i) for i in range(n)])
idx = S.min_left(r,lambda x: x > res)
print(idx)
return 0
if __name__ == "__main__":
main()