扫描线+离散化+线段树
给出题目！
题目界面
那么，大家一看一般是一脸蒙蔽
因为这确实听***钻，许多人不会打二维线段树，却一直在想线段树怎么打，可悲（大佬：花了5分钟打出二维线段树，好难！），那摸，大家，这道题怎么做？
接下来会涉及到离散化与线段树，请自学，抱歉⊙﹏⊙
那么，这道题呢，重要的是扫描线（如图）：
那一根根蓝或红线就叫线（矩阵左右的线为红，上下为蓝，为什么这样分色，后面讲），每根线其实都是某个矩阵上的一条边。（注意，扫描线比较适合用于在矩阵的每条边严格与X轴或Y轴平行或重合的矩阵问题上）
现在，把与X轴平行的线和与Y轴平行分开来。
同时，我们
规定，代表矩阵下面和左边的边，为入边，这些线权值为1，同时规定矩阵上面和右边的边，为出边，这些线权值为-1，那么代表一个矩阵的四根线权值加起来就为1了！
那么，我们再定一条更厉害的动态线，叫扫描线，我们每次只用扫描线处理一种颜色的线，先扫红色：
这条扫描线上也被Y坐标分成一个个小格，每个格子一开始值为0。
每经过一条红线，就将这条红线与扫描线重叠部分加上这条线的权值。
如图：
现在，前面的权值就有用了（扫描线全部扫完后身上所有的格的值都为0）
当扫描线扫过出边的时候，就把入边的值给抵消了！
然后在将蓝线扫一遍就可以将全局的线用两次扫描就扫完了！
那么，怎么统计答案呢？
暴力的话只需要统计当这个格子里加为1和减为0的时，给答案加上这个格子离散前的长度（离散后长度为1）。（想想为什么，很关键！）
但是，这样暴力仍然为O（n^2）
于是，我们用线段树让他变为O（nlogn）
许多人就开始想lazy使时间变短，但是，其实，根本没有lazy，只不过统计答案的方式与暴力不同而已！
给出代码（离散化可以根据个人爱好改变）：
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int cc=300000;//范围
struct ndoe
{
int l,r,lc,rc,c,ss;//ss代表当前这个范围被完整覆盖了几次
}a[cc];int len;//线段树
struct caozuo
{
int x,l,r,k;//l与r为范围，k为权值，x为用于排列的坐标
}tot1[cc],tot2[cc];//记录线的信息，tot1为蓝线,tot2为红线
struct LSnode
{
int x,y;
}A[cc],B[cc];//离散值
int n,kk1,kk2,ys1[cc],ys2[cc];
//ys1[i]代表离散后编号为i的点与离散后编号为0的点离散前的长度是多少？ys2也一样。
bool cmp1(LSnode x,LSnode y){return x.x<y.x;}//离散化的排列
bool cmp2(caozuo x,caozuo y){return x.x!=y.x?x.x<y.x:x.k>y.k;}//将线按顺序排起来，一个个改变扫描线的值，来模拟扫描线扫过去的场景
void bt(int l,int r)
{
len++;int now=len;
a[now].l=l;a[now].r=r;a[now].c=a[now].lc=a[now].rc=0;
if(l+1<r)//因为扫描线上每个格子长度为1，只有大于1才可以申请左右儿子来帮忙
{
int mid=(l+r)/2;
a[now].lc=len+1;bt(l,mid);
a[now].rc=len+1;bt(mid,r);//左儿子与右儿子
}
}//建树
void update(int x)
{
if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
else a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
}//统计答案的重点，注意，不用+=
void change(int now,int l,int r,int k)
{
if(a[now].l==l && a[now].r==r){a[now].ss+=k;update(now);return ;}//完全覆盖直接统计
int lc=a[now].lc,rc=a[now].rc,mid=(a[now].l+a[now].r)/2;
if(r<=mid)change(lc,l,r,k);
else if(mid<=l)change(rc,l,r,k);
else change(lc,l,mid,k),change(rc,mid,r,k);//否则只能扔给左右儿子处理
//因为mid代表的坐标的是，所以不需要加一
update(now);//统计
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d%d%d%d",&A[i*2-1].x,&B[i*2-1].x,&A[i*2].x,&B[i*2].x);
tot1[i*2-1].x=B[i*2-1].x;tot1[i*2].x=B[i*2].x;
tot2[i*2-1].x=A[i*2-1].x;tot2[i*2].x=A[i*2].x;//给每条线的坐标(为什么只给一个，因为另外的一个坐标是当作范围来用的)
tot1[i*2-1].k=tot2[i*2-1].k=1;tot1[i*2].k=tot2[i*2].k=-1;//出边与入边
A[i*2-1].y=B[i*2-1].y=i*2-1;A[i*2].y=B[i*2].y=i*2;//离散化，A为tot1离散范围，B为tot2离散。
}
sort(A+1,A+n*2+1,cmp1);sort(B+1,B+n*2+1,cmp1);//排序
A[0].x=A[1].x-1,B[0].x=B[1].x-1;
for(int i=1;i<=n*2;i++)
{
if(A[i].x!=A[i-1].x)
{
kk1++;
ys1[kk1]=ys1[kk1-1]+A[i].x-A[i-1].x;
}
if(B[i].x!=B[i-1].x)
{
kk2++;
ys2[kk2]=ys2[kk2-1]+B[i].x-B[i-1].x;//前缀和方便后面处理
}
int kkk_c1=A[i].y,kkk_c2=B[i].y;//分清这是范围内的l还是r
if(kkk_c1%2==1)tot1[kkk_c1].l=tot1[kkk_c1+1].l=kk1;
else tot1[kkk_c1].r=tot1[kkk_c1-1].r=kk1;
if(kkk_c2%2==1)tot2[kkk_c2].l=tot2[kkk_c2+1].l=kk2;
else tot2[kkk_c2].r=tot2[kkk_c2-1].r=kk2;
}
sort(tot1+1,tot1+2*n+1,cmp2);sort(tot2+1,tot2+2*n+1,cmp2);//将线扫一遍
int ans=0,lastt=0;//关键！
len=0;bt(1,kk1);//建树
for(int i=1;i<=n*2;i++)
{
lastt=a[1].c;//统计上次的答案
if(tot1[i].l!=tot1[i].r)change(1,tot1[i].l,tot1[i].r,tot1[i].k);//扫蓝线
ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小，ans只记录这次该变了什么
}
for(int i=1;i<=kk2;i++)ys1[i]=ys2[i];//其实可以搞两颗线段时，为了简洁，只好这样
len=0;bt(1,kk2);//建树
for(int i=1;i<=n*2;i++)
{
lastt=a[1].c;//统计上次的答案
if(tot2[i].l!=tot2[i].r)change(1,tot2[i].l,tot2[i].r,tot2[i].k);//扫红线
ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小，ans只记录这次该变了什么
}
printf("%d\n",ans);//输出
return 0;
}
大家是不是对
void update(int x)
{
if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
else a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
}//统计答案的重点
——————————————————————————————————————————————————————————
int ans=0,lastt=0;//关键！
len=0;bt(1,kk1);//建树
for(int i=1;i<=n*2;i++)
{
lastt=a[1].c;//统计上次的答案
if(tot1[i].l!=tot1[i].r)change(1,tot1[i].l,tot1[i].r,tot1[i].k);//扫蓝线
ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小，ans只记录这次该变了什么
}
for(int i=1;i<=kk2;i++)ys1[i]=ys2[i];//其实可以搞两棵线段时，为了简洁，只好这样
len=0;bt(1,kk2);//建树
for(int i=1;i<=n*2;i++)
{
lastt=a[1].c;//统计上次的答案
if(tot2[i].l!=tot2[i].r)change(1,tot2[i].l,tot2[i].r,tot2[i].k);//扫红线
ans+=abs(a[1].c-lastt);//加个abs因为出边会使答案变小，ans只记录这次该变了什么
}
不理解？
线段树里的c代表这个线段树节点所管理的扫描线范围里有值的格子的长度（长度为离散前的长度）。
那么，如果父亲节点的ss!=0并且儿子节点的ss!=0，不就重复了吗，但是，我们仍然只算父亲节点的区间，因为他包括了儿子节点的范围，所以才加了个else。
因为有$$ans+=abs(a[1].c-lastt);$$这一句，和
void update(int x)
{
if(a[x].ss!=0)a[x].c=ys1[a[x].r]-ys1[a[x].l];//离散前的长度
else a[x].c=a[a[x].lc].c+a[a[x].rc].c;//不行就继承
}//统计答案的重点
所以，我们仔细观察能发现一下结论。
- 如果一个扫描线的区间多次经过入边，c值不变。
- 由于lastt记录了上一次的根节点的值，所以没变的c值不会被ans再次加入。
- 若某个扫描线的区间被出边更改为0，继承左右儿子的c值后，由于lastt值上一次几录了他是整个区间都被覆盖的c值，这一次利用abs可以加到这次操作中由有值被减为0的区间值。
- 一次更改中，所有区间不会出现那边减这边加的情况，顶多某个加，或某个减（线的权值要么为正，要么为服，所以会出现这种情况！）
- ss值一直为非负数！
那么，根据1跟2结论，重复计算不会出现，根据3跟4结论，出边也有可能有影响。
那么，大家会发现：
这张图上有一条出边与入边重合了，如果不判断的话可能会出现中间这一条线的长度被计算两次，那么我们将入边优先，出边靠后就可以解决了！
bool cmp2(caozuo x,caozuo y){return x.x!=y.x?x.x<y.x:x.k>y.k;}
//x值不一样按先后排序，不一样按出入边排序，但因为入边权值大于出边，所以可以这样写
由于计算这两条线的时候这个区间的ss值一直大于0，所以c值也不变，ans值也不会记录。
罗里吧嗦这么一大堆，那么这个为什么对？，因为ans只在某个区间的ss值在变化为0或1时记录答案，根本与暴力也是十分像的！
（ ·_·逃
