如果要动态更新m次。。我们显然可以用o(mn)的暴力弄出来
其实可以o(mlogn)的；

在李睿的论文里提出了一种新的数据结构：
很巧妙，很强大：
对于序列a[]，我们设一个数组C，其中 （k为i在二进制下末尾0的个数）。

c[i]=a[i]+a[i-1]+...+
a[i-2^k+1]//这一项的最后一位一定是0
包含a[x]的c序列：

c[x]=a[x]+a[x-1]+...+a[x-2^k+1]
c[x+2^k]=a[x+2^k]+a[x+2^k-1]...+a[x]+...+a[x-2^k+1]
....
一直加到<=S的状况

针对这个情况。。我们有两个实现。。一个是update(),另一个是统计的操作
如果针对上面的统计就是求给定区间的sum （x,y）=sum(1,y)-sum(1,x)；

procedure UPDATA(x,A)
begin
     p←x
     while (p<=n) do
     begin
         C[p]←C[p]+A
            p←p+LOWBIT(p)
     end
end 

求a[1]-a[x]的和
function  SUM(x)
begin
    ans ← 0
p ← x
while (p>0) do
     begin
          ans←ans+C[p]
          p←p-LOWBIT(p)
     end
return ans
end 

#include<iostream>
#define MaxS 1025
#define L(a) (a&(a^(a-1)))
int S,x,y,A,L,B,R,T;
int c[MaxS][MaxS];
void update()
{
    //x<=i<S的c[i][y]更新
    int i,j;
    for(i=x;i<=S;i+=L(i))
        for(j=y;j<=S;j+=L(j))
            c[i][j]+=A;
}
int compute(int x,int y)
{
    int result=0,i,j;
    for(i=x;i>0;i-=L(i))
        for(j=y;j>0;j-=L(j))
            result+=c[i][j];
    return result;
}
int main()
{
    int oper,ans;
    while(scanf("%d",&oper)&&oper!=3)
    {
        switch (oper)
        {
        case 0:
            scanf("%d",&S);
            memset(c,0,sizeof(c));
            break;
        case 1:
            scanf("%d%d%d",&x,&y,&A);
            x++,y++;
            update();
            break;
        case 2:
            scanf("%d%d%d%d",&L,&B,&R,&T);
            L++,B++,R++,T++;
            ans=compute(R,T)-compute(L-1,T)-compute(R,B-1)+compute(L-1,B-1);
            printf("%d\n",ans);
            break;
        }
    }
    return 0;
}

• for any k, such that 1 <= k < n : |a_k - a_k+1| = 1 and
• a₁ = 0

  如果没有如此序列则输出"No"

我们假设n-->序列长度，S-->序列和；

S=sigma a[i](1<=i<=n)
令bi=a[i+1]-a[i] (1<=i<n)

important ....我就是这里一直错...绝对值...没考虑....

#include<iostream>
#include<math.h>
int N,S;
int main()
{
    int std,i,d,pre;
    int T;
    scanf("%d",&T);
    for(int j=1;j<=T;j++)
    {
        scanf("%d%d",&N,&S);
        std=(N*(N-1))/2;
        if((S+std)%2||abs(S)>std)
        {
            printf("No\n");
            if(j!=T)printf("\n");
            continue;
        }
        printf("0\n");
        for(pre=0,std+=S,std/=2,i=1;i<N;i++)
        {
            if(std>=N-i)
            {    
                d=1;
                std-=N-i;
            }
            else d=0;
            printf("%d\n",pre=2*d-1+pre);
        }
        if(j!=T)printf("\n");
    }
    return 0;
}

用横线来划分阶段，对于图一，虽然划分后很整齐，但把某些砖分成了两半，于是将他们也添加进来，于是变成了图二，其显得参差不齐，但最多也是向下突出一格，在图三中，我们将图二的空隙填满，则又转移到了下一种状态。

定义添砖小块状态为1,否则为0,则每行状态可以映射到一个数(0,2^h})于是可建立这样的状态a[ i ：j]：表示第i行填满，第i+1行对应状态为j时的不同方案数，a[I,j]=∑a[i-1,k]，其中，状态k可导出状态j,初始化条件a[0,0]=1，最后a[w,0]即为所求。

的启发，再加上zp的讲解逐渐清晰起来：
行数我们默认是从0开始

#include<iostream>
#define max(a,b) (a>b?a:b)
int N,M,maxl=0;
__int64 ans[3000],tmp[3000];
void solve(int j,int last,int now)
{
    if(j>M)
    {
        tmp[now]+=ans[last];
        maxl=max(maxl,now);
        return;
    }
    int up=(1<<(M-j))&last,uprt;
    //up-->头顶上的那个格子状态，uprt-->头顶上的右边的那个格子的状态
    if(j==M)
    {
        if(!up)solve(j+1,last,now*2+1);//就剩一个空了，并且上面的那个是0，那么显然是竖条
        //这一行需要补一个小方格
        //如果上面是1，显然下面仍然是要接着一个竖条，但是这个小方格是上面这半个，无需置1
        else solve(j+1,last,now*2);
    }
    else
    {
        uprt=(1<<(M-j-1))&last;
        if(!up)
        {
            solve(j+1,last,now*2+1);
            if(!uprt)//如果头顶上的不为0，头顶上右边的也不为0，下面的就可以放一个横条
                solve(j+2,last,now*4);
        }
        else//这个地方时很容易出错的，我这里认为是第j列置为0
            //可以理解为是一个竖形条状的上半个格子，也可以认为是一个横行条状的左半个格子
            //这里千万不能把这两种情况分开计算，这样会重复的
            solve(j+1,last,now*2);
    }
}
            

int main()
{
    int i,j;
    while(scanf("%d%d",&N,&M)&&N)
    {
        if((N*M)%2)
        {
            printf("0\n");
            continue;
        }
        memset(ans,0,sizeof(ans));
        ans[0]=1;
        for(i=1;i<=N;i++)
        {
            memset(tmp,0,sizeof(tmp));
            for(j=0;j<=maxl;j++)
                if(ans[j])solve(1,j,0);
            memcpy(ans,tmp,sizeof(tmp));
        }
        printf("%I64d\n",ans[0]);
    }
    return 0;
}