結果
| 問題 |
No.1441 MErGe
|
| コンテスト | |
| ユーザー |
 已经死了
|
| 提出日時 | 2024-06-28 17:57:26 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 9,276 bytes |
| コンパイル時間 | 440 ms |
| コンパイル使用メモリ | 82,304 KB |
| 実行使用メモリ | 115,072 KB |
| 最終ジャッジ日時 | 2024-06-28 17:57:59 |
| 合計ジャッジ時間 | 29,646 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 2 |
| other | AC * 16 TLE * 12 |
ソースコード
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))
n,q=li()
a=[0]+li()
sl=SortedList(list(range(1,n+1)))
bit=BIT(n+5)
for i in range(1,n+1):
bit.add(i,a[i])
for _ in range(q):
op,l,r=li()
st=sl[l-1]
ed=sl[r-1]
if op==1:
tot=bit.query(st,ed)
for _ in range(r-l+1):
tmp=sl[l-1]
bit.add(tmp,-bit.query(tmp,tmp))
sl.remove(tmp)
sl.add(st)
bit.add(st,tot)
else:
print(bit.query(st,ed))