bzoj 3600 zkw线段树+替罪羊树

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
using namespace std;
struct node
{
	unsigned long long rank, rankl, rankr;
	int son[2];
	node()
	{
		son[0] = son[1] = 0;
	}
	int size;
	int numl, numr;
};
struct segnode
{
	int value;
	int pos;
};
int n, m;
int segnum;
segnode segtree[650000];
node tree[400000];
unsigned long long inf = 9223372036854775808;
double alpha = 0.75;
int *first;
unsigned long long rebuildl, rebuildr;

int pos[400000];
int tot = 1;
int stack[400000];
int top, root;
//void travel(int num, string s)
//{
	//if (tree[num].son[0])
	//	travel(tree[num].son[0], s + "左 ");
//	cout << s << " " << "num:" << num << " " << "rank:" << tree[num].rank << " " << "rankl:" << tree[num].rankl << " " << "rankr:" << tree[num].rankr << " " << "size:" << tree[num].size << endl;
	///if (tree[num].son[1])
	//	travel(tree[num].son[1], s + "右 ");
//}
void update(int k)
{
	int lson = segtree[k * 2].pos;
	int rson = segtree[k * 2 + 1].pos;
	if (((tree[lson].rank == tree[rson].rank) && (segtree[2 * k].value <segtree[2 * k + 1].value)) || (tree[segtree[k * 2].pos].rank>tree[segtree[k * 2 + 1].pos].rank))
	{
		segtree[k].value = segtree[k * 2].value;
		segtree[k].pos = segtree[2 * k].pos;
	}
	else
	{
		segtree[k].value = segtree[k * 2 + 1].value;
		segtree[k].pos = segtree[2 * k + 1].pos;
	}
}
bool operator >(node a, node b)
{
	return (tree[a.numl].rank > tree[b.numl].rank) || ((tree[a.numl].rank == tree[b.numl].rank) && (tree[a.numr].rank>tree[b.numr].rank));
}
bool operator ==(node a, node b)
{
	return (tree[a.numl].rank == tree[b.numl].rank) && (tree[a.numr].rank == tree[b.numr].rank);
}
int insert(int &num, node d, unsigned long long  rankl, unsigned long long rankr)
{
	unsigned long long mid = (rankl + rankr) / 2;
	if (num == 0)
	{
		num = tot++;
		tree[num] = d; tree[num].rankl = rankl; tree[num].rankr = rankr;
		tree[num].rank = (rankl + rankr) / 2;
		return num;
	}
	if (tree[num] == d)
		return num;
	int k;
	//tree[num].size++;
	if (tree[num] > d)
		k = insert(tree[num].son[0], d, rankl, mid - 1);
	else
		k = insert(tree[num].son[1], d, mid + 1, rankr);
	tree[num].size = tree[tree[num].son[0]].size + tree[tree[num].son[1]].size+1;
	if ((tree[num].size*alpha <= max(tree[tree[num].son[1]].size, tree[tree[num].son[0]].size)*1.0))
	{
		first = # rebuildl = rankl; rebuildr = rankr;
	}
	return k;
}
void get(int num)
{
	if (tree[num].son[0])
		get(tree[num].son[0]);
	stack[top++] = num;
	if (tree[num].son[1])
		get(tree[num].son[1]);
	tree[num].son[0] = 0; tree[num].son[1]=0;
}
void rebuild(int &num, unsigned long long  rankl, unsigned long long rankr, int l, int r)
{
	unsigned long long rankmid = (rankl + rankr) / 2;
	int mid = (l + r) / 2;
	num = stack[mid];
	tree[num].rank = rankmid; tree[num].rankl = rankl; tree[num].rankr = rankr;//这里rebuild 的顺序特别有讲究你只能预先支付最多一层把这句话写中间就错。
	if (l <= mid - 1)
		rebuild(tree[num].son[0], rankl, rankmid - 1, l, mid - 1);
	if (mid+1<=r)
	rebuild(tree[num].son[1], rankmid + 1, rankr, mid + 1, r);
	tree[num].size = tree[tree[num].son[0]].size + tree[tree[num].son[1]].size + 1;
}
int ins(int nodel, int noder)
{
	node d;
	d.numl = segtree[nodel + segnum].pos; d.numr = segtree[noder + segnum].pos; d.size = 1;
	first = 0;
	int numberr = insert(root, d, 1, inf);
	if (first != 0)
	{
		top = 0;
		get(*first);
		rebuild(*first, rebuildl, rebuildr, 0, top - 1);
	}
	if (!root)root = numberr;
	return numberr;
}
void init()
{

	for (segnum = 1; segnum <= n + 2; segnum *= 2);
	segtree[segnum].pos = 0; segtree[segnum].value = 1000000000;
	for (int i = 1; i <= n; i++)
	{
		segtree[i + segnum].pos = 0; segtree[i + segnum].value = i;
	}
	for (int i = n + segnum + 1; i < 2 * segnum; i++)
		segtree[i].pos = 0, segtree[i].value = 1000000000;
	for (int i = segnum - 1; i >= 1; i--)
		update(i);
}
void change(int l, int r, int pos)
{
	segtree[pos + segnum].pos = ins(l, r);//注意我的线段树是从0开始的
	for (int i = (pos + segnum) >> 1; i >= 1; i = i >> 1)
	{
		update(i);
	}
}
int find(int l, int r)
{
	l -= 1; r += 1;
	l += segnum; r += segnum;
	segnode d;
	d.pos = 0; d.value = 1000000000;
	for (; l^r ^ 1; l = l >> 1, r = r >> 1)
	{
		if ((~l & 1) && ((tree[d.pos].rank<tree[segtree[l ^ 1].pos].rank) || ((tree[d.pos].rank == tree[segtree[l ^ 1].pos].rank) && (d.value>segtree[l ^ 1].value))))
		{
			d.value = segtree[l ^ 1].value;
			d.pos = segtree[l ^ 1].pos;
		}
		if ((r & 1) && ((tree[d.pos].rank<tree[segtree[r ^ 1].pos].rank) || ((tree[d.pos].rank == tree[segtree[r ^ 1].pos].rank) && (d.value>segtree[r ^ 1].value))))
		{
			d.value = segtree[r ^ 1].value;
			d.pos = segtree[r ^ 1].pos;
		}
	}
	return d.value;
}
int main()
{
	scanf("%d%d", &n, &m);
	init();
	while (m--)
	{
		getchar();
		char d;
		scanf("%c", &d);
		//cout << d << endl;
		if (d == 'C')
		{
			int a, b, c;
			scanf("%d%d%d", &a, &b, &c);
			//cout << a << " " << b << " " << c << endl;
			change(a, b, c);
		}
		else
		{
			int a, b;
			scanf("%d%d", &a, &b);
			printf("%d\n", find(a, b));
		}
	}

}

为了写得与众不同和写得好看点写了个zkw+替罪羊。。。。。

那什么是替罪羊呢？其实就相当于这样。每天我们都要到垃圾吧，你每次扔垃圾是愿意把垃圾放垃圾桶里等垃圾桶满了,再到垃圾场仍垃圾,还是愿意每次都跑很远到垃圾场然后扔垃圾呢，答案显而易见，替罪羊就是基于此原理啦，至于细致的复杂度分析其实是不用了解的，感觉没什么用。。。算法导论看完自然就懂了。还有一定要在最后一个不平衡点重构。这就好像你是愿意垃圾桶里一有垃圾你就仍呢，还是等垃圾桶满了你再仍垃圾。