扫雷

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2398    Accepted Submission(s): 645

Problem Description

扫雷游戏是晨晨和小璐特别喜欢的智力游戏，她俩最近沉迷其中无法自拔。
该游戏的界面是一个矩阵，矩阵中有些格子中有一个地雷，其余格子中没有地雷。 游戏中，格子可能处于己知和未知的状态。如果一个己知的格子中没有地雷，那么该 格子上会写有一个一位数，表示与这个格子八连通相邻的格子中地雷总的数量。
现在，晨晨和小璐在一个3行N列（均从1开始用连续正整数编号）的矩阵中进 行游戏，在这个矩阵中，第2行的格子全部是己知的，并且其中均没有地雷；而另外 两行中是未知的，并且其中的地雷总数量也是未知的。
晨晨和小璐想知道，第1行和第3行有多少种合法的埋放地雷的方案。

Input

包含多组测试数据，第一行一个正整数T，表示数据组数。
每组数据由一行仅由数字组成的长度为N的非空字符串组成，表示矩阵有3行N 列，字符串的第i个数字字符表示矩阵中第2行第i个格子中的数字。
保证字符串长度N <= 10000，数据组数<= 100。

Output

每行仅一个数字，表示安放地雷的方案数mod100,000,007的结果。

Sample Input


2 22 000


Sample Output


6 1


Source



2016年中国大学生程序设计竞赛（合肥）-重现赛（感谢安徽大学）

 

       

        中文题。

        有个3*N的地图，告诉你第二行的情况，问你有多少种情况放地雷。

        自己自始至终的想法：状态压缩。由于任意一个第二行格子的情况只与前一个的格子控制范围的后四个有关，所以我么可以用一个4位的二进制数来表示某个位置是否放了地雷。定义dp[i][j]表示处理到第i列，且第i列所控制的后四个格子的状态是j的时候的方案数。那么就可以很自然的得到状态转移方程：dp[i][j]=Σdp[i-1][x]，其中这个x表示上一个可以合法转移的状态。这里关于这个状态的枚举，我们可以枚举上一个格子的状态，然后根据上一个推下一个。我们假设第i个格子控制范围内含有a[i]个地雷，那么我们枚举x的时候就要枚举x下雷的个数，确定个数后，再通过预处理出的所有满足雷个数的状态来确定转移。如此一来，每个个数的雷的状态分别有[1,4,6,4,1]种，然后每次枚举的时候最多枚举三个数量，最后的时间复杂度是O(N*3*6)，即使加上100组数据，理论上讲怎么也不应该TLE。但是无奈HDU就是给你个TLE。但是据说现场赛的时候，状态压缩是可以过的。不过呢，这里我还是要把代码贴出来！虽然A不了……

#include<cstdio>
#include<algorithm>
#include<cstring>
#define mod 100000007
#define N 10010
using namespace std;

int a[N],dp[N][16],ed[5],st[5][16];
char s[N];

void dfs(int x,int t,int num)
{
    if (t==a[1])
    {
        dp[1][num]=1;
        return;
    }
    if (x<0) return;
    dfs(x-1,t+1,num|(1<<x));
    dfs(x-1,t,num);
}

int countone(int x)
{
    int res=0;
    while(x) {res+=(x&1);x>>=1;}
    return res;
}

void init(int x,int t,int num)                    //初始化，把所有后四个格子的情况弄出来
{
    if (t)
    {
        int p=countone(num);
        st[p][++ed[p]]=num;
    }
    if (x<0) return;
    init(x-1,t+1,num|(1<<x));
    init(x-1,t,num);
}

int main()
{
    int T_T;
    init(3,0,0);
    scanf("%d",&T_T);
    st[0][++ed[0]]=0;
    for(int i=0;i<=4;i++)
    {
        sort(st[i]+1,st[i]+ed[i]+1);                            //去重
        ed[i]=unique(st[i]+1,st[i]+ed[i]+1)-st[i]-1;
    }
    bool flag;
    int k,status,p,i,j,ns1,ns2,ans;
    while(T_T--)
    {
        scanf("%s",s);
        int n=strlen(s);
        ans=0; flag=1;
        for(int i=0;i<n;i++)
        {
            a[i+1]=s[i]-48;
            if (a[i+1]>6)
            {
                flag=0; break;
            }
        }
        if (!flag||a[n]>4&&flag||a[1]>4)
        {
            puts("0");
            continue;
        }
        if (n==1)
        {
            if (a[1]==0||a[1]==2) puts("1");
            else if (a[1]==1) puts("2");
            else puts("0");
            continue;
        }
        memset(dp,0,sizeof(dp[0])*n);
        dfs(3,0,0);                                //处理初始化
        for(i=2;i<n;i++)
        {
            flag=0;
            int Min=min(a[i-1],min(4,a[i]));
            for(j=max(a[i]-2,0);j<=Min;j++)                    //枚举前一个格子后四个包含的雷的数量
                for(p=1;p<=ed[j];p++)                        //根据数量枚举前一个的状态
                {
                    k=st[j][p]; ns2=a[i]-j;
                    status=(k%4)<<2;                        //根据前一个的状态构造后面的状态
                    if (ns2==2)                        //转移到对应的新状态，怕段判断当前格子控制的后两个格子的状态
                    {
                        ns1=status|3;
                        dp[i][ns1]=(dp[i][ns1]+dp[i-1][k])%mod;
                        if (dp[i][ns1]) flag=1;
                    } else
                    if (ns2==1)
                    {
                        ns1=status|1; ns2=status|2;
                        dp[i][ns1]=(dp[i][ns1]+dp[i-1][k])%mod;
                        dp[i][ns2]=(dp[i][ns2]+dp[i-1][k])%mod;
                        if (dp[i][ns1]||dp[i][ns2]) flag=1;
                    } else
                    if (ns2==0)
                    {
                        dp[i][status]=(dp[i][status]+dp[i-1][k])%mod;
                        if (dp[i][status]) flag=1;
                    }
                }
            if (!flag) break;
        }
        if (flag==0){puts("0"); continue;}
        for(p=1;p<=ed[a[n]];p++)
        {
            k=st[a[n]][p];
            ans=(ans+dp[n-1][k])%mod;
        }
        printf("%I64d\n",ans);
    }

    return 0;
}


        在不管怎么优化都难逃TLE的命运之下，我很不情愿的写了另外一种dp思路。我们发现一个三维的dp也可以很好的表示这种情况。定义dp[i][j][k]表示第i个格子控制范围的前一列中有j个雷，自己所在列有k个雷，那么后一列就有a[i]-j-k个雷，相当于确定了一个的情况。然后转移的话也很自然dp[i][j][a[i]-j-k]=Σdp[i-1][k][j]。但是这里要注意，当某一列的个数是1的时候，这一个雷可以放的位置是不确定的，可以上可以下，所以说我们得做一些修正，对于1的时候要乘上一个2。于是有修改之后的状态转移方程：dp[i][j][a[i]-j-k]=Σp[j]*dp[i-1][k][j]，其中p={1,2,1}。这样可以很轻松的实现转移，而时间复杂度为O(3*3*N)，其实在理论上比状态压缩快不了多少，只能怪出题人卡常数吧……具体见代码：

#include <bits/stdc++.h>
using namespace std;
#define LL long long
const LL mod = 100000007;
const int maxn = 1e4 + 5;
LL dp[maxn][3][6];
char ch[maxn];
int a[maxn];
int n;
LL p[3] = {1, 2, 1};

LL solve(){
    memset(dp, 0, sizeof(dp));
    for (int i = 0; i <= 2; i++) {
        if (a[1] - i > 2) continue;
        if (a[1] - i < 0) break;
        dp[1][i][a[1] - i] = p[i];
    }
    for (int i = 2; i <= n; i++){
        for (int j = 0; j <= 2; j++){
            for (int k = 0; k <= 2; k++){
                if (a[i] - j - k > 2) continue;
                if (a[i] - j - k < 0) break;
                dp[i][j][a[i] - j - k] = (dp[i][j][a[i] - j - k] + p[j] * dp[i - 1][k][j]) % mod;
            }
        }
    }
    LL ans = 0;
    for (int i = 0; i <= 2; i++){
        if (i > a[n]) break;
        ans = (ans + dp[n][i][0]) % mod;
    }
    return ans;
}

int main(){
    int t; scanf("%d", &t);
    while (t--){
        scanf("%s", ch);
        n = strlen(ch);
        bool flag = true;
        for (int i = 0; ch[i] != '\0'; i++){
            a[i + 1] = ch[i] - '0';
            if ((i == 0 || i == n - 1) && ch[i] > '4'){
                flag = false; break;
            }
            if (ch[i] > '6') {
                flag = false; break;
            }
        }
        if (!flag) {
            printf("0\n"); continue;
        }
        printf("%I64d\n", solve());
    }
    return 0;
}