#1113354 (C++23) No.3239 Omnibus

提出ソース

結果

問題	No.3239 Omnibus
コンテスト
ユーザー	kwm_t
提出日時	2025-08-16 14:33:27
言語	C++23 (gcc 13.3.0 + boost 1.87.0)
結果	AC
実行時間	591 ms / 10,000 ms
コード長	6,120 bytes
コンパイル時間	3,407 ms
コンパイル使用メモリ	301,140 KB
実行使用メモリ	30,464 KB
最終ジャッジ日時	2025-08-16 14:33:48
合計ジャッジ時間	18,425 ms
ジャッジサーバーID （参考情報）	judge2 / judge5

このコードへのチャレンジ
（要ログイン）

ファイルパターン	結果
sample	AC * 1
other	AC * 33

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
//using mint = modint1000000007;
//const int mod = 1000000007;
//using mint = modint998244353;
//const int mod = 998244353;
//const int INF = 1e9;
//const long long LINF = 1e18;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i,l,r)for(int i=(l);i<(r);++i)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; --i)
#define rrep2(i,l,r)for(int i=(r) - 1;i>=(l);--i)
#define all(x) (x).begin(),(x).end()
#define allR(x) (x).rbegin(),(x).rend()
#define P pair<long long,long long>
template<typename A, typename B> inline bool chmax(A & a, const B & b) { if (a < b) { a = b; return true; } return false; }
template<typename A, typename B> inline bool chmin(A & a, const B & b) { if (a > b) { a = b; return true; } return false; }
// 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() : n(0), root(nullptr) {}
	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 {
		if (l >= r)return e();
		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);
	}
};

P op(P a, P b) {
	return { a.first + b.first,a.second + b.second };
}
P e() { return { 0,0 }; }
int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	int n, q; cin >> n >> q;
	string s; cin >> s;

	vector<dynamic_segtree<P, op, e>> seg;
	seg.reserve(26 * 26 * 26);
	for (int i = 0; i < 26 * 26 * 26; i++) {
		seg.emplace_back(n);
	}
	auto encode = [&](int index)->int {
		int x = 0;
		rep(i, 3) {
			x *= 26;
			x += s[index + i] - 'a';
		}
		return x;
	};
	auto encode2 = [&](string s)->int {
		int x = 0;
		rep(i, 3) {
			x *= 26;
			x += s[i] - 'a';
		}
		return x;
	};
	rep(i, n - 2) {
		seg[encode(i)].set(i, { i,1 });
	}
	while (q--) {
		int t; cin >> t;
		if (t == 1) {
			int k; cin >> k;
			char c; cin >> c;
			k--;
			rep2(idx, k - 2, k + 1) {
				if (idx < 0)continue;
				if (idx >= n - 2)continue;
				seg[encode(idx)].set(idx, e());
			}
			s[k] = c;
			rep2(idx, k - 2, k + 1) {
				if (idx < 0)continue;
				if (idx >= n - 2)continue;
				seg[encode(idx)].set(idx, { idx,1 });
			}
		}
		else {
			int l, r; cin >> l >> r;
			l--, r--;
			string s; cin >> s;
			auto key = encode2(s);
			auto val = seg[key].prod(l, r - 1);
			long long ans = val.first - val.second*(l - 1);
			cout << ans << endl;
		}
	}
	return 0;
}

yukicoder

結果

ソースコード