大家好，我是个毒瘤，我非常喜欢暴力数据结构，于是我就用莫队+分块过了这个题

Solution

发现这个题静态查询资瓷离线，于是考虑莫队。

在这里简单介绍一下莫队：

将所有询问离线后，对原序列分块。按照左端点所在块单调不降排序。当左端点所在块相同时，按照右端点单调排序。

然后用头尾指针指向当前的区间，维护区间内的信息。每两个查询间暴力移动指针。移动指针时每移动一下就维护一次答案。

考虑这么做的复杂度：一共有 \(O(\sqrt{n})\)个块，每个块内右端点单调，所以一个块内右端点最多移移动 \(O(n)\) 个位置，于是右端点移动 \(O(n~\sqrt{n})\)个位置。同理，左端点在一个块内最多移动 \(O(\sqrt{n})\) 次，每次最多移动 \(O(\sqrt{n})\) 个位置，块内移动次数是 \(O(n)\) 。一共有 \(O(\sqrt{n})\) 个块，于是左端点移动 \(O(n~\sqrt{n})\) 个位置。于是莫队不计修改和查询的总复杂度为 \(O(n~\sqrt{n})\)。

维护答案时，最显然的想法是用树状数组维护前缀和，这样单次修改复杂度 \(O(\log n)\) ，查询时在树状数组上二分，复杂度 \(O(\log n)\) 。修改总复杂度 \(O(n~\sqrt{n}~\log n)\) ，查询的总复杂度 \(O(m~\log n)\) 。于是发现修改的复杂度过高，查询的复杂度完全不需要这么低，那么可以用分块将修改复杂度将至 \(O(1)\) ，查询复杂度升高至 \(O(\sqrt{n})\) 。具体的，离散化后按照权值分块，每个块维护块内元素出现总次数。查询时暴力从第一个块开始扫，累加元素出现总次数，当加入一个块总次数大于 \(k\) 时在块内暴力找位置，总复杂度 \(O(n~\sqrt n)\)。开O2最慢的点250ms

Code

#include <cmath>

#include <cstdio>

#include <algorithm>

#ifdef ONLINE_JUDGE

#define freopen(a, b, c)

#endif

#define rg register

#define ci const int

#define cl const long long

typedef long long int ll;

namespace IPT {

	const int L = 10000000;

	char buf[L], *front=buf, *end=buf;

	char GetChar() {

		if (front == end) {

			end = buf + fread(front = buf, 1, L, stdin);

			if (front == end) return -1;

		}

		return *(front++);

	}

}

template <typename T>

inline void qr(T &x) {

	rg char ch = IPT::GetChar(), lst = ' ';

	while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();

	while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();

	if (lst == '-') x = -x;

}

template <typename T>

inline void ReadDb(T &x) {

	rg char ch = IPT::GetChar(), lst = ' ';

	while ((ch > '9') || (ch < '0')) lst = ch, ch = IPT::GetChar();

	while ((ch >= '0') && (ch <= '9')) x = x * 10 + (ch ^ 48), ch = IPT::GetChar();

	if (ch == '.') {

		ch = IPT::GetChar();

		double base = 1;

		while ((ch >= '0') && (ch <= '9')) x += (ch ^ 48) * ((base *= 0.1)), ch = IPT::GetChar();

	}

	if (lst == '-') x = -x;

}

namespace OPT {

	char buf[120];

}

template <typename T>

inline void qw(T x, const char aft, const bool pt) {

	if (x < 0) {x = -x, putchar('-');}

	rg int top=0;

	do {OPT::buf[++top] = x % 10 + '0';} while ( x /= 10);

	while (top) putchar(OPT::buf[top--]);

	if (pt) putchar(aft);

}

const int maxn = 200010;

int n, m;

int belong[maxn], MU[maxn], temp[maxn], bk[maxn], block[maxn], rmp[maxn], lc[maxn];

struct Ask {

	int l, r, id, ans, k;

	inline bool operator<(const Ask &_others) const {

		if (belong[this->l] != belong[_others.l]) return this->l < _others.l;

		if (belong[this->l] & 1) return this->r < _others.r;

		return this->r > _others.r;

	}

};

Ask ask[maxn];

void init_hash();

void add(ci&);

void dlt(ci&);

inline bool cmp(const Ask &_a,const Ask &_b) {

	return _a.id < _b.id;

}

int main() {

	freopen("1.in", "r", stdin) ;

	qr(n); qr(m);

	for (rg int i = 1, sn = sqrt(n); i <= n; ++i) if((belong[i] = i / sn) != belong[i-1]) lc[belong[i]] = i;

	for (rg int i = 1; i <= n; ++i) qr(MU[i]);

	init_hash();

	for (rg int i = 1; i <= m; ++i) {

		qr(ask[i].l); qr(ask[i].r); qr(ask[i].k); ask[i].id = i;

	}

	std::sort(ask + 1, ask + 1 + m);

	int prel = ask[1].l, prer = prel - 1;

	for (rg int i = 1; i <= m; ++i) {

		int l = ask[i].l, r = ask[i].r;

		while (prel < l) dlt(prel++);

		while (prel > l) add(--prel);

		while (prer > r) dlt(prer--);

		while (prer < r) add(++prer);

		int _cnt = 0, cur = 0;

		while (_cnt + block[cur] < ask[i].k) _cnt+=block[cur++];

		for (rg int j = lc[cur]; ; ++j) if((_cnt += bk[j]) >= ask[i].k) {

			ask[i].ans = j; break;

		}

	}

	std::sort(ask + 1, ask + 1 + m, cmp);

	for (rg int i = 1; i <= m; ++i) qw(rmp[ask[i].ans], '\n', true);

	return 0;

}

void init_hash() {

	for (rg int i = 1; i <= n; ++i) temp[i] = MU[i];

	std::sort(temp + 1, temp + 1 + n);

	int *ed = std::unique(temp + 1, temp + 1 + n);

	for (rg inti = 1; i <= n; ++i) {

		int k = MU[i];

		rmp[MU[i] = std::lower_bound(temp + 1, ed, MU[i]) - temp] = k;

	}

}

inline void dlt(ci &k) {

	--bk[MU[k]];

	--block[belong[MU[k]]];

}

inline void add(ci &k) {

	++bk[MU[k]];

	++block[belong[MU[k]]];

}

巴特西

【莫队】【P3834】【模板】可持久化线段树 1（主席树）

大家好，我是个毒瘤，我非常喜欢暴力数据结构，于是我就用莫队+分块过了这个题

Solution

Code

Summary

我爱暴力数据结构！

最新文章

热门文章

巴特西

【莫队】【P3834】 【模板】可持久化线段树 1（主席树）

大家好，我是个毒瘤，我非常喜欢暴力数据结构，于是我就用莫队+分块过了这个题

Solution

Code

Summary

我爱暴力数据结构！

最新文章

热门文章

【莫队】【P3834】【模板】可持久化线段树 1（主席树）