POJ3009-Curling 2.0

最新推荐文章于 2022-04-11 09:26:15 发布
最新推荐文章于 2022-04-11 09:26:15 发布
阅读量1w 收藏 5
点赞数 5
分类专栏： POJ解题报告 文章标签： vector 游戏 structure search class path
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyy289065406/article/details/6647671
版权

全解题报告索引目录 -> 【北大ACM – POJ试题分类】

转载请注明出处：http://exp-blog.com

-------------------------------------------------------------------------

 

 

大致题意：

哈哈，玩过“GBA口袋怪兽”的同学看到这题都应该非常容易理解了，“游戏也不过是这样写出来的”O(∩_∩)O哈~

 

题意不难懂，我大致翻译一下：

就是要求把一个冰壶从起点“2”用最少的步数移动到终点“3”

其中0为移动区域，1为石头区域，冰壶一旦想着某个方向运动就不会停止，也不会改变方向（想想冰壶在冰上滑动），除非冰壶撞到石头1 或者 到达终点 3

 

注意的是：

冰壶撞到石头后，冰壶会停在石头前面，此时（静止状态）才允许改变冰壶的运动方向，而该块石头会破裂，石头所在的区域由1变为0. 也就是说，冰壶撞到石头后，并不会取代石头的位置。

终点是一个摩擦力很大的区域，冰壶若到达终点3，就会停止在终点的位置不再移动。

 

解题思路：

其实与其说这是深搜题，我觉得更像模拟题。。。

要先明确：

0为滑动区域

1为石头区域

2为起点，也是可滑动区域

3为终点，不可滑动区域

 

（1）       起点为“2”，也是一个可滑动的区域，所以标记起点位置之后，可以把起点当做0

（2）       注意区分冰壶是运动的还是静止的，若是静止的话，旁边1格有石头是不能走的。

（3）       输出冰壶从2到3的最短路，如果最短路的步数大于10（不包括10），视作无法走到终点（其实这是用来剪枝的）

（4）       滑动过程中冰壶不允许出界

 基于上面的原则，不难发现：

（1）所谓的“走一步”，就是指冰壶从一个静止状态到下一个静止状态，就是说冰壶在运动时经过的“格数”不视作“步数”，也就是说冰壶每次移动的距离都是不定的。

（2）还有就是由于石头会因为冰壶的碰撞而消失，因此冰壶每“走一步”，场地的环境就会改变一次。

（3）基于（2），可以发现本题虽然是要找 “最短路”，但是BFS几乎不可能，因为每“走一步”，场地的状态就要改变一次；而如果该步不满足要求，又要求把场地的状态还原到前一步，这只有DFS能做到。

（4）基于（3），DFS不是BFS，不能简单地用它来找最短路，必须要把所有可能的路一一找出来，再逐一比较它们的步数才能确定最短。但题目值允许1000MS，此时就面临一个超时的问题。所以题目才同时给出“步数超过10则视为失败”的条件，这是用来剪枝的

 

有了上面的分析，就能最终确定本题的解法了：

有2种方法：

DFS+Vector+剪枝

DFS+回溯+剪枝

 

但是由于POJ对STL的“兼容性”很差，我用STL就没见过不TLE的题。。。这题也一样，所以不推荐，其实Vector是很好用的，利用它的特性可以在DFS返回上一步时，自动还原场地状态，而回溯法则需要手动还原场地状态（其实也就8行代码）

 

DFS用于寻找路径，回溯（或Vector）用于还原棋盘状态，剪枝用于优化

 

另外注意的时，如果把冰壶定义为“动静”两种状态，那么搜索时就可以以“格”为单位，+1搜索，详细可以看我的程序，我感觉这样比较简单。我感觉每步都用for找移动的格数会非常烦 

下面我会把两种代码都贴出来，供大家参考。

 

/*DFS+回溯+剪枝*/

//Memory Time 
//188K   329MS 

#include<iostream>
using namespace std;

const int inf=11;

typedef class
{
	public:
		int r,c;     //冰壶当前位置
		bool status; //status冰壶当前状态：运动true ,静止false
}SE;

SE s,e;   //记录冰壶起止点
int w,h;  //场地size
int MinStep;  //最短路
int board[30][30];  //场地

void DFS(int i,int j,bool status,int direction,int step,bool flag)  
{ //direction:冰壶当前运动方向  North:0  West:1  South:2  East:3 
  //flag:是否消除direction方向下一格位置的石头

	if(step>10)   //剪枝，超过10步的走法就不再考虑了
		return;

	if(board[i][j]==3)   //终点
	{
		if(MinStep>step)
			MinStep=step;
		return;
	}

	if(flag)  //消除石头
	{
		switch(direction)
		{
		    case 0: {board[i-1][j]=0; break;}
	    	case 1: {board[i][j-1]=0; break;}
			case 2: {board[i+1][j]=0; break;}
			case 3: {board[i][j+1]=0; break;}
		}
	}
	
	if(!status)  //静止
	{
		if(i-1>=1 && (board[i-1][j]==0 || board[i-1][j]==3))  //North
			DFS(i-1,j,true,0,step+1,false);

		if(j-1>=1 && (board[i][j-1]==0 || board[i][j-1]==3))  //West
			DFS(i,j-1,true,1,step+1,false);

		if(i+1<=h && (board[i+1][j]==0 || board[i+1][j]==3))  //South
			DFS(i+1,j,true,2,step+1,false);

		if(j+1<=w && (board[i][j+1]==0 || board[i][j+1]==3))  //East
			DFS(i,j-1,true,3,step+1,false);
	}
	else if(status)  //运动
	{
		switch(direction)
		{
	        case 0:
				{
					if(i-1<1)  //预判下一步是否越界
						return;
					else
					{
						if(board[i-1][j]==0)          //下一位置为0且不越界，继续运动
							DFS(i-1,j,true,0,step,false);
						else if(board[i-1][j]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(i,j,false,0,step,true);
						else if(board[i-1][j]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(i-1,j,false,0,step,false);
					}

					break;
				}
			case 1:
				{
					if(j-1<1)  //预判下一步是否越界
						return;
					else
					{
						if(board[i][j-1]==0)          //下一位置为0且不越界，继续运动
							DFS(i,j-1,true,1,step,false);
						else if(board[i][j-1]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(i,j,false,1,step,true);
						else if(board[i][j-1]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(i,j-1,false,1,step,false);
					}

					break;
				}
			case 2:
				{
					if(i+1>h)  //预判下一步是否越界
						return;
					else
					{
						if(board[i+1][j]==0)          //下一位置为0且不越界，继续运动
							DFS(i+1,j,true,2,step,false);
						else if(board[i+1][j]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(i,j,false,2,step,true);
						else if(board[i+1][j]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(i+1,j,false,2,step,false);
					}

					break;
				}
			case 3:
				{
					if(j+1>w)  //预判下一步是否越界
						return;
					else
					{
						if(board[i][j+1]==0)          //下一位置为0且不越界，继续运动
							DFS(i,j+1,true,3,step,false);
						else if(board[i][j+1]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(i,j,false,3,step,true);
						else if(board[i][j+1]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(i,j+1,false,3,step,false);
					}

					break;
				}
		}
	}

	if(flag)  //回溯前还原石头，即还原上一步的棋盘状态
	{
		switch(direction)
		{
		    case 0: {board[i-1][j]=1; break;}
	    	case 1: {board[i][j-1]=1; break;}
			case 2: {board[i+1][j]=1; break;}
			case 3: {board[i][j+1]=1; break;}
		}
	}

	return;
}

int main(void)
{
	while(cin>>w>>h)
	{
		if(!w && !h)
			break;

		/*Structure the Board*/

		MinStep=inf;
		
		for(int i=1;i<=h;i++)
			for(int j=1;j<=w;j++)
			{
				cin>>board[i][j];

				if(board[i][j]==2)
				{
					s.r=i;
					s.c=j;
				    s.status=false;
					board[i][j]=0;  //记录起点位置后，把它作为0处理
				}
				if(board[i][j]==3)  //终点是特别位置，冰壶经过或到达该格都会停止
				{
					e.r=i;
					e.c=j;
				}
			}

		/*Search the min path*/

		DFS(s.r , s.c , s.status , 0 , 0 , false);

		if(MinStep<=10)
			cout<<MinStep<<endl;   //DFS里面虽然剪枝了，但是可能把全部走法都剪了，因此还是要判断
		else
			cout<<-1<<endl;

	}
	return 0;
}


 

============华丽的分割线===============

 

/*DFS+Vector+剪枝*/

//TLE
//万恶的POJ好像和STL不兼容，剪枝还是超时
//vector的优势无法发挥啊。。。

#include<iostream>
#include<vector>
using namespace std;

const int inf=11;

typedef class
{
	public:
		int r,c;     //冰壶当前位置
		bool status; //status冰壶当前状态：运动true ,静止false
}SE;

SE s,e;   //记录冰壶起止点
int w,h;  //场地size
int MinStep;  //最短路

void DFS(vector<vector<int> >board,int i,int j,bool status,int direction,int step,bool flag)  
{ //direction:冰壶当前运动方向  North:0  West:1  South:2  East:3 
  //flag:是否消除direction方向下一格位置的石头

	if(step>10)   //剪枝，超过10步的走法就不再考虑了
		return;

	if(board[i][j]==3)   //终点
	{
		if(MinStep>step)
			MinStep=step;
		return;
	}

	if(flag)  //消除石头
	{
		switch(direction)
		{
		    case 0: {board[i-1][j]=0; break;}     //board用vector表示的目的就是为了在当前步删除某位置的石头时
	    	case 1: {board[i][j-1]=0; break;}     //前一步并不会删除该位置的石头
			case 2: {board[i+1][j]=0; break;}
			case 3: {board[i][j+1]=0; break;}
		}
	}
	
	if(!status)  //静止
	{
		if(i-1>=1 && (board[i-1][j]==0 || board[i-1][j]==3))  //North
			DFS(board,i-1,j,true,0,step+1,false);

		if(j-1>=1 && (board[i][j-1]==0 || board[i][j-1]==3))  //West
			DFS(board,i,j-1,true,1,step+1,false);

		if(i+1<=h && (board[i+1][j]==0 || board[i+1][j]==3))  //South
			DFS(board,i+1,j,true,2,step+1,false);

		if(j+1<=w && (board[i][j+1]==0 || board[i][j+1]==3))  //East
			DFS(board,i,j-1,true,3,step+1,false);
	}
	else if(status)  //运动
	{
		switch(direction)
		{
	        case 0:
				{
					if(i-1<1)  //预判下一步是否越界
						return;
					else
					{
						if(board[i-1][j]==0)          //下一位置为0且不越界，继续运动
							DFS(board,i-1,j,true,0,step,false);
						else if(board[i-1][j]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(board,i,j,false,0,step,true);
						else if(board[i-1][j]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(board,i-1,j,false,0,step,false);
					}

					break;
				}
			case 1:
				{
					if(j-1<1)  //预判下一步是否越界
						return;
					else
					{
						if(board[i][j-1]==0)          //下一位置为0且不越界，继续运动
							DFS(board,i,j-1,true,1,step,false);
						else if(board[i][j-1]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(board,i,j,false,1,step,true);
						else if(board[i][j-1]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(board,i,j-1,false,1,step,false);
					}

					break;
				}
			case 2:
				{
					if(i+1>h)  //预判下一步是否越界
						return;
					else
					{
						if(board[i+1][j]==0)          //下一位置为0且不越界，继续运动
							DFS(board,i+1,j,true,2,step,false);
						else if(board[i+1][j]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(board,i,j,false,2,step,true);
						else if(board[i+1][j]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(board,i+1,j,false,2,step,false);
					}

					break;
				}
			case 3:
				{
					if(j+1>w)  //预判下一步是否越界
						return;
					else
					{
						if(board[i][j+1]==0)          //下一位置为0且不越界，继续运动
							DFS(board,i,j+1,true,3,step,false);
						else if(board[i][j+1]==1)          //下一位置为1且不越界，停止运动，并消除下一位置的石头
							DFS(board,i,j,false,3,step,true);
						else if(board[i][j+1]==3)          //下一位置为3且不越界，运动到位置3后停止运动，游戏结束
							DFS(board,i,j+1,false,3,step,false);
					}

					break;
				}
		}
	}

	return;
}

int main(void)
{
	while(cin>>w>>h)
	{
		if(!w && !h)
			break;

		/*Structure the Board*/

		MinStep=inf;
		vector<vector<int> >board(h+1,vector<int>(w+1));

		for(int i=1;i<=h;i++)
			for(int j=1;j<=w;j++)
			{
				cin>>board[i][j];

				if(board[i][j]==2)
				{
					s.r=i;
					s.c=j;
				    s.status=false;
					board[i][j]=0;  //记录起点位置后，把它作为0处理
				}
				if(board[i][j]==3)  //终点是特别位置，冰壶经过或到达该格都会停止
				{
					e.r=i;
					e.c=j;
				}
			}

		/*Search the min path*/

		DFS(board , s.r , s.c , s.status , 0 , 0 , false);

		if(MinStep<=10)
			cout<<MinStep<<endl;   //DFS里面虽然剪枝了，但是可能把全部走法都剪了，因此还是要判断
		else
			cout<<-1<<endl;

		/*Relax*/

	//	board.swap(vector<vector<int> >());      //POJ好像禁用swap()
	}
	return 0;
}


 

小優YoU
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
POJ3009-Curling 2.0【DFS+Vector+回溯+剪枝】
07-31
北大POJ3009-Curling 2.0【DFS+Vector+回溯+剪枝】 解题报告+AC代码
POJ 3009 Curling 2.0 解题报告
12-31
业余爱好。所以，算法不一定好，CODING也不一定佳，效率不一定高，只是能通过online judge而已。
POJ 3009 - Curling 2.0 + Python DFS
xxdragon126的博客
12-04 426
原题链接及参考资料： # http://poj.org/problem?id=3009 # https://exp-blog.com/algorithm/poj/poj3009-curling-2.0/ 一 注意事项 1 初始时刻的运动状态为“静止”，接下来有4种运动方向：上下左右 3当状态为运动时，下一步进行判断： 3.1 继续运动 3.2 遇到石头，则停止，并击碎石头 ...
poj 3009 (深搜求最短路)
weixin_30698297的博客
03-05 155
题目大意就是求在特定规则下的最短路，这个规则包含了消除障碍的操作。用BFS感觉选择消除障碍的时候不同路径会有影响，用DFS比较方便状态的还原（虽然效率比较低），因此这道题目采用DFS来写。 写的第一次提交代码是TLE，原因是忘记总步数>10就应该剪枝的条件。AC代码如下： 1 #include <cstdio> 2 #include <algorithm...
POJ 1979 Red and Black
ZDQQQqq的博客
04-11 145
编程语言：Java 题目链接：http://poj.org/problem?id=1979 题解：简单DFS 结果：AC import java.io.*; import java.util.Scanner; public class Main { static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in))); static PrintWriter
POJ 3009 （dfs）
兜率工的博客
06-15 216
不能被题目的这种纸老虎吓到，就是很平常的一个搜索，就是加了个限定条件是每次搜索只能走一行或者一列，相信自己一定能写出来的。 wa了半天，dfs里面直接判断mmp[i][j]是否能够等于一了，忘了下标会越界。。。。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;cst...
poj之旅——3009
Holylight_Knight
05-07 192
题意：给出一幅图，0表示可走的路，1表示障碍，3表示终点，2表示起点（可视作0），求一个小球由2到3需要撞上障碍或边缘的次数（每撞一次，障碍则消失，重新选定方向，小球将沿次方向一直运动到撞上什么或到终点） 思路：深搜，但有点麻烦。在深搜过程中三个判断：           1.若是0，则继续走           2.若是3，则替换结果           3.若是1，则消除障碍，继续走，
魔兽世界终极版POJ的-测试数据
11-03
这是魔兽世界终极版POJ的-测试数据，找了好久才找到的。 本来想设置为0积分，但是它居然自动收费(o_ _)ﾉ。 看传送门：https://pan.baidu.com/s/1cCIwW8psGDASu2JdZawG3Q
POJ2002-Squares
07-31
北大POJ2002-Squares 解题报告+AC代码
POJ1724-ROADS 测试数据
06-26
POJ1724-ROADS 测试数据。数据来源：CEOI 1998 Round II
POJ3733-Changing Digits【DFS+强剪枝】
08-18
北大POJ3733-Changing Digits【DFS+强剪枝】 解题报告+AC代码
POJ1523 - SPF 测试数据
06-27
POJ1523 - SPF 测试数据。 数据来源：Greater New York 2000 问题H
POJ1010-STAMPS 测试数据
06-23
北大ACＭ-POJ1010 - STAMPS 原比赛（Pacific Northwest 1998）题目的测试数据
POJ---1456.Supermarket测试数据及答案
04-25
POJ---1456.Supermarket测试数据及答案，题目描述:A supermarket has a set Prod of products on sale. It earns a profit px for each product x∈Prod sold by a deadline dx that is measured as an integral ...
POJ1472-Instant Complexity 测试数据
06-24
POJ1472-Instant Complexity 测试数据。数据来源：Southwestern European Regional Contest 1997
poj 3009 ( Curling 2.0 深搜 搜直线）
T_T
09-01 2614
题目链接：http://poj.org/problem?id=3009                                                                                                                                  Curling 2.0 Time Limi
poj 3009(深度搜索)
weiwei2012start的专栏
11-03 735
#include #include #include using namespace std; #define N 22 int map[N][N]; int minstep; int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}}; int w,h; bool check(int x,int y) { if(x>=1 && x=1 && y<=w)
【POJ3009】深度搜索
wifi_hu的博客
03-23 264
  题干网址： 点击打开链接  注意对碰到边界情况的处理，注意对impossible情况的处理，对最小步数的剪枝了解一下，了解一下......#include &lt;iostream&gt; using namespace std; int flag = 0; int go[4][2] = {{-1,0},{1,0},{0,1},{0,-1}}; int a[32][32]; int min...
poj3009Curling 2.0(打冰球，DFS）
不积跬步无以至千里
04-02 241
题意：要求把一个冰壶从起点“2”用最少的步数移动到终点“3”，其中0为移动区域，1为石头区域，冰壶一旦想着某个方向运动就不会停止，也不会改变方向（想想冰壶在冰上滑动），除非冰壶撞到石头1或者到达终点3，（冰球到达边界会滑出去，不会反弹回来）冰壶撞到石头后，冰壶会停在石头前面，此时（静止状态）才允许改变冰壶的运动方向，而该块石头会破裂，石头所在的区域由1变为0. 也就是说，冰壶撞到石头后，并不会取代...
poj3278-分支限界法
最新发布
05-14
POJ3278是一道分支限界法的经典问题，题目描述为： 给定两个整数N和K，有两种操作： 1.将N加1或减1，代价为1。 2.将N乘2，代价为0。 问将N变为K的最小代价是多少。 这道题可以使用分支限界法来求解。我们可以使用一个队列来存储当前状态，每次取出队头元素，进行扩展操作，将扩展出的新状态加入队列中。在扩展操作时，我们需要注意一些剪枝策略，比如： 1.如果当前状态的代价已经大于之前的最小代价，就不需要再扩展该状态。 2.如果当前状态已经出现过了，也不需要再扩展该状态。 3.如果当前状态的N已经超过K，也不需要再扩展该状态。 这些剪枝策略可以有效地减少状态的扩展次数，提高算法效率。 下面是使用C++实现的代码：

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值