FZU 2133 kk排座位 轮廓线状态压缩

题目链接：http://acm.fzu.edu.cn/problem.php?pid=2133

如果考虑从高度为1-n的顺序放，可以发现，从一排开始，每排的人数是不增的。即如果有三排，人数分别为a1，a2，a3，始终有a1>=a2>=a3，不然的话，下一个人是无法放进来的。那么，我们可以按这一条斜线做状态的转移，我们将每排的人数压成一个11进制数（m<=10），表示状态，可以使用dp[ i ][ j ]表示放到第i个人，状态为j的方法有多少种。但是感觉j的范围是在太大。考虑到人数是不增的，我们不妨将 a1-a2，a2-a3，a3-a4，....压成一个11进制数，我们可以用dp[ i ][ j ][ k ]表示，放到第i个人，最后一排是j个人，每排的增量状为k，这个时候的放的方法数。又，仔细一想，其实j也是可以省掉的，因为你知道总人数是i，根据k的情况，可以算出来j具体是多少。那么，考虑到k每位之和不会超过m，我们先dfs预处理一下有效状态（我大概算了一下，有效状态似乎不超过1000），然后就可以做DP了。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef __int64 LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF=100011122;
const double INFF=1e100;
const double eps=1e-8;
const int mod=1000000007;
const int NN=400005;
const int MM=1000010;
/* ****************** */

struct node
{
    int zt,sum;
}re[NN];
int dui[NN*3];
int tol;
int dp[2][NN];
int a[20];
int limit[10];
int pp11[11];

void dfs(int now,int zt,int t_sum,int left,int ttt)
{
    if(now==0)
    {
        tol++;
        re[tol].zt=zt;
        re[tol].sum=t_sum;
        dui[zt]=tol;
        return;
    }
    int i;
    for(i=0;i<=left;i++)
    {
        dfs(now-1,zt*11+i,t_sum+i*ttt,left-i,ttt+1);
    }
}

int main()
{
    int cas,n,m,i,pai,t,temp;
    int j,k,zt,ans;

    pp11[0]=1;
    for(i=1;i<8;i++)
    {
        pp11[i]=pp11[i-1]*11;
    }

    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&m);
        pai=(n+m-1)/m;

        for(i=1;i<=pai;i++)
            limit[i]=m;
        limit[pai]=n%m;
        if(limit[pai]==0)limit[pai]=m;

        if(pai==1)
        {
            puts("1");
        }
        else
        {
            tol=0;
            dfs(pai-1,0,0,m,1);
         //   printf("tol==%d\n",tol);

            memset(dp,0,sizeof(dp));
            t=0;
            dp[t][1]=1;
            for(i=1;i<=n;i++)
            {
                t=1-t;
                for(j=1;j<=tol;j++)
                    dp[t][j]=0;
                for(j=1;j<=tol;j++)
                    if(dp[1-t][j])
                    {
                        a[pai]=(i-1-re[j].sum)/pai;
                        temp=re[j].zt;
                        for(k=pai-1;k>=1;k--)
                        {
                            a[k]=a[k+1]+temp%11;
                            temp/=11;
                        }
                        a[0]=100;

                        for(k=1;k<=pai;k++)
                        {
                            if(a[k]+1<=limit[k] && a[k-1]>a[k])
                            {
                                zt=re[j].zt;
                                if(k<pai)
                                {
                                    zt+=pp11[pai-k-1];
                                }
                                if(k-1>=1)
                                {
                                    zt-=pp11[pai-k];
                                }
                                zt=dui[zt];
                                dp[t][zt]+=dp[1-t][j];
                                if(dp[t][zt]>=mod)
                                    dp[t][zt]-=mod;
                            }
                        }
                    }
            }

        //    printf("finally  %d\n",limit[pai-1]-limit[pai]);

            ans=dp[t][ dui[ limit[pai-1]-limit[pai] ] ];
            printf("%d\n",ans);
        }
    }
    return 0;
}