主席树

参考资料：
http://blog.csdn.net/metalseed/article/details/8045038
http://www.cnblogs.com/oyking/p/3230296.html
可持久化的线段树 - 包括函数式线段树实现方法 其中著名的有第一类主席树和第二类主席树
前缀和主席树套一个树状数组或者直接用树状数组add每个点就得到第二类主席树
第一类主席树可以解决区间k小问题，时间复杂度为单次logn一共(n+q)log(n) 空间复杂度为 nlogn
第二类主席树可以解决带修改的区间k小问题，时间复杂度为单次lognlogn 共nlogn+qlognlogn 或者不用前缀和 (n+q)lognlogn 空间复杂度为 qlognlogn 或者不用前缀和 (q+n)logn*logn 用垃圾回收重复利用空间可以 去掉一个logn的空间 nlogn 因为树状数组没有必要在修改之后再用修改之前的总共就只要开nlogn的空间因为c数组n个就可以了每个一条顶到叶子的链logn的空间，可以直接使用或者回收利用（并不能减少。。。0 0）
这里的单科线段树总节点数直接用n表示了，n和tot一个量级
区间k小，线段树的每个节点统计的是每个rank值的数量
前缀和代表的前缀1-i添加了前i个点的线段树
第i棵树可以利用到第i-1棵，因为差的就是接下来要插入的i点的rank值，只会有一条顶到底的链节点值不同前一个，所以不用建出所有完整的线段树，每颗前缀和的树只会增加logn节点，其它的利用以前节点，共nlogn空间
关键，巧妙是因为每棵树的形态都是一样的，范围也是一样的，可以直接利用以前，又可以直接加减，所以树状数组也能利用
求k小就是看左孩子数量是不是>=k 是走左边不是走右边
主席树是离线的，因为要看查询和修改里的值，把对应值离散化到n个点的值里来，另外划分树和离线区间分治也能解决区间k小问题

看了下离线区间分治，因为离线，每个排名都确定了，把修改操作分成两份某个点数量-1，某个点数量+1,初始化操作算某个点数量+1，然后算对左边区间和右边区间的贡献，先只算左边区间右边分治递归，把当前每次查询操作排名<=mid的贡献算出来，然后判断与每次查询的值比较如果>=k这个查询就划分到左边也就是【l，mid】的排名里，否则划分到右边【mid+1，r】排名里，划分到右边的累计一下左边【l,mid】的贡献值，修改操作直接看目标rank点在哪边继续划分到左右，然后分治递归，最后哪些查询操作在l==r里，把对应答案索引记录一下就行了。因为有修改，要计算某次查询的贡献还是要用到树状数组，修改算贡献的时候判断一下rank<=mid，才处理add就行了，算完每次查询贡献保存临时值后，要把树状数组还原回去，感觉清掉也行，以便之后分治继续使用。。。（好吧其实这就是划分树）
附一下zoj2112的划分树方法链接：
http://www.cnblogs.com/chanme/p/4493455.html

hdu 4010 第一类主席树 这个是求区间中数值小于h的有多少个的，用了map还是咋回事要c++交，g++跪

#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
#include <set>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 10007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-12;
const int N = 100005 + 5;
const int M = 100005;

#pre sum president tree

int n, m, d;
int a[N];
int rnk[N];
int root[N];
int sz = 0;
struct Node {
	int sum;
	int ch[2];
}T[N * 30];
void insert(int &num, int k, int l, int r) {
	++sz;
	T[sz] = T[num]; num = sz;
	T[num].sum++;
	if (l == r) {
		return;
	}
	int m = (l + r) >> 1;
	if (k <= m) {
		insert(T[num].ch[0], k, l, m);
	}
	else {
		insert(T[num].ch[1], k, m + 1, r);
	}
}
int query(int i, int j, int k, int l, int r) {
	if (r <= k)
		return T[j].sum - T[i].sum;
	if (l > k) return 0;
	int m = (l + r) >> 1;
	return query(T[i].ch[0], T[j].ch[0], k, l, m) + query(T[i].ch[1], T[j].ch[1], k, m + 1, r);

}
struct Seg {
	int l, r, h;
}q[N];
int val[N * 5];
int cnt = 0;
map<int, int> mp;
int main() {
	int t;
	scanf("%d", &t);
	for (int x = 1; x <= t; x++) {
		for (int i = 0; i <= sz; i++)T[i].ch[0] = T[i].ch[1] = T[i].sum = 0;
		cnt = 0;
		sz = 0;
		mp.clear();

		scanf("%d%d", &n, &m);

		for (int i = 1; i <= n; i++) {
			scanf("%d", &a[i]);
			val[cnt++] = a[i];
		}
		for (int i = 0; i < m; i++) {
			int l, r, h;
			scanf("%d%d%d", &l, &r, &h);
			q[i].l = l;
			q[i].r = r;
			q[i].h = h;
			val[cnt++] = h;
		}
		sort(val, val + cnt);
		int tot = 0;
		rnk[0] = ++tot;
		for (int i = 1; i < cnt; i++) {
			if (val[i] != val[i - 1])
				rnk[i] = ++tot;
			else
				rnk[i] = tot;
		}
		for (int i = 0; i<cnt; i++)
			mp[val[i]] = rnk[i];
		root[0] = 0;
		for (int i = 1; i <= n; i++) {
			root[i] = root[i - 1];
			insert(root[i], mp[a[i]], 1, tot);
		}
		printf("Case %d:
", x);
		for (int i = 0; i < m; i++) {
			printf("%d
", query(root[q[i].l], root[q[i].r + 1], mp[q[i].h], 1, tot));
		}
	}
	return 0;
}

zoj 2112 把map改成了2分的方法才过了，这里map占内存不小，另外发现垃圾回收或者重复利用并不能绝对减少空间，每次走的路径并不以一定相同。。。这里好像不重复利用也不递归插入都可以过。。。map坑啊。。。
zoj 2112 第二类主席树 这里函数式的思想，我就当它是打了个Pack包，可以进行+=了以及包装了lt() rt() 和强转 int 或者说把线段树的根节点当成树状数组的每个节点来用 树状数组的用法就像个函数？瞎比比

#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
#include <set>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 10007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-12;
const int N = 60005 + 5;
const int M = 10005;

int n, m, d;
int a[50005];
int rnk[N];
int root[N];
int croot[N];
int sz = 0, tot = 0;
void insert(int &num, int val, int k, int l, int r);
struct Node {
	int sum;
	int ch[2];
}T[2500010];
void insert(int &num, int val, int k, int l, int r,int flag) {
	if (flag==0||num==0) {
		T[++sz] = T[num]; num = sz;
	}
	T[num].sum += val;
	if (l == r) {
		return;
	}
	int m = (l + r) >> 1;
	if (k <= m) {
		insert(T[num].ch[0], val, k, l, m, flag);
	}
	else {
		insert(T[num].ch[1], val, k, m + 1, r, flag);
	}
}
//int insert(int &num, int val, int k, int l, int r, int flag) {
//	if (flag == 0 || num == 0) {
//		T[++sz] = T[num]; num = sz;
//	}
//	T[num].sum += val;
//	int x = num;
//	while (l < r) {
//		int mid = (l + r) >> 1;
//		if (k <= mid) {
//			int y = x;
//			x = T[x].ch[0];
//			if (flag == 0 || x == 0) {
//				T[++sz] = T[x];
//				x = sz;
//			}
//			T[x].sum += val;
//			T[y].ch[0] = x;
//			r = mid;
//		}
//		else {
//			int y = x;
//			x = T[x].ch[1];
//			if (flag == 0 || x == 0) {
//				T[++sz] = T[x];
//				x = sz;
//			}
//			T[x].sum += val;
//			T[y].ch[1] = x;
//			l = mid + 1;
//		}
//	}
//	return num;
//}
int query(int i, int j, int k, int l, int r) {
	if (k > T[j].sum - T[i].sum)
		k = T[i].sum - T[i].sum;
	if (l == r)
		return l;
	int m = (l + r) >> 1;
	if (k <= T[T[j].ch[0]].sum - T[T[i].ch[0]].sum)
		return query(T[i].ch[0], T[j].ch[0], k, l, m);
	else
		return query(T[i].ch[1], T[j].ch[1], k - (T[T[j].ch[0]].sum - T[T[i].ch[0]].sum), m + 1, r);
}
void add(int x, int num, int d) {
	while (x <= tot) {
		insert(croot[x], d, num, 1, tot,1);
		x += x&-x;
	}
}
struct Pack {
	vector<int> v;
	Pack() {}
	Pack(int x) { v.push_back(x); }
	void operator +=(int x) {
		v.push_back(x);
	}
	operator int()const {//得到左孩子和
		int ret = 0;
		for(int i=0;i<v.size();i++)
			ret += T[T[v[i]].ch[0]].sum;
		return ret;
	}
	void lt() {
		for (int i = 0; i < v.size(); i++)
			v[i] = T[v[i]].ch[0];
	}
	void rt() {
		for (int i = 0; i < v.size(); i++)
			v[i] = T[v[i]].ch[1];
	}
};
Pack sum(int x, int k) {
	Pack ret;
	while (x>0) {
		ret += croot[x];
		x -= x&-x;
	}
	return ret;
}
int binSearch(int l, int r, int k) {
	Pack treesl = sum(l, k);
	Pack treesr = sum(r, k);
	Pack presl = Pack(root[l]);
	Pack presr = Pack(root[r]);
	int xl = 1, xr = tot;
	while (xl<xr) {
		int mid = (xl + xr) >> 1;
		int t = treesr - treesl + presr - presl;
		if (t < k) {
			treesr.rt(); treesl.rt(); presr.rt(); presl.rt();
			k -= t;
			xl = mid + 1;
		}
		else {
			treesr.lt(); treesl.lt(); presr.lt(); presl.lt();
			xr = mid;
		}
	}
	return xl;
}
struct Seg {
	int l, r, h, x;
}q[M];
int val[N];
int cnt = 0;
//map<int, int> mp;
int Hash(int x) {
	return lower_bound(val, val + tot, x) - val+1;
}
int main() {
	int t;
	scanf("%d", &t);
	for (int x = 1; x <= t; x++) {
		for (int i = 0; i <= sz; i++)T[i] = T[0];
		cnt = 0;
		sz = 0;
		tot = 0;
		//mp.clear();

		scanf("%d%d", &n, &m);

		for (int i = 1; i <= n; i++) {
			scanf("%d", &a[i]);
			val[cnt++] = a[i];
		}
		for (int i = 0; i < m; i++) {
			char op[2];
			scanf("%s", op);
			if (op[0] == 'Q') {
				int l, r, h;
				scanf("%d%d%d", &l, &r, &h);
				q[i].l = l;
				q[i].r = r;
				q[i].h = h;
				if (l<1||r>n||l>r||h<1 || h>r - l + 1)
					assert(false);
			}
			else {
				int x, h;
				scanf("%d%d", &x, &h);
				q[i].x = x;
				q[i].h = h;
				val[cnt++] = h;
				q[i].l = -inf;
			}
		}
		sort(val, val + cnt);
		rnk[0] = ++tot;
		for (int i = 1; i < cnt; i++) {
			if (val[i] != val[i - 1])
				rnk[i] = ++tot;
			else
				rnk[i] = tot;
		}
		for (int i = 0; i <= tot; i++)croot[i] = 0;
		unique(val, val + cnt);
		/*for (int i = 0; i<cnt; i++)
			mp[val[i]] = rnk[i];*/
		root[0] = 0;
		for (int i = 1; i <= n; i++) {
			root[i] = root[i - 1];
			insert(root[i], 1, Hash(a[i]), 1, tot, 0);
		}
		for (int i = 0; i < m; i++) {
			if (q[i].l!=-inf) {
				printf("%d
", val[binSearch(q[i].l - 1, q[i].r, q[i].h) - 1]);
				//printf("%d
", query(root[q[i].l], root[q[i].r + 1], mp[q[i].h], 1, tot));
			}
			else {
				add(q[i].x, Hash(a[q[i].x]), -1);
				a[q[i].x] = q[i].h;
				add(q[i].x, Hash(q[i].h), 1);
			}
		}
		for (int i = 1; i <= tot; i++)
			croot[i] = 0, val[i] = 0, a[i] = 0;
	}
	return 0;
}