POJ1739

最新推荐文章于 2020-08-27 12:21:46 发布
最新推荐文章于 2020-08-27 12:21:46 发布
阅读量910 收藏 1
点赞数
分类专栏： ACM--题解汇总 ACM--插头DP 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013480600/article/details/20552215
版权

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;
}

focus_best
关注
专栏目录
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
POJ.rar_poj java_poj1048
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
POJ 1739 Tony's Tour
tmeteorj的专栏
03-06 619
题意：给定n*m的带障碍格子图，求从左下角走到右下角的哈密顿路的总数。 题解：更进一步的插头DP，主要解法可以参照我的上篇日志：http://blog.csdn.net/tmeteorj/article/details/8635090。 改动之处在于单向插头，上篇中用01和10分别代表左右括号，这道题则需要加11作为单向括号（因为它在括号序列状态中是没有与之匹配的括号的） #include
POJ1739 Tony's Tour
qq_36782366的博客
07-28 575
题目链接:poj1739 题目大意： 现在有一个N*M(1 输入：输入包含多组实例。每个实例的第一行为N和M，接下来是一个N*M的字符矩阵，其中‘#’表示障碍格，‘.‘表示好格。以一行0 0表示输入结束。 输出：输出有多少种行走方法。 分析：插头DP问题，且和HDU3377很类似： hdu3377博客题解 既然从左下角到右下角找一条经过所有点的路，那么我们在最后一行后面再加一行全
poj 1739（男人八题之插头DP）
志当存高远
06-08 1864
Tony's Tour Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 1680   Accepted: 751 Description A square township has been divided up into n*m(n rows and m column
【连通性状态压缩DP】poj1739
Evil.livE
07-31 4046
<br />极其恶心的一道状态压缩dp，很多细节的地方想得我头昏脑胀，做这道题差不多花了整整一天的时间吧（调到凌晨6.00），想啊想，草稿纸都花了几十张，方法和标准做法有点不一样，和cdq2008年论文中提到的方法差不多。<br /> <br />首先这道题是要我们求从一个图的左下角至右下角的哈密顿路径的条数，因为起点和终点确定了，所以可以转化为求哈密顿回路，默认左下角和右下角的方块已经连通就可以了。<br /> <br />关于状态的设计也是参考cdq2008年论文里介绍的‘插头’和‘轮廓线’的方法：<b
poj 1739 Tony's Tour(插头dp)
ACM之梦
01-30 576
题意： 给出地图，起点是(N,1),终点是(N,M),有障碍物，求有多少种方案能从起点到终点。 题解： 非环形的插头dp，特判一些起点和终点的dp，还要注意一点，从上往下dp的时候因为起点是左下角，所以不存在不建立新插头的方案！不然未走的空格子就被计算成了路径，反而增加累赘的方案数。 #include #include #include #include #include #inc
jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c
09-22
标题中的"jihe.rar_2289_POJ 3714_poj3714_poj3714 Ra_visual c" 提到了一个压缩文件，可能包含有关编程竞赛或算法解决的资源，特别是与POJ（Problem On Judge）平台上的问题3714相关的。"Ra_visual c"可能指的是...
poj2775.rar_poj_poj 27_poj27_poj2775
09-23
标签"poj poj_27 poj27 poj2775"进一步确认了这是一道关于POJ平台的编程挑战，其中"poj_27"可能是表示第27类问题或者某种分类，而"poj27"可能是对"poj2775"的简写。 压缩文件中的"www.pudn.com.txt"可能是一个链接...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ 1739
weixin_30915951的博客
08-15 81
楼教主男人八题之一。。。 题目大意： 求从左下角经过所有非障碍点一次到达右下角的方案数 这里不是求回路，但是我们可以考虑，在最下面一行再增加一行，那么就可以当做求此时左下角到右下角的回路总数，那么就转化成了陈丹琦论文的URAL1519的 方法了 但是最后一行添加的格子必须是最后一条直线跑的，也就是除了左下角和右下角中间的点只能有水平方向上的插头 1 #incl...
POJ1739 基于连通性的状态压缩dp
woshitanwei的专栏
05-21 1819
<br />题目：http://poj.org/problem?id=1739<br />这种题新手必须仔细钻研大牛们的代码！！！！这一点很重要<br />大体上与陈丹琪的例题差不多，就是n*m的矩阵求从左下角到右下角的一条满足遍历除障碍外的所有格点的路的方案数。<br />首先膜拜陈丹琪的论文：http://wenku.baidu.com/view/f49801155f0e7cd18425368e.html<br />定义dp[l,i,j]为l行以上(包括l行[1,1]到[l,i])中已构成的所有连通块构
POJ-1739：Tony's Tour
Mitsuha_的博客
08-23 497
POJ-1739：Tony's TourA square township has been divided up into n*m(n rows and m columns) square plots (1<=N,M<=8),some of them are blocked, others are unblocked. The Farm is located in the lower left plot and the Market is located in the lower right plot.
poj1739 Tony‘s Tour
binarycopycode
08-27 162
http://poj.org/problem?id=1739 普通通路问题，左下角走到右下角，那么只要在上面加两层壳，一层全不可走，一层全可走，那么总左下角走到右下角是一条路径且他和从外面这层壳的唯一路径走形成了一条回路，问题就转换成了直接求回路，就等同于模板题了 https://blog.csdn.net/liufengwei1/article/details/108114948 #include<cstdio> using namespace std; typedef long lo
poj 1739 Tony's Tour 插头dp模板题
sepNINE的专栏
07-23 1302
题意： 给一个迷宫，求左下角到右下角的路径数。 分析： 插头dp的模板题，建议先看cdq的论文再看代码，这份代码在模板基础上略微有改动。论文地址http://wenku.baidu.com/view/ed2b3e23482fb4daa58d4b74.html 代码： #include using namespace std; const int maxD=16; const int H
poj 1739 插头DP
马德里小铁匠的铁匠铺
04-16 734
和上一题很像，只需要增加两行就行。。。
POJ-1739-插头dp
walk_up的专栏
07-07 804
int dp[10][10][19690]; //传说中的三进制 int bit[]={1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683}; char ok[13][13]; int st[1000][10], go[19900], p[900][10], slack[10]; int k, num, tot; int main() { int n
POJ编程题解资源集合
"这些题目是来自POJ (Programming Online Judge) 的一系列算法练习题，涵盖了基础到中等难度的编程问题。题目涉及了各种算法和数据结构，包括但不限于数学计算、字符串处理、逻辑推理、递归、动态规划、位运算等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值