結果
| 問題 | No.1441 MErGe |
| ユーザー |
 已经死了
|
| 提出日時 | 2024-06-28 19:02:50 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
AC
|
| 実行時間 | 970 ms / 1,000 ms |
| コード長 | 9,807 bytes |
| コンパイル時間 | 185 ms |
| コンパイル使用メモリ | 82,432 KB |
| 実行使用メモリ | 131,620 KB |
| 最終ジャッジ日時 | 2024-06-28 19:03:15 |
| 合計ジャッジ時間 | 22,259 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge4 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 141 ms
83,584 KB |
| testcase_01 | AC | 155 ms
83,584 KB |
| testcase_02 | AC | 144 ms
83,584 KB |
| testcase_03 | AC | 212 ms
84,608 KB |
| testcase_04 | AC | 220 ms
84,992 KB |
| testcase_05 | AC | 283 ms
85,504 KB |
| testcase_06 | AC | 249 ms
84,864 KB |
| testcase_07 | AC | 255 ms
84,992 KB |
| testcase_08 | AC | 431 ms
93,824 KB |
| testcase_09 | AC | 391 ms
92,544 KB |
| testcase_10 | AC | 473 ms
92,288 KB |
| testcase_11 | AC | 504 ms
89,856 KB |
| testcase_12 | AC | 487 ms
93,952 KB |
| testcase_13 | AC | 913 ms
128,656 KB |
| testcase_14 | AC | 852 ms
128,376 KB |
| testcase_15 | AC | 859 ms
124,480 KB |
| testcase_16 | AC | 796 ms
128,248 KB |
| testcase_17 | AC | 811 ms
124,328 KB |
| testcase_18 | AC | 675 ms
111,232 KB |
| testcase_19 | AC | 711 ms
114,944 KB |
| testcase_20 | AC | 611 ms
111,360 KB |
| testcase_21 | AC | 620 ms
112,256 KB |
| testcase_22 | AC | 706 ms
111,872 KB |
| testcase_23 | AC | 897 ms
129,532 KB |
| testcase_24 | AC | 910 ms
129,520 KB |
| testcase_25 | AC | 880 ms
129,652 KB |
| testcase_26 | AC | 970 ms
129,652 KB |
| testcase_27 | AC | 889 ms
131,620 KB |
| testcase_28 | AC | 581 ms
129,044 KB |
| testcase_29 | AC | 619 ms
129,396 KB |
ソースコード
import os,sys,random,threading
#sys.exit() 退出程序
from random import randint,choice,shuffle
#randint(a,b)从[a,b]范围随机选择一个数
#choice(seq)seq可以是一个列表,元组或字符串,从seq中随机选取一个元素
#shuffle(x)将一个可变的序列x中的元素打乱
from copy import deepcopy
from io import BytesIO,IOBase
from types import GeneratorType
from functools import lru_cache,reduce
#reduce(op,迭代对象)
from bisect import bisect_left,bisect_right
#bisect_left(x) 大于等于x的第一个下标
#bisect_right(x) 大于x的第一个下标
from collections import Counter,defaultdict,deque
from itertools import accumulate,combinations,permutations
#accumulate(a)用a序列生成一个累积迭代器，一般list化前面放个[0]做前缀和用
#combinations(a,k)a序列选k个 组合迭代器
#permutations(a,k)a序列选k个 排列迭代器
from heapq import heapify,heappop,heappush
#heapify将列表转为堆
from typing import Generic,Iterable,Iterator,TypeVar,Union,List
from string import ascii_lowercase,ascii_uppercase,digits
#小写字母，大写字母，十进制数字
from math import ceil,floor,sqrt,pi,factorial,gcd,log,log10,log2,inf
#ceil向上取整，floor向下取整 ，sqrt开方 ，factorial阶乘
from decimal import Decimal,getcontext
#Decimal(s) 实例化Decimal对象,一般使用字符串
#getcontext().prec=100 修改精度
from sys import stdin, stdout, setrecursionlimit
input = lambda: sys.stdin.readline().rstrip("\r\n")
MI = lambda :map(int,input().split())
li = lambda :list(MI())
ii = lambda :int(input())
mod = int(1e9 + 7) #998244353
inf = int(1e20)
py = lambda :print("YES")
pn = lambda :print("NO")
DIRS = [(0, 1), (1, 0), (0, -1), (-1, 0)] # 右下左上
DIRS8 = [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0),(-1, 1)] # →↘↓↙←↖↑↗
class BIT:
"""单点修改,区间和查询"""
__slots__ = "size", "bit", "tree"
def __init__(self, n: int):
self.size = n
self.bit = n.bit_length()
self.tree = [0]*(n+1)
def add(self, index: int, delta: int) -> None:
# index 必须大于0
while index <= self.size:
self.tree[index]+=delta
index += index & -index
def _query(self, index: int) -> int:
res = 0
while index > 0:
res += self.tree[index]
index -= index & -index
return res
def query(self, left: int, right: int) -> int:
return self._query(right) - self._query(left - 1)
def bisectLeft(self, k: int) -> int:
"""返回第一个前缀和大于等于k的位置pos
1 <= pos <= self.size + 1
"""
curSum, pos = 0, 0
for i in range(self.bit, -1, -1):
nextPos = pos + (1 << i)
if nextPos <= self.size and curSum + self.tree[nextPos] < k:
pos = nextPos
curSum += self.tree[pos]
return pos + 1
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values);self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = [];self._rebuild = True
def _fen_build(self):
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
if self._rebuild:self._fen_build()
_fen_tree = self._fen_tree;x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
_list_lens = self._list_lens
if k < _list_lens[0]:return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
if not self._len:return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:pos = mi
else:lo = mi
if pos and value <= _lists[pos - 1][-1]:pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:idx = mi
else:lo = mi
return pos, idx
def _loc_right(self, value):
if not self._len:return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:hi = mi
else:pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:idx = mi
else:lo = mi
return pos, idx
def add(self, value):
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
_len = self._len
self.discard(value)
if _len == self._len:raise Valueerror('{0!r} not in list'.format(value))
def pop(self, index=-1):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
return self._len
def __getitem__(self, index):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
return (value for _list in self._lists for value in _list)
def __reversed__(self):
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
return 'SortedList({0})'.format(list(self))
class chain:
def __init__(self,n):
#维护每个节点的前驱后继，初始时每个点的前驱和后继都是自己
self.nxtfa=list(range(n+2))
self.prefa=list(range(n+2))
def nxt(self,x):
t=x;fa=self.nxtfa
while fa[x]!=x:
x=fa[x]
while t!=x:
fa[t],t=x,fa[t]
return x
def pre(self,x):
t=x;fa=self.prefa
while fa[x]!=x:
x=fa[x]
while t!=x:
fa[t],t=x,fa[t]
return x
def remove(self,x):
self.nxtfa[x]=self.nxt(x+1)
self.prefa[x]=self.pre(x-1)
n,q=li()
a=[0]+li()
sl=SortedList(list(range(n+5)))
un=chain(n+5)
pre=list(accumulate(a))
for _ in range(q):
op,l,r=li()
st,ed=sl[l],sl[r+1]-1
if op==2:
print(pre[ed]-pre[st-1])
else:
idx=un.nxt(st+1)
while idx<=ed:
sl.remove(idx)
un.remove(idx)
idx=un.nxt(idx+1)