hihoCoder 1147 时空阵（动态规划）

题目链接

时间限制: 20000ms

单点时限: 1000ms

内存限制: 256MB

描述

幽香这几天学习了魔法，准备建造一个大型的时空传送阵。

幽香现在可以在幻想乡的n个地点建造一些传送门，如果她建造了从地点a与地点b之间的传送门，那么从a到b和从b到a都只需要单位1的时间。

同时这些地点之间在地理上是非常遥远的，因此来往他们必须使用传送门。

现在幽香想要问你，有多少种建造传送门的方案，使得地点1和地点n之间的最短距离恰好为k？两个方案不同当且仅当建造的传送门的集合不同。不能建造节点到自身的传送门，两个点之间也最多造一个传送门。

输入

第一行一个数n(1 <= n <= 100)，k(1 <= k <= 100)，表示地点的个数和题目中所述的距离。

输出

输出一行，表示方案的数量。答案对109+7取模。

样例输入

6 3

样例输出

2344

题解：根据点到起点的距离，我们可以把图看成分层图，以这个角度进行动态规划。

用 dp[i][j][k] 表示前i层共有j个点，第i层有k个点的方案数。

第i层的点只能与第i-1层的点和同层的点之间建边。

转移就是：（x表示上一层的点数）(设题目中要求n在第L层)

如果i<L：

dp[i][j][k]+=dp[i-1][j-k][x]*((2^x-1)^k)*2^(k*(k-1)/2)*C[n-j-1][k]

否则：（因为第n个点一定要放在第L层）

dp[i][j][k]+=dp[i-1][j-k][x]*((2^x-1)^k)*2^(k*(k-1)/2)*C[n-j-2][k]

求出dp以后，直接统计答案即可。

代码如下：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#define mod 1000000007
#define nn 110
typedef long long LL;
using namespace std;
int n,m;
LL c[nn][nn],po[nn*nn];
LL dp[nn][nn][nn];
void init()
{
    int i,j;
    po[0]=1;
    for(i=1;i<=10000;i++)
        po[i]=(po[i-1]*2)%mod;
    memset(c,0,sizeof(c));
    c[0][0]=1;
    for(i=1;i<=100;i++)
    {
        c[i][0]=1;
        for(j=1;j<=i;j++)
        {
            c[i][j]=(c[i-1][j]+c[i-1][j-1])%mod;
        }
    }
}
LL cf(LL x,int y)
{
    LL re=1;
    while(y)
    {
        if(y&1)
        {
            re=(re*x)%mod;
        }
        x=(x*x)%mod;
        y/=2;
    }
    return re;
}
int main()
{
    int i,j,k,e;
    init();
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        memset(dp,0,sizeof(dp));
        dp[0][1][1]=1;
        LL ix;
        for(i=1;i<=m;i++)
        {
            for(j=i+1;j<=n-m+i;j++)
            {
                for(k=1;k<=j-i;k++)
                {
                    ix=i<m?c[n-j+k-1][k]:c[n-j+k-1][k-1];
                    for(e=1;e<=j-k-i+1;e++)
                    {
                        dp[i][j][k]+=ix*dp[i-1][j-k][e]%mod*cf((po[e]-1+mod)%mod,k)%mod*po[(k-1)*k/2]%mod;
                        dp[i][j][k]%=mod;
                    }
                }
            }
        }
        LL ans=0;
        for(i=m+1;i<=n;i++)
        {
            for(j=1;j<=i-m;j++)
            {
                ans+=dp[m][i][j]*po[j*(n-i)+(n-i)*(n-i-1)/2]%mod;
                ans%=mod;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}