POJ1739

POJ1739 Tony's Tour

现在有一个N*M(1<=N,M<=8)的矩阵,矩阵中有好格和坏格,坏格子不能走,现在要求你求从矩阵左下角走到矩阵右下角(这两个格肯定是好格)且经过矩阵中所有的好格一次 共有多少种走法?

输入:输入包含多组实例。每个实例的第一行为N和M,接下来是一个N*M的字符矩阵,其中‘#’表示障碍格,‘.‘表示好格。以一行0 0表示输入结束。

输出:输出有多少种行走方法。

分析:插头DP问题,且和HDU3377很类似:

http://blog.csdn.net/u013480600/article/details/20478989

既然从左下角到右下角找一条经过所有点的路,那么我们在最后一行后面再加一行全由可行格构成的行,且要求这一行的格子:

该行首格只处理有上插头无左插头的情况,

该行中间所有格子只处理有左插头无上插头的情况,

该行尾格只处理左插头和上插头都存在的情况。

AC代码:110ms 一次AC

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;
const int MAXD=15;
int N,M;
int ex,ey;//最后一个好格的坐标
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
long long sum;//记录最终的最大值
struct HASHMAP
{
    int size,head[HASH],next[STATE];//next[i]=j表示第i个状态后面链接着第j个状态
    long long state[STATE];//state[i]=S表第i个状态是S
    long long f[STATE];//f[i]=x表第i个状态有x种情况
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    void push(long long st, long long num)
    {
        long long h = st%HASH;
        int i;
        for(i=head[h]; i!=-1; i=next[i])
        {
            if(state[i]==st)
            {
                f[i]+=num;
                return ;
            }
        }
        next[size]=head[h];
        head[h]=size;
        f[size]=num;
        state[size]=st;
        size++;
    }
} hm[2];
void decode(int *code,long long st)//st->code
{
    for(int i=M; i>=0; i--)
    {
        code[i]=st&7;
        st>>=3;
    }
}
long long encode(int *code)//code->st
{
    int ch[MAXD];
    memset(ch,-1,sizeof(ch));
    ch[0]=0;
    int cnt=1;
    long long st=0;
    for(int i=0; i<=M; i++)
    {
        if( ch[code[i]]==-1 ) ch[code[i]]= cnt++;
        code[i]=ch[code[i]];
        st<<=3;
        st|=code[i];
    }
    return st;
}
void shift(int *code)//处理完了一行的最后一列,将code整体右移一位,首位添0
{
    for(int i=M; i>=1; i--)
        code[i]=code[i-1];
    code[0]=0;
}
void dpblock(int i,int j)//坏格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left==0&&up==0)//全无插头时,才能生成新状态
        {
            if(j==M)//j为当前行最后一列,需要右移一位
                shift(code);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
        }
    }
}
void dpblank(int i,int j)//好格
{
    //此时的N已经执行了 N=N+1 操作了
    if(i==N&&j==1)
    {
        for(int k=0; k<hm[cur].size; k++)
        {
            long long st=hm[cur].state[k];
            long long num = hm[cur].f[k];
            int code[MAXD];
            decode(code,st);
            int left=code[j-1] ,up=code[j];
            if(left==0&&up)//只有上插头
            {
                if(mp[i][j+1]==1)//(i,j)右边是个好格
                {
                    code[j-1]=0;
                    code[j]=left+up;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num );
                }
            }
        }
    }
    else if(i==N&&j<=M-1&&j>=2)
    {
        for(int k=0; k<hm[cur].size; k++)
        {
            long long st=hm[cur].state[k];
            long long num = hm[cur].f[k];
            int code[MAXD];
            decode(code,st);
            int left=code[j-1] ,up=code[j];
            if(left&&up==0)//只有左插头
            {
                if(mp[i][j+1]==1)//(i,j)右边是个好格
                {
                    code[j-1]=0;
                    code[j]=left+up;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num );
                }
            }
        }
    }
    else if(i==N&&j==M)
    {
        for(int k=0; k<hm[cur].size; k++)
        {
            long long st=hm[cur].state[k];
            long long num = hm[cur].f[k];
            int code[MAXD];
            decode(code,st);
            int left=code[j-1] ,up=code[j];
            if(left&&up)//两个插头都存在
            {
                sum +=num;//总数增加
            }
        }
    }
    else
        for(int k=0; k<hm[cur].size; k++)
        {
            long long st=hm[cur].state[k];
            long long num = hm[cur].f[k];
            int code[MAXD];
            decode(code,st);
            int left=code[j-1] ,up=code[j];
            if(left>0&&up>0)//都有插头
            {
                if(left!=up)//合并两个连通分量
                {
                    code[j-1]=code[j]=0;
                    for(int l=0; l<=M; l++)
                        if(code[l]==up)
                            code[l]=left;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num );
                }
                else if(i==ex&&j==ey)//最后一个好格
                {
                    sum +=num;//总数增加
                    code[j-1]=code[j]=0;
                    //if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    //hm[1-cur].push( encode(code),num );
                }
                //if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                //    hm[1-cur].push( encode(code),num );
                //这两句不能从上面提到这里来,因为这个大块中不仅是这两种情况
            }
            else if(left>0||up>0)//其中一个有插头另一个没有
            {
                if(mp[i][j+1]==1)//(i,j)右边是个好格
                {
                    code[j-1]=0;
                    code[j]=left+up;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num );
                }
                if(mp[i+1][j]==1)//(i,j)下面是个好格
                {
                    code[j-1]=left+up;
                    code[j]=0;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num );
                }
            }
            else//两个都没插头
            {
                if(mp[i][j+1]==1&&mp[i+1][j]==1)//(i,j)格的右边和下边是可行格,才可以新生成一个连通分量
                {
                    //这里不会出现j是最后一列的情况
                    int max_c=1;//表示当前扫描到的最大插头编号
                    for(int l=0; l<=M; l++)
                        if(max_c<code[l])
                            max_c = code[l];
                    code[j-1]=code[j]=max_c+1;
                    hm[1-cur].push( encode(code),num );
                }
            }
        }
}
void init()
{
    ex=ey=0;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            char a;
            scanf("%c",&a);
            if(a=='.')
            {
                mp[i][j]=1;//好格为1
            }
        }
        getchar();//读'\n'
    }
    if(mp[N][1]==0 || mp[N][M]==0)//最后一行的左角和右角不可达
    {
        ex=ey=0;
    }
    else//否则,最后一个必走格是我们添加的那行尾
    {
        ex=N+1;
        ey=M;
    }
    for(int j=1; j<=M; j++) //添加最后一行必走格
        mp[N+1][j]=1;
    N=N+1;//添加了一行
}
void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j])
                dpblank(i,j);
            else
                dpblock(i,j);
            cur=1-cur;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];
    printf("%I64d\n",sum);
}
int main()
{
    while(scanf("%d%d",&N,&M)==2&&N&&M)
    {
        getchar();//读\n
        if(N==1&&M==1)//只有一格特殊处理
        {
            char x;
            x=getchar();
            if(x=='.')printf("1\n");
            else printf("0\n");

            continue;
        }
        else if(M==1)//只有一列多行的情况
        {
            char x[MAXD];
            int ok=1;
            for(int i=1; i<=N; i++)
            {
                x[i]=getchar();
                if(x[i]=='.'&&i<N)
                    ok=0;
            }
            if(x[N]=='#')
                ok = 0;
            printf("%d\n",ok);

            continue;
        }
        init();
        if(ex==0)//全是坏格子
        {
            printf("0\n");
            continue;
        }
        solve();
    }
    return 0;
}

解法二:在最后一行后面添加两行,其中添加的第一行除了首尾两格是好格外其他都是坏格子,添加的第二行全是好格子,如此即可。且全是必走格子,找一条从经过所有可行格的回路即可。

AC代码:110ms,一次AC

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;
const int MAXD=15;
int N,M;
int ex,ey;//最后一个好格的坐标
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
long long sum;//记录最终的最大值
struct HASHMAP
{
    int size,head[HASH],next[STATE];//next[i]=j表示第i个状态后面链接着第j个状态
    long long state[STATE];//state[i]=S表第i个状态是S
    long long f[STATE];//f[i]=x表第i个状态有x种情况
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    void push(long long st, long long num)
    {
        long long h = st%HASH;
        int i;
        for(i=head[h]; i!=-1; i=next[i])
        {
            if(state[i]==st)
            {
                f[i]+=num;
                return ;
            }
        }
        next[size]=head[h];
        head[h]=size;
        f[size]=num;
        state[size]=st;
        size++;
    }
} hm[2];
void decode(int *code,long long st)//st->code
{
    for(int i=M; i>=0; i--)
    {
        code[i]=st&7;
        st>>=3;
    }
}
long long encode(int *code)//code->st
{
    int ch[MAXD];
    memset(ch,-1,sizeof(ch));
    ch[0]=0;
    int cnt=1;
    long long st=0;
    for(int i=0; i<=M; i++)
    {
        if( ch[code[i]]==-1 ) ch[code[i]]= cnt++;
        code[i]=ch[code[i]];
        st<<=3;
        st|=code[i];
    }
    return st;
}
void shift(int *code)//处理完了一行的最后一列,将code整体右移一位,首位添0
{
    for(int i=M; i>=1; i--)
        code[i]=code[i-1];
    code[0]=0;
}
void dpblock(int i,int j)//坏格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left==0&&up==0)//全无插头时,才能生成新状态
        {
            if(j==M)//j为当前行最后一列,需要右移一位
                shift(code);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
        }
    }
}
void dpblank(int i,int j)//好格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        long long num = hm[cur].f[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left>0&&up>0)//都有插头
        {
            if(left!=up)//合并两个连通分量
            {
                code[j-1]=code[j]=0;
                for(int l=0; l<=M; l++)
                    if(code[l]==up)
                        code[l]=left;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
            else if(i==ex&&j==ey)//最后一个好格
            {
                sum +=num;//总数增加
                code[j-1]=code[j]=0;
                //if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                //hm[1-cur].push( encode(code),num );
            }
            //if(j==M)shift(code);//j为当前行最后一列,需要右移一位
            //    hm[1-cur].push( encode(code),num );
            //这两句不能从上面提到这里来,因为这个大块中不仅是这两种情况
        }
        else if(left>0||up>0)//其中一个有插头另一个没有
        {
            if(mp[i][j+1]==1)//(i,j)右边是个好格
            {
                code[j-1]=0;
                code[j]=left+up;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
            if(mp[i+1][j]==1)//(i,j)下面是个好格
            {
                code[j-1]=left+up;
                code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
            }
        }
        else//两个都没插头
        {
            if(mp[i][j+1]==1&&mp[i+1][j]==1)//(i,j)格的右边和下边是可行格,才可以新生成一个连通分量
            {
                //这里不会出现j是最后一列的情况
                int max_c=1;//表示当前扫描到的最大插头编号
                for(int l=0; l<=M; l++)
                    if(max_c<code[l])
                        max_c = code[l];
                code[j-1]=code[j]=max_c+1;
                hm[1-cur].push( encode(code),num );
            }
        }
    }
}
void init()
{
    ex=ey=0;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            char a;
            scanf("%c",&a);
            if(a=='.')
            {
                mp[i][j]=1;//好格为1
            }
        }
        getchar();//读'\n'
    }
    if(mp[N][1]==0 || mp[N][M]==0)//最后一行的左角和右角不可达
    {
        ex=ey=0;
    }
    else//否则,最后一个必走格是我们添加的那行尾
    {
        ex=N+2;
        ey=M;
    }
    for(int j=1; j<=M; j++) //添加一行除首尾两格是好格外其他都是障碍格
    {
        if(j==1||j==M)
            mp[N+1][j]=1;
    }
    for(int j=1; j<=M; j++) //添加一行全好格
    {
        mp[N+2][j]=1;
    }
    N=N+2;//添加了一行
}
void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j])
                dpblank(i,j);
            else
                dpblock(i,j);
            cur=1-cur;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];
    printf("%I64d\n",sum);
}
int main()
{
    while(scanf("%d%d",&N,&M)==2&&N&&M)
    {
        getchar();//读\n
        if(N==1&&M==1)//只有一格特殊处理
        {
            char x;
            x=getchar();
            if(x=='.')printf("1\n");
            else printf("0\n");

            continue;
        }
        else if(M==1)//只有一列多行的情况
        {
            char x[MAXD];
            int ok=1;
            for(int i=1; i<=N; i++)
            {
                x[i]=getchar();
                if(x[i]=='.'&&i<N)
                    ok=0;
            }
            if(x[N]=='#')
                ok = 0;
            printf("%d\n",ok);

            continue;
        }
        init();
        if(ex==0)//全是坏格子
        {
            printf("0\n");
            continue;
        }
        solve();
    }
    return 0;
}

发布了733 篇原创文章 · 获赞 161 · 访问量 85万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览