POJ3009-Curling 2.0

转载请注明出处:優YoU http://user.qzone.qq.com/289065406/blog/1303548481

 

大致题意:

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

 

题意不难懂,我大致翻译一下:

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

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

 

注意的是:

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

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

 

解题思路:

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

要先明确:

0为滑动区域

1为石头区域

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

3为终点,不可滑动区域

 

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

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

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

(4)       滑动过程中冰壶不允许出界

 基于上面的原则,不难发现:

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

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

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

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

 

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

2种方法:

DFS+Vector+剪枝

DFS+回溯+剪枝

 

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

 

DFS用于寻找路径,回溯(或Vector)用于还原棋盘状态,剪枝用于优化

 

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

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

  1 /*DFS+回溯+剪枝*/
2
3 //Memory Time
4 //188K 329MS
5
6 #include<iostream>
7 using namespace std;
8
9 const int inf=11;
10
11 typedef class
12 {
13 public:
14 int r,c; //冰壶当前位置
15 bool status; //status冰壶当前状态:运动true ,静止false
16 }SE;
17
18 SE s,e; //记录冰壶起止点
19 int w,h; //场地size
20 int MinStep; //最短路
21 int board[30][30]; //场地
22
23 void DFS(int i,int j,bool status,int direction,int step,bool flag)
24 { //direction:冰壶当前运动方向 North:0 West:1 South:2 East:3
25 //flag:是否消除direction方向下一格位置的石头
26
27 if(step>10) //剪枝,超过10步的走法就不再考虑了
28 return;
29
30 if(board[i][j]==3) //终点
31 {
32 if(MinStep>step)
33 MinStep=step;
34 return;
35 }
36
37 if(flag) //消除石头
38 {
39 switch(direction)
40 {
41 case 0: {board[i-1][j]=0; break;}
42 case 1: {board[i][j-1]=0; break;}
43 case 2: {board[i+1][j]=0; break;}
44 case 3: {board[i][j+1]=0; break;}
45 }
46 }
47
48 if(!status) //静止
49 {
50 if(i-1>=1 && (board[i-1][j]==0 || board[i-1][j]==3)) //North
51 DFS(i-1,j,true,0,step+1,false);
52
53 if(j-1>=1 && (board[i][j-1]==0 || board[i][j-1]==3)) //West
54 DFS(i,j-1,true,1,step+1,false);
55
56 if(i+1<=h && (board[i+1][j]==0 || board[i+1][j]==3)) //South
57 DFS(i+1,j,true,2,step+1,false);
58
59 if(j+1<=w && (board[i][j+1]==0 || board[i][j+1]==3)) //East
60 DFS(i,j-1,true,3,step+1,false);
61 }
62 else if(status) //运动
63 {
64 switch(direction)
65 {
66 case 0:
67 {
68 if(i-1<1) //预判下一步是否越界
69 return;
70 else
71 {
72 if(board[i-1][j]==0) //下一位置为0且不越界,继续运动
73 DFS(i-1,j,true,0,step,false);
74 else if(board[i-1][j]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
75 DFS(i,j,false,0,step,true);
76 else if(board[i-1][j]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
77 DFS(i-1,j,false,0,step,false);
78 }
79
80 break;
81 }
82 case 1:
83 {
84 if(j-1<1) //预判下一步是否越界
85 return;
86 else
87 {
88 if(board[i][j-1]==0) //下一位置为0且不越界,继续运动
89 DFS(i,j-1,true,1,step,false);
90 else if(board[i][j-1]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
91 DFS(i,j,false,1,step,true);
92 else if(board[i][j-1]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
93 DFS(i,j-1,false,1,step,false);
94 }
95
96 break;
97 }
98 case 2:
99 {
100 if(i+1>h) //预判下一步是否越界
101 return;
102 else
103 {
104 if(board[i+1][j]==0) //下一位置为0且不越界,继续运动
105 DFS(i+1,j,true,2,step,false);
106 else if(board[i+1][j]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
107 DFS(i,j,false,2,step,true);
108 else if(board[i+1][j]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
109 DFS(i+1,j,false,2,step,false);
110 }
111
112 break;
113 }
114 case 3:
115 {
116 if(j+1>w) //预判下一步是否越界
117 return;
118 else
119 {
120 if(board[i][j+1]==0) //下一位置为0且不越界,继续运动
121 DFS(i,j+1,true,3,step,false);
122 else if(board[i][j+1]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
123 DFS(i,j,false,3,step,true);
124 else if(board[i][j+1]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
125 DFS(i,j+1,false,3,step,false);
126 }
127
128 break;
129 }
130 }
131 }
132
133 if(flag) //回溯前还原石头,即还原上一步的棋盘状态
134 {
135 switch(direction)
136 {
137 case 0: {board[i-1][j]=1; break;}
138 case 1: {board[i][j-1]=1; break;}
139 case 2: {board[i+1][j]=1; break;}
140 case 3: {board[i][j+1]=1; break;}
141 }
142 }
143
144 return;
145 }
146
147 int main(void)
148 {
149 while(cin>>w>>h)
150 {
151 if(!w && !h)
152 break;
153
154 /*Structure the Board*/
155
156 MinStep=inf;
157
158 for(int i=1;i<=h;i++)
159 for(int j=1;j<=w;j++)
160 {
161 cin>>board[i][j];
162
163 if(board[i][j]==2)
164 {
165 s.r=i;
166 s.c=j;
167 s.status=false;
168 board[i][j]=0; //记录起点位置后,把它作为0处理
169 }
170 if(board[i][j]==3) //终点是特别位置,冰壶经过或到达该格都会停止
171 {
172 e.r=i;
173 e.c=j;
174 }
175 }
176
177 /*Search the min path*/
178
179 DFS(s.r , s.c , s.status , 0 , 0 , false);
180
181 if(MinStep<=10)
182 cout<<MinStep<<endl; //DFS里面虽然剪枝了,但是可能把全部走法都剪了,因此还是要判断
183 else
184 cout<<-1<<endl;
185
186 }
187 return 0;
188 }

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

 

  1 /*DFS+Vector+剪枝*/
2
3 //TLE
4 //万恶的POJ好像和STL不兼容,剪枝还是超时
5 //vector的优势无法发挥啊。。。
6
7 #include<iostream>
8 #include<vector>
9 using namespace std;
10
11 const int inf=11;
12
13 typedef class
14 {
15 public:
16 int r,c; //冰壶当前位置
17 bool status; //status冰壶当前状态:运动true ,静止false
18 }SE;
19
20 SE s,e; //记录冰壶起止点
21 int w,h; //场地size
22 int MinStep; //最短路
23
24 void DFS(vector<vector<int> >board,int i,int j,bool status,int direction,int step,bool flag)
25 { //direction:冰壶当前运动方向 North:0 West:1 South:2 East:3
26 //flag:是否消除direction方向下一格位置的石头
27
28 if(step>10) //剪枝,超过10步的走法就不再考虑了
29 return;
30
31 if(board[i][j]==3) //终点
32 {
33 if(MinStep>step)
34 MinStep=step;
35 return;
36 }
37
38 if(flag) //消除石头
39 {
40 switch(direction)
41 {
42 case 0: {board[i-1][j]=0; break;} //board用vector表示的目的就是为了在当前步删除某位置的石头时
43 case 1: {board[i][j-1]=0; break;} //前一步并不会删除该位置的石头
44 case 2: {board[i+1][j]=0; break;}
45 case 3: {board[i][j+1]=0; break;}
46 }
47 }
48
49 if(!status) //静止
50 {
51 if(i-1>=1 && (board[i-1][j]==0 || board[i-1][j]==3)) //North
52 DFS(board,i-1,j,true,0,step+1,false);
53
54 if(j-1>=1 && (board[i][j-1]==0 || board[i][j-1]==3)) //West
55 DFS(board,i,j-1,true,1,step+1,false);
56
57 if(i+1<=h && (board[i+1][j]==0 || board[i+1][j]==3)) //South
58 DFS(board,i+1,j,true,2,step+1,false);
59
60 if(j+1<=w && (board[i][j+1]==0 || board[i][j+1]==3)) //East
61 DFS(board,i,j-1,true,3,step+1,false);
62 }
63 else if(status) //运动
64 {
65 switch(direction)
66 {
67 case 0:
68 {
69 if(i-1<1) //预判下一步是否越界
70 return;
71 else
72 {
73 if(board[i-1][j]==0) //下一位置为0且不越界,继续运动
74 DFS(board,i-1,j,true,0,step,false);
75 else if(board[i-1][j]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
76 DFS(board,i,j,false,0,step,true);
77 else if(board[i-1][j]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
78 DFS(board,i-1,j,false,0,step,false);
79 }
80
81 break;
82 }
83 case 1:
84 {
85 if(j-1<1) //预判下一步是否越界
86 return;
87 else
88 {
89 if(board[i][j-1]==0) //下一位置为0且不越界,继续运动
90 DFS(board,i,j-1,true,1,step,false);
91 else if(board[i][j-1]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
92 DFS(board,i,j,false,1,step,true);
93 else if(board[i][j-1]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
94 DFS(board,i,j-1,false,1,step,false);
95 }
96
97 break;
98 }
99 case 2:
100 {
101 if(i+1>h) //预判下一步是否越界
102 return;
103 else
104 {
105 if(board[i+1][j]==0) //下一位置为0且不越界,继续运动
106 DFS(board,i+1,j,true,2,step,false);
107 else if(board[i+1][j]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
108 DFS(board,i,j,false,2,step,true);
109 else if(board[i+1][j]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
110 DFS(board,i+1,j,false,2,step,false);
111 }
112
113 break;
114 }
115 case 3:
116 {
117 if(j+1>w) //预判下一步是否越界
118 return;
119 else
120 {
121 if(board[i][j+1]==0) //下一位置为0且不越界,继续运动
122 DFS(board,i,j+1,true,3,step,false);
123 else if(board[i][j+1]==1) //下一位置为1且不越界,停止运动,并消除下一位置的石头
124 DFS(board,i,j,false,3,step,true);
125 else if(board[i][j+1]==3) //下一位置为3且不越界,运动到位置3后停止运动,游戏结束
126 DFS(board,i,j+1,false,3,step,false);
127 }
128
129 break;
130 }
131 }
132 }
133
134 return;
135 }
136
137 int main(void)
138 {
139 while(cin>>w>>h)
140 {
141 if(!w && !h)
142 break;
143
144 /*Structure the Board*/
145
146 MinStep=inf;
147 vector<vector<int> >board(h+1,vector<int>(w+1));
148
149 for(int i=1;i<=h;i++)
150 for(int j=1;j<=w;j++)
151 {
152 cin>>board[i][j];
153
154 if(board[i][j]==2)
155 {
156 s.r=i;
157 s.c=j;
158 s.status=false;
159 board[i][j]=0; //记录起点位置后,把它作为0处理
160 }
161 if(board[i][j]==3) //终点是特别位置,冰壶经过或到达该格都会停止
162 {
163 e.r=i;
164 e.c=j;
165 }
166 }
167
168 /*Search the min path*/
169
170 DFS(board , s.r , s.c , s.status , 0 , 0 , false);
171
172 if(MinStep<=10)
173 cout<<MinStep<<endl; //DFS里面虽然剪枝了,但是可能把全部走法都剪了,因此还是要判断
174 else
175 cout<<-1<<endl;
176
177 /*Relax*/
178
179 // board.swap(vector<vector<int> >()); //POJ好像禁用swap()
180 }
181 return 0;
182 }

 

 

posted on 2011-07-31 01:22  小優YoU  阅读(322)  评论(1编辑  收藏  举报

导航