結果

問題 No.2220 Range Insert & Point Mex
ユーザー shobonvipshobonvip
提出日時 2023-02-17 22:10:33
言語 PyPy3
(7.3.15)
結果
AC  
実行時間 630 ms / 2,000 ms
コード長 4,432 bytes
コンパイル時間 500 ms
コンパイル使用メモリ 81,976 KB
実行使用メモリ 222,392 KB
最終ジャッジ日時 2024-07-21 12:44:09
合計ジャッジ時間 14,015 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 70 ms
67,712 KB
testcase_01 AC 62 ms
67,712 KB
testcase_02 AC 63 ms
67,840 KB
testcase_03 AC 64 ms
67,712 KB
testcase_04 AC 61 ms
67,584 KB
testcase_05 AC 64 ms
68,224 KB
testcase_06 AC 63 ms
67,584 KB
testcase_07 AC 64 ms
67,968 KB
testcase_08 AC 65 ms
67,712 KB
testcase_09 AC 64 ms
67,840 KB
testcase_10 AC 65 ms
68,352 KB
testcase_11 AC 63 ms
67,840 KB
testcase_12 AC 63 ms
67,968 KB
testcase_13 AC 628 ms
222,392 KB
testcase_14 AC 620 ms
222,000 KB
testcase_15 AC 609 ms
222,144 KB
testcase_16 AC 619 ms
222,256 KB
testcase_17 AC 620 ms
222,384 KB
testcase_18 AC 616 ms
222,268 KB
testcase_19 AC 630 ms
222,004 KB
testcase_20 AC 281 ms
123,592 KB
testcase_21 AC 295 ms
123,728 KB
testcase_22 AC 292 ms
123,980 KB
testcase_23 AC 437 ms
131,760 KB
testcase_24 AC 441 ms
130,284 KB
testcase_25 AC 345 ms
144,124 KB
testcase_26 AC 427 ms
132,624 KB
testcase_27 AC 335 ms
106,416 KB
testcase_28 AC 179 ms
131,016 KB
testcase_29 AC 181 ms
135,556 KB
testcase_30 AC 182 ms
135,432 KB
testcase_31 AC 296 ms
136,888 KB
testcase_32 AC 338 ms
141,480 KB
testcase_33 AC 340 ms
142,176 KB
testcase_34 AC 390 ms
121,948 KB
testcase_35 AC 384 ms
122,584 KB
testcase_36 AC 381 ms
128,268 KB
testcase_37 AC 386 ms
131,492 KB
testcase_38 AC 500 ms
150,512 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List

T = TypeVar('T')

# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
class SortedSet(Generic[T]):
	BUCKET_RATIO = 50
	REBUILD_RATIO = 170
	
	def _build(self, a=None) -> None:
		"Evenly divide `a` into buckets."
		if a is None: a = list(self)
		size = self.size = len(a)
		bucket_size = int(math.ceil(math.sqrt(size/self.BUCKET_RATIO)))
		self.a = [a[size*i//bucket_size: size*(i+1)//bucket_size] for i in range(bucket_size)]
	
	def __init__(self, a: Iterable[T] = []) -> None:
		"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
		a = list(a)
		if not all(a[i] < a[i+1] for i in range(len(a)-1)):
			a = sorted(set(a))
		self._build(a)
	
	def __iter__(self) -> Iterator[T]:
		for i in self.a:
			for j in i: yield j
	
	def __reversed__(self) -> Iterator[T]:
		for i in reversed(self.a):
			for j in reversed(i): yield j
	
	def __len__(self) -> int:
		return self.size
	
	def __repr__(self) -> str:
		return "SortedSet"+str(self.a)
	
	def __str__(self) -> str:
		s = str(list(self))
		return "{"+s[1: len(s)-1]+"}"
	
	def _find_bucket(self, x: T) -> List[T]:
		"Find the bucket which should contain x. self must not be empty."
		for a in self.a:
			if x <= a[-1]: return a
		return a
	
	def __contains__(self, x: T) -> bool:
		if self.size == 0: return False
		a = self._find_bucket(x)
		i = bisect_left(a, x)
		return i != len(a) and a[i] == x
	
	def add(self, x: T) -> bool:
		"Add an element and return True if added. / O(√N)"
		if self.size == 0:
			self.a = [[x]]
			self.size = 1
			return True
		a = self._find_bucket(x)
		i = bisect_left(a, x)
		if i != len(a) and a[i] == x: return False
		a.insert(i, x)
		self.size += 1
		if len(a) > len(self.a)*self.REBUILD_RATIO:
			self._build()
		return True
	
	def discard(self, x: T) -> bool:
		"Remove an element and return True if removed. / O(√N)"
		if self.size == 0: return False
		a = self._find_bucket(x)
		i = bisect_left(a, x)
		if i == len(a) or a[i] != x: return False
		a.pop(i)
		self.size -= 1
		if len(a) == 0: self._build()
		return True
	
	def lt(self, x: T) -> Union[T, None]:
		"Find the largest element < x, or None if it doesn't exist."
		for a in reversed(self.a):
			if a[0] < x:
				return a[bisect_left(a, x)-1]
	
	def le(self, x: T) -> Union[T, None]:
		"Find the largest element <= x, or None if it doesn't exist."
		for a in reversed(self.a):
			if a[0] <= x:
				return a[bisect_right(a, x)-1]
	
	def gt(self, x: T) -> Union[T, None]:
		"Find the smallest element > x, or None if it doesn't exist."
		for a in self.a:
			if a[-1] > x:
				return a[bisect_right(a, x)]
	
	def ge(self, x: T) -> Union[T, None]:
		"Find the smallest element >= x, or None if it doesn't exist."
		for a in self.a:
			if a[-1] >= x:
				return a[bisect_left(a, x)]
	
	def __getitem__(self, x: int) -> T:
		"Return the x-th element, or IndexError if it doesn't exist."
		if x < 0: x += self.size
		if x < 0: raise IndexError
		for a in self.a:
			if x < len(a): return a[x]
			x -= len(a)
		raise IndexError
	
	def index(self, x: T) -> int:
		"Count the number of elements < x."
		ans = 0
		for a in self.a:
			if a[-1] >= x:
				return ans+bisect_left(a, x)
			ans += len(a)
		return ans
	
	def index_right(self, x: T) -> int:
		"Count the number of elements <= x."
		ans = 0
		for a in self.a:
			if a[-1] > x:
				return ans+bisect_right(a, x)
			ans += len(a)
		return ans


def compress(arr):
	*XS, = set(arr)
	XS.sort()
	return {cmp_e: cmp_i for cmp_i, cmp_e in enumerate(XS)}

n = int(input())
lss = []
rss = []
ass = []
qss = []
for i in range(n):
	l,r,a = map(int,input().split())
	if a > n: continue
	lss.append(l)
	rss.append(r)
	ass.append(a)
	qss.append(l)
	qss.append(r)

Q = int(input())
x = list(map(int,input().split()))
qss += x[::]

q_c = compress(qss)
m = len(q_c)

bucket1 = [[] for i in range(m)]
bucket2 = [[] for i in range(m)]
for i in range(len(lss)):
	bucket1[q_c[lss[i]]].append(ass[i])
	bucket2[q_c[rss[i]]].append(ass[i])	

nouse = SortedSet(range(n+1))
cnt = [0] * (n+1)

pivot = 0
for i in range(m):
	# 追加処理
	for j in bucket1[i]:
		if cnt[j] == 0:
			nouse.discard(j)
		cnt[j] += 1

	# クエリ処理
	if pivot < Q and q_c[x[pivot]] == i:
		print(nouse.ge(0))
		pivot += 1

	# 削除処理
	for j in bucket2[i]:
		cnt[j] -= 1
		if cnt[j] == 0:
			nouse.add(j)
0