結果

問題 No.2421 entersys?
ユーザー shobonvipshobonvip
提出日時 2023-08-12 14:06:44
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 1,151 ms / 3,000 ms
コード長 6,389 bytes
コンパイル時間 5,316 ms
コンパイル使用メモリ 291,624 KB
実行使用メモリ 60,484 KB
最終ジャッジ日時 2024-11-19 17:25:15
合計ジャッジ時間 21,204 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 7 ms
17,396 KB
testcase_01 AC 9 ms
17,472 KB
testcase_02 AC 11 ms
17,560 KB
testcase_03 AC 8 ms
17,392 KB
testcase_04 AC 9 ms
17,524 KB
testcase_05 AC 9 ms
17,500 KB
testcase_06 AC 9 ms
17,496 KB
testcase_07 AC 9 ms
17,600 KB
testcase_08 AC 10 ms
17,500 KB
testcase_09 AC 11 ms
17,648 KB
testcase_10 AC 9 ms
17,460 KB
testcase_11 AC 782 ms
45,024 KB
testcase_12 AC 811 ms
44,976 KB
testcase_13 AC 812 ms
45,072 KB
testcase_14 AC 790 ms
44,948 KB
testcase_15 AC 769 ms
45,160 KB
testcase_16 AC 817 ms
47,064 KB
testcase_17 AC 806 ms
47,124 KB
testcase_18 AC 815 ms
47,100 KB
testcase_19 AC 816 ms
47,176 KB
testcase_20 AC 806 ms
47,028 KB
testcase_21 AC 679 ms
41,040 KB
testcase_22 AC 576 ms
39,516 KB
testcase_23 AC 1,151 ms
60,380 KB
testcase_24 AC 1,146 ms
60,484 KB
testcase_25 AC 1,131 ms
60,452 KB
testcase_26 AC 389 ms
36,016 KB
testcase_27 AC 390 ms
36,112 KB
testcase_28 AC 399 ms
36,028 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
using namespace std;

//* ATCODER
#include<atcoder/all>
using namespace atcoder;
typedef modint998244353 mint;
//*/

/* BOOST MULTIPRECISION
#include<boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
//*/

typedef long long ll;

#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define rrep(i, s, n) for (int i = (int)(n)-1; i >= (int)(s); i--)

template <typename T> bool chmin(T &a, const T &b) {
	if (a <= b) return false;
	a = b;
	return true;
}

template <typename T> bool chmax(T &a, const T &b) {
	if (a >= b) return false;
	a = b;
	return true;
}

template <typename T> T max(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmax(ret, a[i]);
	return ret;
}

template <typename T> T min(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmin(ret, a[i]);
	return ret;
}

template <typename T> T sum(vector<T> &a){
	T ret = 0;
	for (int i=0; i<(int)a.size(); i++) ret += a[i];
	return ret;
}

// https://lorent-kyopro.hatenablog.com/entry/2021/03/12/025644
template <class S, S (*op)(S, S), S (*e)()> class dynamic_segtree {
public:
	dynamic_segtree(size_t n) : n(n), root(nullptr) {}

	void set(size_t p, S x) {
		assert(p < n);
		set(root, 0, n, p, x);
	}

	S get(size_t p) const {
		assert(p < n);
		return get(root, 0, n, p);
	}

	S prod(size_t l, size_t r) const {
		assert(l <= r && r <= n);
		return prod(root, 0, n, l, r);
	}

	S all_prod() const { return root ? root->product : e(); }

	void reset(size_t l, size_t r) {
		assert(l <= r && r <= n);
		return reset(root, 0, n, l, r);
	}

	template <bool (*f)(S)> size_t max_right(size_t l) const {
		return max_right(l, [](S x) { return f(x); });
	}

	template <class F> size_t max_right(size_t l, const F& f) const {
		assert(l <= n);
		S product = e();
		assert(f(product));
		return max_right(root, 0, n, l, f, product);
	}

	template <bool (*f)(S)> size_t min_left(size_t r) const {
		return min_left(r, [](S x) { return f(x); });
	}

	template <class F> size_t min_left(size_t r, const F& f) const {
		assert(r <= n);
		S product = e();
		assert(f(product));
		return min_left(root, 0, n, r, f, product);
	}

private:
	struct node;
	using node_ptr = std::unique_ptr<node>;

	struct node {
		size_t index;
		S value, product;
		node_ptr left, right;

		node(size_t index, S value)
			: index(index),
			  value(value),
			  product(value),
			  left(nullptr),
			  right(nullptr) {}

		void update() {
			product = op(op(left ? left->product : e(), value),
						 right ? right->product : e());
		}
	};

	const size_t n;
	node_ptr root;

	void set(node_ptr& t, size_t a, size_t b, size_t p, S x) const {
		if (!t) {
			t = std::make_unique<node>(p, x);
			return;
		}
		if (t->index == p) {
			t->value = x;
			t->update();
			return;
		}
		size_t c = (a + b) >> 1;
		if (p < c) {
			if (t->index < p) std::swap(t->index, p), std::swap(t->value, x);
			set(t->left, a, c, p, x);
		} else {
			if (p < t->index) std::swap(p, t->index), std::swap(x, t->value);
			set(t->right, c, b, p, x);
		}
		t->update();
	}

	S get(const node_ptr& t, size_t a, size_t b, size_t p) const {
		if (!t) return e();
		if (t->index == p) return t->value;
		size_t c = (a + b) >> 1;
		if (p < c) return get(t->left, a, c, p);
		else return get(t->right, c, b, p);
	}

	S prod(const node_ptr& t, size_t a, size_t b, size_t l, size_t r) const {
		if (!t || b <= l || r <= a) return e();
		if (l <= a && b <= r) return t->product;
		size_t c = (a + b) >> 1;
		S result = prod(t->left, a, c, l, r);
		if (l <= t->index && t->index < r) result = op(result, t->value);
		return op(result, prod(t->right, c, b, l, r));
	}

	void reset(node_ptr& t, size_t a, size_t b, size_t l, size_t r) const {
		if (!t || b <= l || r <= a) return;
		if (l <= a && b <= r) {
			t.reset();
			return;
		}
		size_t c = (a + b) >> 1;
		reset(t->left, a, c, l, r);
		reset(t->right, c, b, l, r);
		t->update();
	}

	template <class F>
	size_t max_right(const node_ptr& t, size_t a, size_t b,
					 size_t l, const F& f, S& product) const {
		if (!t || b <= l) return n;
		if (f(op(product, t->product))) {
			product = op(product, t->product);
			return n;
		}
		size_t c = (a + b) >> 1;
		size_t result = max_right(t->left, a, c, l, f, product);
		if (result != n) return result;
		if (l <= t->index) {
			product = op(product, t->value);
			if (!f(product)) return t->index;
		}
		return max_right(t->right, c, b, l, f, product);
	}

	template <class F>
	size_t min_left(const node_ptr& t, size_t a, size_t b,
					size_t r, const F& f, S& product) const {
		if (!t || r <= a) return 0;
		if (f(op(t->product, product))) {
			product = op(t->product, product);
			return 0;
		}
		size_t c = (a + b) >> 1;
		size_t result = min_left(t->right, c, b, r, f, product);
		if (result != 0) return result;
		if (t->index < r) {
			product = op(t->value, product);
			if (!f(product)) return t->index + 1;
		}
		return min_left(t->left, a, c, r, f, product);
	}
};

int op(int a, int b){
	return a + b;
}
int e(){
	return 0;
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int n, q; cin >> n;
	dynamic_segtree<int,op,e> seg(1e9+50);
	
	vector<map<int,int>> sg(300000);
	int piv = 0;
	map<string,int> g;

	rep(i,0,n){
		string x;
		int l, r; cin >> x >> l >> r;
		if (g.find(x) == g.end()){
			g[x] = piv;
			piv++;
		}
		seg.set(l, seg.get(l) + 1);
		seg.set(r+1, seg.get(r+1) - 1);
		sg[g[x]][l] += 1;
		sg[g[x]][r+1] += -1;
		if (sg[g[x]][l] == 0){
			sg[g[x]].erase(l);
		}
		if (sg[g[x]][r+1] == 0){
			sg[g[x]].erase(r+1);
		}
	}

	cin >> q;
	rep(i,0,q){
		int t; cin >> t;
		if (t == 1){
			string x; int v; cin >> x >> v;
			if (g.find(x) == g.end()){
				g[x] = piv;
				piv++;
			}
			auto k = sg[g[x]].upper_bound(v);
			if (k == sg[g[x]].begin()){
				cout << "No\n";
				continue;
			}
			k--;
			if (k->second == 1){
				cout << "Yes\n";
			}else{
				cout << "No\n";
			}
		}else if (t == 2){
			int v; cin >> v;
			cout << seg.prod(0, v + 1) << '\n';
		}else{
			string x;
			int l, r; cin >> x >> l >> r;
			if (g.find(x) == g.end()){
				g[x] = piv;
				piv++;
			}
			seg.set(l, seg.get(l) + 1);
			seg.set(r+1, seg.get(r+1) - 1);
			sg[g[x]][l] += 1;
			sg[g[x]][r+1] += -1;
			if (sg[g[x]][l] == 0){
				sg[g[x]].erase(l);
			}
			if (sg[g[x]][r+1] == 0){
				sg[g[x]].erase(r+1);
			}
		}
	}
}
0