UVALive 6914

---

题目描述：

一个8*8的格子.给你一个最多可以放的障碍物的数目.一个人只能往下或者往右走.问把00点和(n-1)(m-1)点能够隔开的总放障碍的方法数.

题解：

首先我们注意到n很小,可以状压. 如果我们不状压怎么样?f[i][j][k]隔断到i,j点,用了k个障碍. 那么i,j放不放障碍呢?放的话,好转移.不放的话,我们要考虑它的上方和左方放不放点.有一个放和两个都放好弄.两个都不放就不会了. 于是我们再增加一维sta. 用来状压i,j点还没放的时候那一层的状态情况.含义和铺砖一样. 一样就可以只看当前点要不要放来转移.

重点：

8果断用一层的状压来简化思路(不状压发现不会转移….)

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <ctype.h>
#include <limits.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#include <bitset>
#define CLR(a) memset(a, 0, sizeof(a))
#define REP(i, a, b) for(ll i = a;i < b;i++)
#define REP_D(i, a, b) for(ll i = a;i <= b;i++)

typedef long long ll;

using namespace std;

const ll maxS = (1<<8);
const ll maxn = 10;
const ll MOD = 1e9+7.1;

ll f[maxn][maxn][maxn*maxn][maxS];
ll n, m, limit;
void solve()
{
    ll key = (1<<m);
    CLR(f);
    f[0][0][0][(key-1)^1] = 1;
    for(ll i = 0; i<n; i++)
    {
        for(ll j = 0; j<m; j++)
        {
            for(ll k = 0; k<=limit; k++)
            {
                for(ll s = 0; s<key; s++)
                {

                    if(j==0)
                    {
                        ll newS = s;
                        f[i][j+1][k][newS]=(f[i][j+1][k][newS] + f[i][j][k][s])%MOD;
                        newS = (s|(1));
                        f[i][j+1][k+1][newS] = (f[i][j+1][k+1][newS] + f[i][j][k][s])%MOD;
                    }
                    else if(j==m-1)
                    {
                        ll newS = s;
                        if((1<<(j-1)&s)==0 || ((1<<j)&s)==0)
                        {
                            ll t = (1<<j);
                            t = ~t;
                            newS = (s&(t));
                        }
                        else
                        {
                            newS = (s|(1<<j));
                        }
                        f[i+1][0][k][newS] = (f[i+1][0][k][newS] + f[i][j][k][s])%MOD;
                        newS = (s|(1<<j));
                        f[i+1][0][k+1][newS] = (f[i+1][0][k+1][newS] + f[i][j][k][s])%MOD;
                    }
                    else
                    {
                        ll newS = s;
                        if((1<<(j-1)&s)==0 || ((1<<j)&s)==0)
                        {
                            ll t = (1<<j);
                            t = ~t;
                            newS = (s&(t));
                        }
                        else
                        {
                            newS = (s|(1<<j));
                        }
                        f[i][j+1][k][newS] = (f[i][j+1][k][newS] + f[i][j][k][s])%MOD;
                        newS = (s|(1<<j));
                        f[i][j+1][k+1][newS] = (f[i][j+1][k+1][newS] + f[i][j][k][s])%MOD;
                    }
                }
            }
        }
    }
    //printf("-------------%lld \n", f[0][2][0][4]);
    ll ans = 0;
    for(ll s = 0; s < key; s++)
    {
        if((s&(1<<(m-1)) ))
        {
            for(ll i = 0; i<=limit; i++)
            {
                ans = (ans + f[n][0][i][s])%MOD;
            }
        }
    }
    printf("%lld\n", ans);
}

ll C[20][20];

void getC()
{
    C[0][0] = 1;
    for(ll i = 1; i<=8; i++)
    {
        C[i][0] = 1;
        for(ll j = 1; j<i; j++)
        {
            C[i][j] = (C[i-1][j] + C[i-1][j-1])%MOD;
        }
        C[i][i] = 1;
    }
}

int main()
{
    //freopen("9Iin.txt", "r", stdin);
    //freopen("9Iout.txt", "w", stdout);
    ll t;
    getC();
    scanf("%lld", &t);
    REP_D(_,1,t)
    {
        printf("Case #%lld: ", _);
        scanf("%lld%lld%lld", &n, &m, &limit);
        if(m==1)
        {
            ll ans = 0;
            for(ll i = 1; i<=limit; i++)
            {
                ans = (ans + C[n][i])%MOD;
            }
            printf("%lld\n", ans);
        }
        else
        {
            solve();
        }
    }
    return 0;
}