BZOJ 2752 [HAOI2012]高速公路(road)：线段树【维护区间内子串和】

题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2752

题意：

　　有一个初始全为0的，长度为n的序列a。

　　有两种操作：

　　　　（1）C l r v: 将[l,r)内的数全部加v。

　　　　（2）Q l r: 在[l,r)内随机选两个数x,y(x < y)，问你∑(a[x to y])的期望，用最简分数形式输出。

题解：

　　首先，题中要求的期望 = 区间内所有子串之和 / 区间内子串个数。

　　如果一个区间的长度为len，显然区间内的子串个数为len*(len+1)/2。

　　所以题目就变成了怎样维护区间内所有子串之和。

　　dat表示某个区间的子串和。

　　假设有两个相邻区间l,r，合并起来的区间叫x。

　　那么dat[x] = dat[x] + dat[y] + 跨两个区间的子串和

　　所以接下来考虑如何求跨区间的子串和。

　　sum表示某个区间的所有元素之和。

　　ln表示区间l的长度，rn表示区间r的长度。

　　ls表示某个区间的所有所有前缀之和，rs表示某个区间的所有后缀之和。

　　则跨区间的子串之和 = rs[l]*rn + ls[r]*ln

　　即dat[x] = dat[x] + dat[y] + rs[l]*rn + ls[r]*ln

　　ls,rs和sum的合并就很好求了：

　　ls[x] = ls[l] + rn*sum[l] + ls[r]

　　rs[x] = rs[r] + ln*sum[r] + rs[l]

　　sum[x] = sum[l] + sum[r]

　　这样线段树的pushup函数就写完了。

　　然后考虑如何pushdown传标记。

　　tag表示某个区间被同时加了多少。

　　现在只考虑当前节点x的某一个儿子y，儿子y的区间长度为len。

　　首先考虑tag[x]对dat[y]的贡献。

　　贡献 = 枚举子串的长度 * 这种长度的子串个数 * tag[x]

　　即：dat[y] += ∑ i*(len-i+1)*tag[x]，其中i∈[1,len]。

　　化简得：dat[y] += ( len*(len+1)/2*(len+1) + ∑(i^2) ) * tag[x]

　　对于其中的∑(i^2)，事先O(n)预处理出来一个平方前缀和数组sqr即可。

　　然后易得tag[x]对ls,rs,sum的贡献：

　　ls[y] += len*(len+1)/2*tag[x]

　　rs[y] += len*(len+1)/2*tag[x]

　　sum[y] += len*tag[x]

　　这样pushdown也就写好了。

　　然后大力线段树即可QAQ……

AC Code:

 #include <iostream>
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #define MAX_N 100005
 #define MAX_T 400005
 #define int ll

 using namespace std;

 typedef long long ll;

 struct Node
 {
     int dt,ls,rs,s,ln;
     Node(int _dt,int _ls,int _rs,int _s,int _ln)
     {
         dt=_dt; ls=_ls; rs=_rs; s=_s; ln=_ln;
     }
     Node(){}
     friend Node mix(const Node &a,const Node &b)
     {
         int _dt=a.dt+b.dt+a.rs*b.ln+b.ls*a.ln;
         int _ls=a.ls+b.ln*a.s+b.ls;
         int _rs=b.rs+a.ln*b.s+a.rs;
         int _s=a.s+b.s;
         int _ln=a.ln+b.ln;
         return Node(_dt,_ls,_rs,_s,_ln);
     }
 };

 int n,m;
 int ls[MAX_T];
 int rs[MAX_T];
 int dat[MAX_T];
 int sum[MAX_T];
 int tag[MAX_T];
 int sqr[MAX_N];

 void cal_sqr()
 {
     for(int i=;i<=n;i++) sqr[i]=sqr[i-]+i*i;
 }

 void push_up(int x,int len)
 {
     int l=x*+,r=x*+;
     Node L(dat[l],ls[l],rs[l],sum[l],len-(len>>));
     Node R(dat[r],ls[r],rs[r],sum[r],(len>>));
     Node tmp=mix(L,R);
     dat[x]=tmp.dt;
     ls[x]=tmp.ls;
     rs[x]=tmp.rs;
     sum[x]=tmp.s;
 }

 void push_down(int x,int len)
 {
     if(tag[x])
     {
         int l=x*+,r=x*+;
         int ln=(len-(len>>)),rn=(len>>);
         dat[l]+=(ln*(ln+)/*(ln+)-sqr[ln])*tag[x];
         dat[r]+=(rn*(rn+)/*(rn+)-sqr[rn])*tag[x];
         ls[l]+=ln*(ln+)/*tag[x];
         ls[r]+=rn*(rn+)/*tag[x];
         rs[l]+=ln*(ln+)/*tag[x];
         rs[r]+=rn*(rn+)/*tag[x];
         sum[l]+=ln*tag[x];
         sum[r]+=rn*tag[x];
         tag[l]+=tag[x];
         tag[r]+=tag[x];
         tag[x]=;
     }
 }

 void update(int a,int b,int k,int l,int r,int x)
 {
     if(a<=l && r<=b)
     {
         int len=r-l+;
         tag[k]+=x;
         sum[k]+=len*x;
         ls[k]+=len*(len+)/*x;
         rs[k]+=len*(len+)/*x;
         dat[k]+=(len*(len+)/*(len+)-sqr[len])*x;
         return;
     }
     if(r<a || b<l) return;
     push_down(k,r-l+);
     int mid=(l+r)>>;
     update(a,b,k*+,l,mid,x);
     update(a,b,k*+,mid+,r,x);
     push_up(k,r-l+);
 }

 Node query(int a,int b,int k,int l,int r)
 {
     if(a<=l && r<=b) return Node(dat[k],ls[k],rs[k],sum[k],r-l+);
     if(r<a || b<l) return Node(,,,,);
     push_down(k,r-l+);
     int mid=(l+r)>>;
     Node v1=query(a,b,k*+,l,mid);
     Node v2=query(a,b,k*+,mid+,r);
     return mix(v1,v2);
 }

 signed main()
 {
     scanf("%lld%lld",&n,&m);
     n--;
     cal_sqr();
     char opt[];
     int l,r,v;
     while(m--)
     {
         scanf("%s%lld%lld",opt,&l,&r);
         if(opt[]=='C')
         {
             scanf("%lld",&v);
             update(l,r-,,,n,v);
         }
         else
         {
             int dt=query(l,r-,,,n).dt;
             int len=r-l;
             int tot=len*(len+)/;
             int g=__gcd(dt,tot);
             printf("%lld/%lld\n",dt/g,tot/g);
         }
     }
 }