BestCoder,57,Desiderium，求期望类题目

题意：

给出一个集合，这个集合由n个线段区间组成，线段与线段间可以重合相交，现在让你从中取一个子集，求由这个子集中，构成线段的长度的期望。

期望值，最后乘以2^n，并对10^9+7取模，然后输出结果。

范围：

n<10^5，线段范围：-10^9<=l,r<=10^9

分析：

这种期望类题目，一般是将问题拆解到小的因子上，求每个线段被取得的概率，然后乘以线段的长度，即为该线段被取得的期望值，最后将所有线段的期望值相加，即为整个问题的期望值。

因为坐标范围太大，所以需要离散化处理。然后去找一个个相互独立的线段，根据总体期望=各部分期望求和，获得最后的解。

具体代码：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
using namespace std;
#define N 100002
typedef long long LL;
#define aa frist
#define bb second
#define mod 1000000007
int n,t;
struct seg
{
    LL len,num;
}s[5*N];

struct no
{
    LL x,f;
}node[2*N];
bool tmp(no a,no b)
{
    if(a.x==b.x) return a.f<b.f;
    else return a.x<b.x;
}
LL f[N];
void make()
{
    f[0]=(LL)1;
    for(int i=1;i<N;i++) f[i]=f[i-1]*2%mod;
}
int main()
{
    make();
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        LL ans=0;
        for(int i=0;i<n;i++)
        {
            LL lx,rx;
            scanf("%I64d%I64d",&lx,&rx);
            node[2*i].x=lx;
            node[2*i].f=-1;
            node[2*i+1].x=rx;
            node[2*i+1].f=1;
//            ans=(ans+(rx-lx)*f[n-1]%mod)%mod;
//            s[i].len=s[i].r-s[i].l+1;
        }
        sort(node,node+2*n,tmp);
//        sort(s,s+n,cmp);
        LL now=1;
        int cnt=0;
        for(int i=1;i<2*n;i++)
        {
            if(now>0)
            {
                s[cnt].len=node[i].x-node[i-1].x;
//                s[cnt].r=node[i].x;
                s[cnt].num=now;
                cnt++;
            }
            if(node[i].f==1)
            {
                now--;
            }
            else now++;
        }
        for(int i=0;i<cnt;i++)
        {
            ans=(ans+s[i].len*(f[n]-f[n-s[i].num])%mod)%mod;
        }
        ans=(ans+mod)%mod;
        printf("%I64d\n",ans);
    }
    return 0;
}
/*
10
1
0 1
2
0 2
1 3
3
0 3
1 5
2 6

*/