bzoj 4031: [HEOI2015]小Z的房间 轮廓线dp

4031: [HEOI2015]小Z的房间

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 98  Solved: 29
[Submit][Status][Discuss]

Description

你突然有了一个大房子，房子里面有一些房间。事实上，你的房子可以看做是一个包含n*m个格子的格状矩形，每个格子是一个房间或者是一个柱子。在一开始的时候，相邻的格子之间都有墙隔着。

你想要打通一些相邻房间的墙，使得所有房间能够互相到达。在此过程中，你不能把房子给打穿，或者打通柱子（以及柱子旁边的墙）。同时，你不希望在房子中有小偷的时候会很难抓，所以你希望任意两个房间之间都只有一条通路。现在，你希望统计一共有多少种可行的方案。

Input

第一行两个数分别表示n和m。

接下来n行，每行m个字符，每个字符都会是’.’或者’*’，其中’.’代表房间，’*’代表柱子。

Output

 一行一个整数，表示合法的方案数 Mod 10^9

Sample Input

3 3
...
...
.*.

Sample Output

15

HINT

对于前100%的数据，n,m<=9

 

　　一看就是连通性插头dp，但是这道题所记录的并不是插头的连通性，而是轮廓线上的每一块之间的连通性，由于连通块不存在类似于ABAB，而且可以最小表示，所以连通性总数只有5000左右。很多细节上的问题，只有编的时候慢慢调了。

　　本以为障碍物在本题中是一个非常难处理的东西，但是实现对障碍物得处理对调试非常方便。（是不是以后没有障碍物的插头DP也可以自己实现一下来加速调试呢？）

 

　　*话说用模意义下行列式大概可以更轻松A掉这道题吧

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 12
#define MAXL 20000
#define MOD 1000000000
typedef long long qword;
inline void deal(qword &x,qword y)
{
        x=(x+y)%MOD;
}
int n,m;
int rec[MAXN];
int stack[MAXN],tops=-1;
int vis[MAXN];
int cnt=0;
int lst[MAXL],totl=0;
int lstp[MAXL][MAXN];
int lstt[MAXL];
pair<int,int> slst[MAXL];
int tmp[MAXN];
void dfs(int now,int mx)
{
        if (now==m)
        {
                memset(vis,0,sizeof(vis));
                tops=-1;
                //for (int i=0;i<=m;i++)printf("%d ",rec[i]);
                for (int i=0;i<m;i++)
                {
                        if (vis[rec[i]]==0)
                        {
                                vis[rec[i]]=1;
                                stack[++tops]=rec[i];
                        }else if (vis[rec[i]]==1)
                        {
                                while (stack[tops]!=rec[i])
                                        vis[stack[tops--]]=2;
                        }else if (vis[rec[i]]==2)
                        {
                //                printf("Failed!\n");
                                return ;
                        }
                }
                cnt++;
                memcpy(lstp[totl],rec,sizeof(rec));
                for (int i=0;i<m;i++)
                        lst[totl]=lst[totl]*10+rec[i];
                lstt[totl++]=mx;
                //printf("Success!\n");
                return ;
        }
        for (int i=0;i<=mx+1;i++)
        {
                rec[now]=i;
                dfs(now+1,max(mx,i));
        }
}
qword dp[MAXN][MAXN][MAXL];
int mi10[MAXN];
int trans(int tmp[])
{
        static int a[MAXN];
        memset(a,-1,sizeof(a));
        int tota=0;
        for (int i=0;i<m;i++)
                if (a[tmp[i]]==-1)
                        a[tmp[i]]=tota++;
        int v=0;
        for (int i=0;i<m;i++)
                v=v*10+a[tmp[i]];
        return (int)(lower_bound(lst,lst+totl,v)-lst);
}
bool mp[MAXN][MAXN];
int main()
{
        freopen("input.txt","r",stdin);
        scanf("%d%d\n",&n,&m);
        char ch;
        for (int i=0;i<n;i++)
        {
                for (int j=0;j<m;j++)
                {
                        scanf("%c",&ch);
                        if (ch=='.')
                                mp[i][j]=true;
                        else
                                mp[i][j]=false;
                }
                scanf("\n");
        }
        int v,z;
        v=0;
        while (v<n)
        {
                bool flag=false;
                for (int j=0;j<m;j++)
                {
                        if (mp[v][j])
                        {
                                flag=true;
                                break;
                        }
                }
                if (flag)break;
                v++;
        }
        for (int i=0;i<n-v;i++)
                memcpy(mp[i],mp[i+v],sizeof(mp[i]));
        n-=v;
        while (n)
        {
                bool flag=false;
                for (int j=0;j<m;j++)
                        if (mp[n-1][j])
                        {
                                flag=true;
                                break;
                        }
                if (flag)break;
                n--;
        }
        dfs(0,-1);
        mi10[0]=1;
        for (int i=1;i<MAXN;i++)mi10[i]=mi10[i-1]*10;
        dp[0][0][totl-1]=1;
        for (int i=0;i<n;i++)
        {
                for (int j=0;j<m;j++)
                {
                        for (int k=0;k<totl;k++)
                        {
                                if (!dp[i][j][k])continue;
                        /*        printf("Position:(%d,%d)\n",i,j);
                                printf("Status:");
                                for (int k2=0;k2<m;k2++)printf("%d ",lstp[k][k2]);
                                printf("\n");
                                printf("Value:%lld\n",dp[i][j][k]);*/
                                if (!mp[i][j])
                                {
                                        //-------------simple copy------------
                                        memcpy(tmp,lstp[k],sizeof(tmp));
                                        v=0;
                                        for (int k2=0;k2<m;k2++)
                                                if (tmp[k2]==tmp[j])v++;
                                        if (v>1 || (i==0) || (i && !mp[i-1][j]))
                                        {
                                                tmp[j]=lstt[k]+1;
                                                z=trans(tmp);
                                                deal(dp[i][j+1][z],dp[i][j][k]);
                                        }
                                        continue;
                                }
                                if (j==0)
                                {
                                        //--------------up--------------
                                        if (i!=0 && mp[i-1][j])
                                                deal(dp[i][j+1][k],dp[i][j][k]);
                                        //--------------none------------
                                        memcpy(tmp,lstp[k],sizeof(tmp));
                                        v=0;
                                        for (int k2=0;k2<m;k2++)
                                                if (tmp[k2]==tmp[j])v++;
                                        if (v>1 || i==0 || (i && !mp[i-1][j]))
                                        {
                                                tmp[j]=lstt[k]+1;
                                                z=trans(tmp);
                                                deal(dp[i][j+1][z],dp[i][j][k]);
                                        }
                                }else
                                {
                                        int p=lstp[k][j-1];
                                        int q=lstp[k][j];
                                        if (p==q)
                                        {
                                                //-------------up-------------
                                                if (i!=0 && mp[i-1][j])
                                                        deal(dp[i][j+1][k],dp[i][j][k]);
                                                //-------------left-----------
                                                if (mp[i][j-1])
                                                        deal(dp[i][j+1][k],dp[i][j][k]);
                                                memcpy(tmp,lstp[k],sizeof(tmp));
                                                tmp[j]=lstt[k]+1;
                                                z=trans(tmp);
                                                deal(dp[i][j+1][z],dp[i][j][k]);
                                        }else
                                        {
                                                //-------------up-------------
                                                if (i!=0 && mp[i-1][j])
                                                        deal(dp[i][j+1][k],dp[i][j][k]);
                                                //-------------none-----------
                                                memcpy(tmp,lstp[k],sizeof(tmp));
                                                v=0;
                                                for (int k2=0;k2<m;k2++)
                                                        if (tmp[k2]==tmp[j])v++;
                                                if (v>1 || i==0 || (i && !mp[i-1][j]))
                                                {
                                                        tmp[j]=lstt[k]+1;
                                                        z=trans(tmp);
                                                        deal(dp[i][j+1][z],dp[i][j][k]);
                                                }
                                                //-------------left-----------
                                                memcpy(tmp,lstp[k],sizeof(tmp));
                                                v=0;
                                                for (int k2=0;k2<m;k2++)
                                                        if (tmp[k2]==tmp[j])v++;
                                                if ((v>1 || i==0 || (i && !mp[i-1][j])) && mp[i][j-1])
                                                {
                                                        tmp[j]=tmp[j-1];
                                                        z=trans(tmp);
                                                        deal(dp[i][j+1][z],dp[i][j][k]);
                                                }
                                                //----------up && left---------
                                                memcpy(tmp,lstp[k],sizeof(tmp));
                                                if (mp[i][j-1] && i!=0 && mp[i-1][j])
                                                {
                                                        v=tmp[j];
                                                        tmp[j]=tmp[j-1];
                                                        for (int k2=0;k2<m;k2++)
                                                                if (tmp[k2]==v)tmp[k2]=tmp[j];
                                                        z=trans(tmp);
                                                        deal(dp[i][j+1][z],dp[i][j][k]);
                                                }
                                        }
                                }
                        }
                }
                for (int k=0;k<totl;k++)
                        dp[i+1][0][k]=dp[i][m][k];
        }
        for (int k2=0;k2<m;k2++)
                if (mp[n-1][k2])
                        tmp[k2]=0;
                else
                        tmp[k2]=v++;
        z=trans(tmp);
        qword ans=dp[n][0][z]%MOD;
        printf("%lld\n",ans);
}