zoukankan      html  css  js  c++  java
  • 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!
    ");
                                    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!
    ");
                    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,&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("
    ");
            }
            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)
    ",i,j);
                                    printf("Status:");
                                    for (int k2=0;k2<m;k2++)printf("%d ",lstp[k][k2]);
                                    printf("
    ");
                                    printf("Value:%lld
    ",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
    ",ans);
    }
  • 相关阅读:
    SCU 3133(博弈)
    SCU 3132(博弈)
    hdu 5183(hash)
    hdu3329(2次dfs)
    hdu5179(数位dp)
    zoj2314(有上下界的网络流)
    CF 519E(树上倍增求lca)
    hdu1251(Trie树)
    SCU 2009(数位dp)
    【Leetcode】Letter Combinations of a Phone Number
  • 原文地址:https://www.cnblogs.com/mhy12345/p/4465251.html
Copyright © 2011-2022 走看看