时间分治（cdq分治）



        搞了半天才发现时间分治和cdq分治是一个东西……

        当对于一个操作的静态操作较简单，动态操作较复杂，并且后面对前面没有影响，还有操作序列可以合并（前提真的很多，还有看你能不能想出来），我们可以使用时间分治。

        以归并排序举例，归并排序的代码如下：

void MergeSort(int l,int r)
{
	if (l == r) return;
	int mid = (l+r)/2;
	MergeSort(l,mid);
	MergeSort(mid+1,r);
	inplace_sort(a+l,a+mid+1,a+r+1);
}

（虽然好像inplace_sort就是归并排序啊233）

        将归并排序操作的序列想象成一个操作序列，很明显，归并排序满足一下几点性质

        1.区间可以合并

        2.前面的序列与后面无关

        于是时间复杂度 T(n) = 2*T(n/2)+O(n)（合并的代价，对于实际问题就是静态操作的代价）

        根据主算法， T(n) = n logn

（其实我也没完全搞懂，关于区间合并这一块事实上难度是很大的，如HNOI city 城市建设，各种缩点乱搞）

        那么，时间分治作用事实上就是一个替代品，跟主席树一样强大的替代品，它可以解决许多需要树套树的问题，甚至可以解决一些范围极大的问题

（上一道水题理解一下）

BZOJ 1176

        给定一个初值相同的矩阵，有两个操作

        （1）1 x y delta 给(x,y)加上delta

        （2）2 x1 y1 x2 y2 求矩形内的和

        其中w <= 2000000,q<=160000,m<=10000

        经典线段树套线段树，不对好像范围有点大……二维线段树早就不知道MLE到哪里去了

        于是我们便想到了时间分治，我们将[x1,y1],[x2,y2]差分成四个和

        以x为第一关键字，y为第二关键字，再用树状数组维护一下就ok了（具体细节参考代码）

#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXW = 2000001;
const int MAXN = 200000;

struct Node
{
	int x,y,delta,flag,idx;
	bool operator < (const Node &rhs) const
	{
		return x < rhs.x || (x == rhs.x && y < rhs.y); 
	}
};

int s,w,cnt,cntq;
int ans[MAXN];
Node C[MAXN];

int c[MAXW];

void modify(int pos,int delta)
{
	for (int i=pos;i<=w;i+=(i&-i)) c[i] += delta; 
}

int query(int pos)
{
	int ans = 0;
	for (int i=pos;i>0;i-=(i&-i)) ans += c[i];
	return ans;
}

void solve(int l,int r)
{
	if (l == r) return;
	int mid = (l+r)/2;
	solve(l,mid);
	solve(mid+1,r);
	int j = l;
	for (int i=mid+1;i<=r;i++)
	{
		if (C[i].flag == 2)
		{
			for ( ;j<=mid && C[j].x <= C[i].x;j++)
			    if (C[j].flag == 1) modify(C[j].y,C[j].delta);
			ans[C[i].idx] += query(C[i].y)*C[i].delta;
		}
	}
	for (int i=l;i<j;i++) if (C[i].flag == 1) modify(C[i].y,-C[i].delta);
	inplace_merge(C+l,C+mid+1,C+r+1);
}

int main()
{
	scanf("%d%d",&s,&w);
	int oper;
	while (scanf("%d",&oper) == 1 && oper != 3)
	{
		if (oper == 1)
		{
			int x,y,delta;
			scanf("%d%d%d",&x,&y,&delta);
			C[++cnt] = (Node){x,y,delta,1,cnt};
		}
		else
		{
			int x1,y1,x2,y2;
			scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
			cntq++;
			C[++cnt] = (Node){x1-1,y1-1,1,2,cntq};
			C[++cnt] = (Node){x1-1,y2,-1,2,cntq};
			C[++cnt] = (Node){x2,y1-1,-1,2,cntq};
			C[++cnt] = (Node){x2,y2,1,2,cntq};
			ans[cntq] = (x2-x1+1)*(y2-y1+1)*s;
		}
	}
	solve(1,cnt);
	for (int i=1;i<=cntq;i++) printf("%d\n",ans[i]);
	return 0;
}

        还有那些比较复杂的区间合并，例如cf最近那题动态割边什么的……以后再说吧