• 【莫队】【P3834】 【模板】可持久化线段树 1(主席树)


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

    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], '
    ', 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]]];
    }
    

    Summary

    我爱暴力数据结构!

  • 相关阅读:
    输入法searchLookUpEditd的使用
    DevExpress GridControl使用方法总结
    DevExpress 控件中GridControl的使用
    MSSQl 事务的使用
    Python class NameError name "xxx" is not defined
    win 10 slmgr.vbs -xpr 无法运行,被豆麦笔记打开解决方法
    git checkout 撤销多个文件,撤销整个文件夹
    Python argparse 模块,参数传递
    Python Enum 枚举 用法汇总
    git branch & checkout fetch 的使用和冲突解决
  • 原文地址:https://www.cnblogs.com/yifusuyi/p/10046532.html
Copyright © 2020-2023  润新知