POJ1739 Tony's Tour

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

题目链接:poj1739

题目大意：

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

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

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

分析：插头DP问题，且和HDU3377很类似：

hdu3377博客题解

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

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

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

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


所有最后可行格分4中情况即可！！

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;//1<<15=32768
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;//7 111  连通的插头标记相同的数字  最多可以有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]);
            //printf("***1***%I64o生成%I64o\n",st,encode(code));
        }
    }
}

void dpblank(int i,int j)//好格
{
	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];//num是状态为st时的最小费用
			int code[MAXD];
			decode(code,st);
			int left=code[j-1] ,up=code[j];
			if(left==0&&up>0)
			{
				if(mp[i][j+1]!=0)//(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&&1<j&&j<M)//红0只能往右走
    {
    	for(int k=0; k<hm[cur].size; k++)
		{
			long long st=hm[cur].state[k];
			long long num = hm[cur].f[k];//num是状态为st时的最小费用
			int code[MAXD];
			decode(code,st);
			int left=code[j-1] ,up=code[j];
			if(left>0&&up==0)//其中一个有插头另一个没有
			{

				if(mp[i][j+1]!=0)//(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];//num是状态为st时的最小费用
			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]!=0)//(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]!=0)//(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]!=0&&mp[i+1][j]!=0)//(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=0;
	ey=0;
	memset(mp,0,sizeof mp);
	char s[30];
	for(int i=1;i<=N;i++)
	{
		scanf("%s",s+1);
		for(int j=1;j<=M;j++)
		{
			if(s[j]=='.')
				mp[i][j]=1;
			else
				mp[i][j]=0;
		}
	}
	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++;//注意  这里将矩形扩大  方便后面的使用
}

void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);//初始时总代价为0   (注意下  如果是方法数的话则为1）
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j]==1)
                dpblank(i,j);
			else if(mp[i][j]==0)
				dpblock(i,j);
            cur=1-cur;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];

}
int main()
{
    while(~scanf("%d%d",&N,&M)&&N&&M)
    {
    	 char s[5];
		if(N==1&&M==1)//只有一格特殊处理
        {

            scanf("%s",s);
            if(s[0]=='.')printf("1\n");
            else printf("0\n");
            continue;
        }
        else if(M==1)//只有一列多行的情况
        {

            int ok=1;
            for(int i=1; i<=N; i++)
            {
				scanf("%s",s);
                if(s[i]=='.'&&i<N)
                    ok=0;
            }
            if(s[N]=='#')
                ok = 0;
            printf("%d\n",ok);
            continue;
        }
        init();
        solve();
		printf("%I64d\n",sum);
    }
    return 0;
}

解法二：参考博客：点击打开链接对其进行优化。

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

即可行点的函数不需要分四种情况讨论，方便了很多。


#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;//1<<15=32768
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;//7 111  连通的插头标记相同的数字  最多可以有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]);
            //printf("***1***%I64o生成%I64o\n",st,encode(code));
        }
    }
}

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];//num是状态为st时的最小费用
		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]!=0)//(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]!=0)//(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]!=0&&mp[i+1][j]!=0)//(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=0;
	ey=0;
	memset(mp,0,sizeof mp);
	char s[30];
	for(int i=1;i<=N;i++)
	{
		scanf("%s",s+1);
		for(int j=1;j<=M;j++)
		{
			if(s[j]=='.')
				mp[i][j]=1;
			else
				mp[i][j]=0;
		}
	}
	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++)//第一行必须走
	{
		mp[N+1][j]=0;
		mp[N+2][j]=1;
	}
	mp[N+1][1]=mp[N+1][M]=1;
	N+=2;//注意  这里将矩形扩大  方便后面的使用
}

void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);//初始时总代价为0   (注意下  如果是方法数的话则为1）
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j]==1)
                dpblank(i,j);
			else if(mp[i][j]==0)
				dpblock(i,j);
            cur=1-cur;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];

}
int main()
{
    while(~scanf("%d%d",&N,&M)&&N&&M)
    {
    	 char s[5];
		if(N==1&&M==1)//只有一格特殊处理
        {

            scanf("%s",s);
            if(s[0]=='.')printf("1\n");
            else printf("0\n");
            continue;
        }
        else if(M==1)//只有一列多行的情况
        {

            int ok=1;
            for(int i=1; i<=N; i++)
            {
				scanf("%s",s);
                if(s[i]=='.'&&i<N)
                    ok=0;
            }
            if(s[N]=='#')
                ok = 0;
            printf("%d\n",ok);
            continue;
        }
        init();
        solve();
		printf("%I64d\n",sum);
    }
    return 0;
}



倚剑笑紅尘
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ2262-Goldbach's Conjecture
07-29
【标题】"POJ2262-Goldbach's Conjecture"是一个编程竞赛题目，源自北京大学的在线判题系统POJ（Problem Online Judge）。这个题目是基于著名的数学猜想——哥德巴赫猜想（Goldbach's Conjecture）设计的。 【描述...
【连通性状态压缩DP】poj1739
Evil.livE
07-31 4001
<br />极其恶心的一道状态压缩dp，很多细节的地方想得我头昏脑胀，做这道题差不多花了整整一天的时间吧（调到凌晨6.00），想啊想，草稿纸都花了几十张，方法和标准做法有点不一样，和cdq2008年论文中提到的方法差不多。<br /> <br />首先这道题是要我们求从一个图的左下角至右下角的哈密顿路径的条数，因为起点和终点确定了，所以可以转化为求哈密顿回路，默认左下角和右下角的方块已经连通就可以了。<br /> <br />关于状态的设计也是参考cdq2008年论文里介绍的‘插头’和‘轮廓线’的方法：<b
poj 1739 Tony's Tour 插头dp模板题
sepNINE的专栏
07-23 1270
题意： 给一个迷宫，求左下角到右下角的路径数。 分析： 插头dp的模板题，建议先看cdq的论文再看代码，这份代码在模板基础上略微有改动。论文地址http://wenku.baidu.com/view/ed2b3e23482fb4daa58d4b74.html 代码： #include using namespace std; const int maxD=16; const int H
POJ 1739 Tony's Tour 解题报告（插头DP）
SF-_- 的 ACM 博客
11-11 886
楼教主男人八题之一，插头DP。可以直接用Ural1519的代码，将地图那块改下即可。如下图：     就是在原有的地图下方加入两行，求此图的哈密顿回路即可。     代码如下： #include #include #include using namespace std; #define LL long long const int maxn=10007; int m,
poj 1739 Tony's Tour(插头dp)
ACM之梦
01-30 533
题意： 给出地图，起点是(N,1),终点是(N,M),有障碍物，求有多少种方案能从起点到终点。 题解： 非环形的插头dp，特判一些起点和终点的dp，还要注意一点，从上往下dp的时候因为起点是左下角，所以不存在不建立新插头的方案！不然未走的空格子就被计算成了路径，反而增加累赘的方案数。 #include #include #include #include #include #inc
poj1739Tony's Tour【插头DP】楼教主男人八题之一
MissZhou要努力
01-11 727
1A掉这个题简直太太太太爽了好么~~淫家可是萌妹子哟（害羞脸 这个题固定了起点是左下角，终点是右下角，那么就利用这个性质，在maze矩阵下面加两行，倒数第二行中间部分全设成有障碍，最后一行全都设成没障碍，就相当于人为把下面的部分补上了。那么M==2和M==1怎么办？很明显前者是补两行没障碍，后者直接输出0 /******** poj1739 2016.1.11 452K 79MS C++ 49
poj.rar_MáS
09-21
题意：给一个无向图，求从起点s到终点e尽力n条边的路径最小值。 边的数量2<=t<=100(每条边可以重复遍历) 算法：利用dp求出 path[ l ] [ i ] [ k ]=MIN(path[ l ][ i ] [ k ] , path[ l ][ i ] [ j ] + path...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
POJ 1739 Tony's Tour
DS-K的博客
11-06 390
题目链接：http://poj.org/problem?id=1739 题意：求从左下角走到右下角，每个非障碍格子只走一次的方案数。 思路：求简单路径的数量，这个简单路径起点和终点固定，其次要把所有的非障碍格子都访问到。所以分为起点、终点、障碍格子和一般格子，一般格子有两个插头，且不能形成回路，即不能合并已经连通的插头。 #include #include #in
【插头DP】Tony's Tour
wu_yihao的专栏
04-20 636
男人八题之一 本来是要用到独立插头的，但是这道题可以转化， 这样做就可以不求哈密顿路径数量，而求哈密顿回路数量，要简单得多。陈丹琦神牛的文章里介绍的方法。 然后就和Formula 1一模一样了。 因为n要增大4，m要增大2，所以我一开始map[10][10]小了。 然后又没有用long long。还有map没有初始化，调了很久很久。核心是没有问题的。 #incl
【POJ 1739】Tony's Tour
Regina8023
04-02 983
插头dp~
poj1739 Tony‘s Tour
binarycopycode
08-27 138
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
便纵有千种风情
08-23 446
题目链接题意：障碍格子不能走，非障碍格子必须遍历， 要求从左下角走到右下角，问方案数。解:1.添加两行,转化为求回路：.####. … … #include<cstdio> #include<string> #include<cstring> #include<iostream> #include<cmath> #include<algorithm> #include<vector> us
POJ-1739-插头dp
walk_up的专栏
07-07 789
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
Tony's Tour poj1739
霁月难逢 彩云易散
07-09 603
确定了起点和终点的简单路径问题，和简单回路差不多，注意处理起点和终点以及特殊情况即可。 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #incl
POJ2135 Farm Tour —— 最小费用最大流
最新发布
05-25
题目描述 农夫约翰在他的农场里建立了一些水沟，以帮助水从一个地方流到另一个地方。他需要为这些水沟安排一些管道，以便水可以通过它们流动。然而，由于约翰的农场是非常大的，因此在不同位置的水沟之间建立管道的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值