两次的覆盖不仅仅单独的改变cnt的判断条件
而是要进行讨论，尽管现在只有1层标记或者没有标记 仍然可能对当前做出贡献
也就是：
分情况讨论
1.cnt>1 : 说明该区间被覆盖两次或以上，那么长度就可以直接计算，就是该区间的长度，剩下的情况就是cnt=1或cnt=0
2.先看叶子节点，因为是叶子没有孩子了，所以被覆盖两次货以上的长度就是0（无论cnt=1或cnt=0都是0，因为是叶子。。。）
3.不是叶子节点 ，且cnt=1.注意这里，cnt=1确切的意义是什么，应该是，可以确定，这个区间被完全覆盖了1次，而有没有被完全覆盖两次或以上则不知道无法确定，那么怎么怎么办了，只要加上t[lch].s + t[rch].s 即，看看左右孩子区间被覆盖了一次或以上的长度，那么叠加在双亲上就是双亲被覆盖两次或以上的长度
3.不是叶子节点，且cnt=0，确切的意义应该是不完全不知道被覆盖的情况（不知道有没有被覆盖，被覆盖了几次，长度是多少都不知道），这种情况，只能由其左右孩子的信息所得
t[lch].ss + t[rch].ss , 即直接将左右孩子给覆盖了两次或以上的长度加起来，这样才能做到不重不漏
转自https://www.cnblogs.com/scau20110726/archive/2013/04/14/3020998.html

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int MAXN = 1e5+7;
struct node
{
    
    
	double l,r,h;
	int f;//l线段左端点 r右端点 h高度 f标记当前这条线段是矩形的上边界还是下边界
}line[MAXN];
double lsh[MAXN];
double tree[MAXN][3];
int ct[MAXN];
int n;
bool cmp(node a,node b){
    
    
	return a.h < b.h;
}
//如果单纯的 只考虑 ct>1的情况 会漏掉很多面积 要分类讨论才不会少
// 通过分类讨论的思想也就可以类似的求 三次 四次的面积 都是可以推得的
void pushup(int rt,int l,int r)
{
    
    
	// 先把一次的更新了
	if(ct[rt]) tree[rt][1] = lsh[r+1]-lsh[l];
	else if(l == r) tree[rt][1] = 0;
	else tree[rt][1] = tree[rt<<1][1]+tree[rt<<1|1][1];
	//再更新两次的
	if(ct[rt]>1) tree[rt][2] = tree[rt][1];
	else if(l == r) tree[rt][2] = 0;
	else if(ct[rt] == 1) tree[rt][2] = tree[rt<<1][1]+tree[rt<<1|1][1];// 当前只覆盖一次 但之前的子孙可能被完全覆盖过 加起来刚好两次
	else tree[rt][2] = tree[rt<<1][2]+tree[rt<<1|1][2];
}

void build(int rt,int l,int r)
{
    
    
	tree[rt][1] = tree[rt][2] = 0;
	ct[rt] = 0;
	if(l == r) return ;
	int mid = (l+r)>>1;
	build(rt<<1,l,mid);
	build(rt<<1|1,mid+1,r);
}

void update(int rt,int l,int r,int ul,int ur,int x)
{
    
    
	if(l>=ul&&r<=ur){
    
    
		ct[rt] += x;
		pushup(rt,l,r);//覆盖标记发生了变化 因此需要 下推一下 重新复值
		return ;
	}
	int mid = (l+r)>>1;
	if(ul <= mid) update(rt<<1,l,mid,ul,ur,x);
	if(ur > mid) update(rt<<1|1,mid+1,r,ul,ur,x);
	pushup(rt,l,r);
}

int main()
{
    
    
	int cas = 0;
	int t;
	scanf("%d",&t);
	double x1,x2,y1,y2;
	while(t--){
    
    
		int n;
		scanf("%d",&n);
		int cnt = 0;
		for(int i = 1;i <= n;i ++){
    
    
			scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
			lsh[++cnt] = x1;//因为坐标会有小数 所以需要离散化 才能用线段树维护
			line[cnt].l = x1;
			line[cnt].r = x2;
			line[cnt].h = y1;
			line[cnt].f = 1;//因为要从下往上扫 所以把下面的当做1
			lsh[++cnt] = x2;
			line[cnt].l = x1;
			line[cnt].r = x2;
			line[cnt].h = y2;
			line[cnt].f = -1;
		}
		sort(lsh+1,lsh+cnt+1);
		sort(line+1,line+cnt+1,cmp);
		int num = unique(lsh+1,lsh+1+cnt)-lsh-1;
		//printf("%d\n",num);
		build(1,1,num);
		double ans = 0;
		for(int i = 1;i <= cnt;i ++){
    
    
			int l = lower_bound(lsh+1,lsh+1+num,line[i].l)-lsh;
			int r = lower_bound(lsh+1,lsh+1+num,line[i].r)-lsh-1;
			//printf("%d %d\n",l,r);
			update(1,1,num,l,r,line[i].f);
			ans += tree[1][2]*(line[i+1].h-line[i].h);// tree[1]代表走到当前节点 被覆盖的区间的总长度为多少
		}
		printf("%.2f\n",ans);
	}
	return 0;
}