[HDU6155]Subsequence Count

题目大意：
　　给定一个01序列，支持以下两种操作：
　　　　1.区间反转；
　　　　2.区间求不同的子序列数量。

思路：
　　首先我们考虑区间反转，这是一个经典的线段树操作。
　　接下来考虑求不同的子序列数量，在已知当前区间的情况下，我们有如下$O(n)$的动态规划：|
　　　　$f_{i,0}=f_{i-1,0}+f_{i-1,1}+1,f_{i,1}=f_{i-1,1}//第i位为0$
　　　　$f_{i,1}=f_{i-1,0}+f_{i-1,1}+1,f_{i,0}=f_{i-1,0}//第i位为1$
　　这样的动态规划显然无法直接用线段树维护，而如果不能直接用线段树维护，上面维护的区间反转也就失去了意义。
　　为了使用线段树维护这种动态规划，我们需要用矩阵表示这种递推关系。
　　$\left(\begin{array}{}f_{i+1,0}\\f_{i+1,1}\\1\end{array}\right)=\left(\begin{array}{}f_{i-1,0}\\f_{i-1,1}\\1\end{array}\right)\times\left(\begin{array}{}1&0&0\\1&1&0\\1&0&1\end{array}\right)$
　　$\left(\begin{array}{}f_{i+1,0}\\f_{i+1,1}\\1\end{array}\right)=\left(\begin{array}{}f_{i-1,0}\\f_{i-1,1}\\1\end{array}\right)\times\left(\begin{array}{}1&1&0\\0&1&0\\0&1&1\end{array}\right)$
　　这样我们就可以保存每个区间的乘积，询问时直接相乘即可。

 #include<cstdio>
 #include<cctype>
 #include<algorithm>
 inline int getint() {
     char ch;
     while(!isdigit(ch=getchar()));
     int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 inline int getdigit() {
     char ch;
     while(!isdigit(ch=getchar()));
     return ch^'';
 }
 const int N=,mod=1e9+;
 template<int SIZE>
 struct Matrix {
     int val[SIZE][SIZE];
     Matrix operator * (const Matrix &another) const {
         Matrix ret;
         for(int i=;i<SIZE;i++) {
             for(int j=;j<SIZE;j++) {
                 ret.val[i][j]=;
                 for(int k=;k<SIZE;k++) {
                     ret.val[i][j]+=(long long)val[i][k]*another.val[k][j]%mod;
                     ret.val[i][j]%=mod;
                 }
             }
         }
         return ret;
     }
     void operator *= (const Matrix &another) {
         *this=*this*another;
     }
     void flip() {
         std::swap(val[][],val[][]);
         std::swap(val[][],val[][]);
         std::swap(val[][],val[][]);
         std::swap(val[][],val[][]);
     }
     int calc() {
         return (val[][]+val[][])%mod;
     }
 };
 const Matrix<> m[]={
     {,,,
      ,,,
      ,,},
     {,,,
      ,,,
      ,,}
 };
 const Matrix<> E={
     ,,,
     ,,,
     ,,
 };
 class SegmentTree {
     private:
         #define _left <<1
         #define _right <<1|1
         Matrix<> val[N<<];
         bool tag[N<<];
         void push_up(const int p) {
             val[p]=val[p _left]*val[p _right];
         }
         void push_down(const int p) {
             if(!tag[p]) return;
             val[p _left].flip();
             val[p _right].flip();
             tag[p _left]^=true;
             tag[p _right]^=true;
             tag[p]=false;
         }
     public:
         void build(const int p,const int b,const int e) {
             tag[p]=false;
             if(b==e) {
                 val[p]=m[getdigit()];
                 return;
             }
             int mid=(b+e)>>;
             build(p _left,b,mid);
             build(p _right,mid+,e);
             push_up(p);
         }
         void modify(const int p,const int b,const int e,const int l,const int r) {
             if(b==l&&e==r) {
                 val[p].flip();
                 tag[p]^=true;
                 return;
             }
             push_down(p);
             int mid=(b+e)>>;
             if(l<=mid) modify(p _left,b,mid,l,std::min(mid,r));
             if(r>mid) modify(p _right,mid+,e,std::max(mid+,l),r);
             push_up(p);
         }
         Matrix<> query(const int p,const int b,const int e,const int l,const int r) {
             if(b==l&&e==r) {
                 return val[p];
             }
             push_down(p);
             int mid=(b+e)>>;
             Matrix<> ret=E;
             if(l<=mid) ret*=query(p _left,b,mid,l,std::min(mid,r));
             if(r>mid) ret*=query(p _right,mid+,e,std::max(mid+,l),r);
             return ret;
         }
 };
 SegmentTree t;
 int main() {
     for(int T=getint();T;T--) {
         int n=getint(),q=getint();
         t.build(,,n);
         while(q--) {
             int op=getint(),l=getint(),r=getint();
             switch(op) {
                 case : {
                     t.modify(,,n,l,r);
                     break;
                 }
                 case : {
                     printf("%d\n",t.query(,,n,l,r).calc());
                     break;
                 }
             }
         }
     }
     return ;
 }