2019牛客多校第二场 J subarray

题目链接：https://ac.nowcoder.com/acm/contest/882/J

开场发现咖啡鸡过了，然后发现好像能做，然后用了树状数组2e7*logn，超时，过了20%，之后才去签H的到。

赛后看了一眼题解，发现因为是连续的，直接用数组，不用树状数组，改了一晚上一上午，答案错误，通过率从53%到76%到80%，然后就实在想不到错哪了，弃疗了。

牛逼网友链接：https://www.cnblogs.com/Yinku/p/11221494.html

除了那个统计区间然后判断连续的方式不一样，其他的都一样啊。。。。

//牛逼网友的J 
#include
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 10000000, MAXM = 1000000;

int l[MAXM + 5], r[MAXM + 5], f[MAXM + 5], g[MAXM + 5];
int sum[MAXN * 3 + 5], b[MAXN * 3 + 5], c[MAXN * 3 + 5];

int main() 
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d%d",&l[i],&r[i]);
    f[1]=r[1]-l[1]+1;
    //f[i]以i段右端点为结尾的能构造出的最大的前缀和
    for(int i=2;i<=n;i++)
        f[i]=max(0,f[i-1]-(l[i]-r[i-1]-1))+r[i]-l[i]+1;
    //0：以i-1段右端点结尾的能构造出的最大的前缀和都不足够跨过[i-1,i]之间的-1
    //f[i - 1] - (l[i] - r[i - 1] - 1)：跨过之后还剩下多少贡献给这段
    g[n]=r[n]-l[n]+1;
    //g[i]以i段左端点为开头的能构造出的最大的前缀和
    for(int i=n-1;i>=1;i--)
        g[i]=max(0,g[i+1]-(l[i+1]-r[i]-1))+r[i]-l[i]+1;
    //ERR1(f, n);
    //ERR1(g, n);
    int i=1,base=10000000;
    ll ans=0;
    while(i<=n) 
	{
        int j=i+1;
        while(j<=n && g[j]+f[j-1]>=l[j]-r[j - 1]-1) {
            //说明这个[j-1,j]之间的-1段可以因为两侧的f[j-1]和g[j]足够大而连接起来
            j++;
        }
        j--;
        //此时j是从i开始最远能够连接到的区间
        int left=max(0,l[i]-g[i]),right=min(1000000000-1,r[j]+f[j]);
        //left,right是至少会产生一个贡献的范围
        //ERR(left, right);
        int t=i,mi=INF,mx=0;
        sum[0]=0;
        for(int k=left;k<=right;k++) 
		{
            //统计这一整段可连接区间的前缀和
            if(k>=l[t] && k<=r[t])
                sum[k-left+1]=sum[k-left]+1;
            else
                sum[k-left+1]=sum[k-left]-1;
            if(k==r[t])
                t++;
            mi=min(mi,sum[k-left+1]+base);
            mx=max(mx,sum[k-left+1]+base);
            //b记录前缀和出现过的次数
            b[sum[k-left+1]+base]++;
        }
        //ERR1(sum, right);
        //b记录前缀和出现过的次数的后缀和
        for(int k=mx-1;k>=mi;k--)
            b[k]+=b[k+1];
        //包含最左侧点的贡献
        ans+=b[base+1];
        for(int k=left;k<=right;k++) {
            t=sum[k-left+1]+base;
            //t表示k位置sum的值
            //b[t+1]比t大的值的个数
            //c[t+1]比在k位置左侧的比t大的值的个数的lazy
            b[t+1]-=c[t+1]; //把lazy加上去
            c[t]+=c[t+1]+1; //lazy标记下移
            c[t+1] = 0; //清空lazy
            ans+=b[t+1];
        }
        for(int k=mi;k<=mx;k++)
            b[k]=0,c[k]=0;
        i=j+1;
    }
    printf("%lld", ans);
    return 0;
}

纪念一下思考了一晚上一上午的代码。通过率80.79%，答案错误

//错的
#include
#define maxl 1000010
#define maxm 40000010
 
using namespace std;
 
int n,mx;
long long ans;
struct seg
{
    int l,r;
}a[maxl];
int b[maxm];
 
inline void prework()
{
    mx=0;
    for(int i=1;i<=n;i++)
    {  
        scanf("%d%d",&a[i].l,&a[i].r);
        mx+=(a[i].r-a[i].l+1);
    }
    mx*=2;
    for(int i=1;i<=2*mx;i++)
        b[i]=0;
}
 
inline void mainwork()
{
    ans=0;
    int sum=mx,id;
	int l=maxl,r=-1;
    long long tmp;
    id=a[1].l-1;
    for(int i=id;i>=-1 && sum<=2*mx;i--)
    {
        b[sum]+=1;
        l=min(l,sum);
        r=max(r,sum);
		sum++;
    }
    a[n+1].l=1e9;
    tmp=0;sum=mx;
    bool flag=true;
    for(int i=1;i<=n;i++)
    { 	
        for(int j=a[i].l;j<=a[i].r;j++)
        {
            sum++;
            tmp+=b[sum-1];
            ans+=tmp;
            b[sum]++;
            l=min(l,sum);
            r=max(r,sum);
        }
        id=a[i].r+1;
        
        while(sum>1 && id=mx)
            	b[j]=1;
            else
            	b[j]=0;
            tmp=0;sum=mx;
			l=maxl;r=-1;
        }
    }
}
 
inline void print()
{
    printf("%lld\n",ans);
}
 
int main()
{
    while(~scanf("%d",&n))
    {
        prework();
        mainwork();
        print();
    }
    return 0;
}
/*
1
0 1
1
1 2
2
0 1
3 4
2
0 1 4 5
1
3 5
1
100000011 100000015
2
100000011 100000015
200000011 200000015
1
2 5
1
999999999 999999999
2
999999994 999999995
999999998 999999999
2
999999993 999999994
999999997 999999998
*/