Codeforces 718C. Sasha and Array（线段树）

传送门

解题思路：

这道题给了我们一个崭新的角度来看线段树。

我们常常使用的线段树是维护区间的函数的。

这里呢，提示我们线段树其实还可以维护递推。

美好的矩阵递推性质支持了这一功能。

或者说，对于递推项求和，可以使用线段树维护矩阵。

区间向前递推可以用懒惰标记记录递推矩阵。

区间的查询可以是子节点矩阵和。

这其实也是满足分配率的。

最后pushup，pushdown搞一搞就好了。

代码（闲来无事卡常码风突变）：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll spc<<1
 #define rrr spc<<1|1
 typedef unsigned long long lnt;
 typedef unsigned int ixt;
 const lnt mod=(lnt)(1e9+);
 struct squ{
     lnt s[][];
     inline void res(void)
     {
         memset(s,,sizeof(s));
         return ;
     }
     inline void O1(void)
     {
         for(register int i=;i<;i++)
             s[i][i]=;
         return ;
     }
     inline squ friend operator + (const squ &a,const squ &b)
     {
         squ ans;
         for(register int i=;i<;i++)
         {
             for(register int j=;j<;j++)
             {
                 ans.s[i][j]=(a.s[i][j]+b.s[i][j])%mod;
             }
         }
         return ans;
     }
     inline squ friend operator * (const squ &a,const squ &b)
     {
         squ ans;
         for(register int i=;i<;i++)
         {
             for(register int j=;j<;j++)
             {
                 ans.s[i][j]=;
                 for(register int k=;k<;k++)
                 {
                     ans.s[i][j]=(ans.s[i][j]+a.s[i][k]*b.s[k][j])%mod;
                 }
             }
         }
         return ans;
     }
     inline squ friend operator ^ (squ a,lnt b)
     {
         squ ans=a;
         b--;
         while(b)
         {
             if(b&)
                 ans=ans*a;
             a=a*a;
             b=b/;
         }
         return ans;
     }
 }sta,pro;
 struct trnt{
     squ sum;
     squ lzt;
     bool op;
 }tr[];
 ixt n,m;
 ixt a[];
 inline void read(ixt &ans)
 {
     ans=;
     char ch=getchar();
     while(ch<''||ch>'')
         ch=getchar();
     while(ch>=''&&ch<='')
         ans=ans*+ch-'',ch=getchar();
     return ;
 }
 inline squ Fib(const lnt &x)
 {
     squ tmp=pro^x;
     return tmp*sta;
 }
 inline void pushup(const int &spc)
 {
     tr[spc].sum=tr[lll].sum+tr[rrr].sum;
     return ;
 }
 inline void add(const int &spc,const squ &v)
 {
     tr[spc].op=true;
     tr[spc].lzt=v*tr[spc].lzt;
     tr[spc].sum=v*tr[spc].sum;
     return ;
 }
 inline void pushdown(const int &spc)
 {
     if(tr[spc].op)
     {
         add(lll,tr[spc].lzt);
         add(rrr,tr[spc].lzt);
         tr[spc].lzt.res();
         tr[spc].lzt.O1();
         tr[spc].op=;
     }
     return ;
 }
 inline void build(const int &l,const int &r,const int &spc)
 {
     tr[spc].lzt.res();
     tr[spc].lzt.O1();
     if(l==r)
     {
         tr[spc].sum=Fib(a[l]);
         return ;
     }
     int mid=(l+r)>>;
     build(l,mid,lll);
     build(mid+,r,rrr);
     pushup(spc);
     return ;
 }
 inline void update(const int &l,const int &r,const int &ll,const int &rr,const int &spc,const squ &v)
 {
     if(ll>r||l>rr)
         return ;
     if(ll<=l&&r<=rr)
     {
         add(spc,v);
         return ;
     }
     int mid=(l+r)>>;
     pushdown(spc);
     update(l,mid,ll,rr,lll,v);
     update(mid+,r,ll,rr,rrr,v);
     pushup(spc);
     return ;
 }
 inline squ query(const int &l,const int &r,const int &ll,const int &rr,const int &spc)
 {
     squ ans;
     ans.res();
     if(l>rr||ll>r)
         return ans;
     if(ll<=l&&r<=rr)
         return tr[spc].sum;
     int mid=(l+r)>>;
     pushdown(spc);
     return query(l,mid,ll,rr,lll)+query(mid+,r,ll,rr,rrr);
 }
 int main()
 {
     sta.s[][]=;
     sta.s[][]=;
     pro.s[][]=;
     pro.s[][]=;
     pro.s[][]=;
     read(n);
     read(m);
     for(register int i=;i<=n;i++)
         scanf("%d",&a[i]);
     build(,n,);
     while(m--)
     {
         ixt opt;
         read(opt);
         if(opt==)
         {
             ixt l,r,x;
             read(l);
             read(r);
             read(x);
             if(!x)
                 continue;
             squ tmp=pro^x;
             update(,n,l,r,,tmp);
         }else{
             ixt l,r;
             read(l);
             read(r);
             printf("%I64u\n",(query(,n,l,r,).s[][]%mod+mod)%mod);
         }
     }
     return ;
 }