深度优先搜索算法

下面是poj3009 curling2.0的题目。

http://acm.pku.edu.cn/JudgeOnline/problem?id=3009

 

使用的是dfs搜索，代码如下，从中可以体会到dfs搜索的常规特点：

 

//POJ3009 Curling 2.0//使用深度搜索，这题有两个地方需要注意：//1、当球与箱子相邻的时候，球无法滚动，也无法装破箱子。//2、题目有一个限界，当球滚了10次还没有进入目标点，看做不能到达。#include<iostream>#include<cstdio>#include<fstream>#define __DEBUG 0using namespace std;#define MAX 30int map[MAX][MAX];int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};int row,column,step,minStep;int find(int x,int y){//检查球是否在board范围内if( x>=0 && x<row && y>=0 && y< column)return 1;elsereturn 0;}void DFS(int step,int x,int y){if( step >= 10 )//剪枝条件“>=10”放弃搜索return;step++;//换一个方向才算步数加1for(int k=0;k<4;k++){int nextX=x+dir[k][0];int nextY=y+dir[k][1];if( map[nextX][nextY]!=1 && find(nextX,nextY)){ //球的下一步不能是block，同时不能超出board的范围while( map[nextX][nextY]!=3 && map[nextX][nextY]!=1 && find(nextX,nextY) ){//找到目标点停止 遇到block停止 超出board的范围停止nextX += dir[k][0];//朝先前的方向一直走下去，知道遇到block或targetnextY += dir[k][1];}if( map[nextX][nextY]==3){//到达目标点if(step<minStep)minStep=step;//cout<<minStep<<endl;return;}else if( map[nextX][nextY]==1){//撞到blockmap[nextX][nextY]=0;//清空blocknextX -= dir[k][0];nextY -= dir[k][1];DFS(step,nextX,nextY);//继续搜索map[nextX][nextY]=1;//如果某次DFS失败未能找到目标点，就需要恢复block，重新开始一次搜索}}}return ;}int main(){//ifstream in("test.txt");int startX,startY;while(1){//in>>column>>row;scanf("%d %d",&column ,&row);if( column ==0 && row==0)break;for(int i=0; i<row ;i++){for(int j=0; j<column ;j++){//in>>map[i][j];scanf("%d",&map[i][j]);if( 2 == map[i][j]){startX=i;startY=j;}}}if(__DEBUG){cout<<startX<<" "<<startY<<endl;}minStep=11;DFS(0,startX,startY);if(minStep<=10)//如果步数超过10次，搜索失败，不存在合适的最短路径cout<<minStep<<endl;elsecout<<-1<<endl;}return 0;}

 

总结一下：

 

1、使用dfs搜索求解最优解，往往需要需要多次深入搜索和回溯的过程，然后选择所有搜索到的解中最优的解。还有就是dfs搜索返回时，一般都是需要恢复原来状态的，以便于下次的搜索。

 

下面是POJ2676 Sudoku：

http://acm.pku.edu.cn/JudgeOnline/problem?id=2676

 

这道题目的本质在于使用dfs回溯的思想解题。这种方法尤其是在存在多个解，只要找到一个解的情况下，非常有用。

 

//POJ2676:Sudoku/*用1-9的数字去填充上面的9*9表格,要求如下 1.每一行的九个格子中1-9各出现一次 2.每一列的九个格子中1-9各出现一次 3.还有如上图用粗线隔开的3*3的小块的九个格子中1-9个数字也各出现一次 有可能不止一种解,只要输出一种合适的解即可 *//*思路：使用回溯法，DFS并使用标记法剪枝静下心来分析，不难*/#include<iostream>#include<fstream>#include<ctime>using namespace std;bool rUsed[9][10],cUsed[9][10],sUsed[9][10];//用于标记某行、某列、某个3*3小方格上哪些数字已经被使用过了int pos[100];//还没有填充数字的方格位置int nullNum;int table[9][9];bool DFS_SUDO;void print(){for(int i=0;i<9;i++){for(int j=0;j<9 ;j++)cout<<table[i][j]<<" ";cout<<endl;}}void DFS(int n){if(n>=nullNum){DFS_SUDO=true;print();return;}int r=pos[n]/9;//在第r行int c=pos[n]%9;//在第c列int k= (r/3)*3+(c/3);//在第k个小方格 for(int i=1; i<=9 && !DFS_SUDO;i++){if( cUsed[c][i] ) continue;if( rUsed[r][i] ) continue;if( sUsed[k][i] ) continue;cUsed[c][i]=rUsed[r][i]=sUsed[k][i]=true;table[r][c]=i;DFS(n+1);table[r][c]=0;//如果DFS搜索失败就回溯cUsed[c][i]=rUsed[r][i]=sUsed[k][i]=false;} return;}int main(){ifstream in("test.txt");int testCase;in>>testCase;while(testCase--){nullNum=0;char line[10];for(int i=0;i<9;i++)//初始化for( int j=0;j<10 ;j++)rUsed[i][j]=cUsed[i][j]=sUsed[i][j]=false;for(int i=0 ;i<9 ;i++){in>>line;//读入一行//cout<<line;for(int j=0;j<9;j++){table[i][j]=line[j]-'0';if(table[i][j]){rUsed[i][ table[i][j] ]=true;//第i行用过这个数cUsed[j][ table[i][j] ]=true;//第j列用过这个数int k= (i/3)*3 + (j/3);//第k个3*3方格sUsed[k][ table[i][j] ]=true;}elsepos[nullNum++]=9*i+j;//使用数组，记录没有填数的小方格的位置}}DFS_SUDO=false;//clock_t time = clock();DFS(0);//cout<<"time used: "<<clock()-time<<" MS"<<endl;}return 0;}

 

 

这里设计的巧妙之处是：使用二维数组直接把已经存在的数字记录下来，而把没有填数字的位置用数组记录下来，这样在dfs搜索的时候就非常方便。可以看出在题目的算法设计时，选择合适和便于处理的数据结构有事半功倍的效果。

 

下面是POJ2488 A knight's journey的题目：

http://acm.pku.edu.cn/JudgeOnline/problem?id=2488

 

//POJ2488 A knight's journey //这里使用DFS搜索策略来完成遍历棋盘上的所有格子//骑士的前进方法可以使用方向二维数组来表示#include<iostream>using namespace std;#define MAXSIZE 30int board[MAXSIZE][MAXSIZE];//boardint stepX[MAXSIZE],stepY[MAXSIZE];//记录当前在棋盘上的位置int dir[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};//the direction of the knightint p,q;//记录棋盘的x，yint sign;//用来标记棋盘的所有空格都已经走完int step;//记录当前的步数void DFS(int i,int j){//DFS searchif( sign) return;//base case，如果遍历完则直接返回step++;stepX[step]=i;//记录当前坐标stepY[step]=j;board[i][j]=1;//标记if( step == p*q){//全部走完了sign=1;return ;}for(int k=0; k<8 ;k++){int x=i+dir[k][0];int y=j+dir[k][1];if( x>=1 && x<=p && y>=1 && y<=q && board[x][y]==0 ){DFS(x,y);step--;//如果DFS搜索失败，则step--}}board[i][j]=0;//失败，则对坐标(i,j)清零，回溯}int main(){int testNum;int t=0;//记录第几次测试cin>>testNum;while( testNum--){sign=0;//每次开始之前对sign进行置零step=0;t++;cin>>p>>q;for(int i=1;i<=p;i++)for(int j=1;j<=q;j++)board[i][j]=0;//initialize the boardDFS(1,1);cout<<"Scenario #"<<t<<":"<<endl;if( sign ){for(int i=1;i<=p*q ; i++)//这里不能使用i<=step来判断，因为step在递归返回时，递减为1了cout<<char(stepY[i]+'A'-1)<<stepX[i];//注意这里要转化为char类型cout<<endl;}elsecout<<"impossible"<<endl;if(testNum!=0)//最后一个senario没有空行cout<<endl;}return 0;}

 

这也是使用dfs回溯的思想来解题的，总结一下：

1、由于dfs回溯法，一般都是写成递归的形式，所以写的时候要细心一点，尤其是在回溯的时候，要进行还原。在这里dfs函数中不能漏泄最后的回溯还原 ：board[i][j] = 0，这个条件表明当走到当前这一步后，后面都是无效的走步时，需要撤销当前的这一步位置的标记。

2、在dfs搜索过程中还是能够记录下搜索路径，便于后面的还原。比如：这道题目中就是使用一个数组来记录路径的。

 

 

下面是POJ3083 Children of the Candy Corn的题目，使用的同样是深度优先搜索：

 

 //POJ3083 Children of the Candy Corn//这里求解最短路径的步数使用BFS进行搜索，而求解left path和right path使用的步数使用DFS搜索//使用矩阵来表示maze，同时利用元素的位置[i,j]，作为坐标//有时终端未显示任何结果，但正常终止，可能是发生了异常（如栈的溢出）#include<iostream>#include<queue>#include<fstream>using namespace std;#define MAX 45//定义全局变量int width,height;char map[MAX][MAX];int dir[2][4]={{1,0,-1,0},{0,1,0,-1}};//标记移动的方向，依次为：下、右、上、左（x坐标，y坐标）int startX,startY;//记录maze的起点坐标int lFlag,lStep,rStep;//lFlag变量标记执行left path或right pathstruct Node{int x;int y;int step;//记录最短路径的步数Node(int x1,int y1,int s):x(x1),y(y1),step(s){}};int BFS(int x,int y){//BFS一般使用队列的数据结构，并使用非递归形式queue<Node> q;Node n=Node(x,y,1);q.push(n);while( !q.empty()){Node tmp=q.front();q.pop();for( int k=0;k<4;k++){//在四个方向上进行判断int nextX=tmp.x+dir[0][k];//这里是在前一个结点的基础上试探，所以使用的是tm.x/tmp.y，而不是x/yint nextY=tmp.y+dir[1][k];if( nextX>=0 && nextX<height && nextY>=0 && nextY<width && map[nextX][nextY]!='#'){if( map[nextX][nextY]=='E')//如果找到出口，就返回return tmp.step+1;q.push( Node(nextX,nextY,tmp.step+1));map[tmp.x][tmp.y]='#';//设置已到达结点以后不可达，否则会陷入死循环}}}return 0;}int DFS(int x,int y,int z){//DFS一般使用递归实现//z表示方向if( map[x][y] == 'E')return 1;for( int k=0; k<4 ;k++){int nextX=x+dir[0][z];int nextY=y+dir[1][z];//if( nextX>=0 && nextX<width && nextY>=0 && nextY<height && map[nextX][nextY]!='#'){//下一步可以到达if( map[nextX][nextY]=='E' || map[nextX][nextY]=='.'){if(lFlag){//向左搜索lStep++;if( z==3)z=-1;if(DFS(nextX,nextY,z+1))//方向加1，方向向左return 1;}else{rStep++;if( z==0)z=4;if(DFS(nextX,nextY,z-1))//方向减1，方向向右return 1;}}if( lFlag){//向左搜索,顺时针旋转方向 z--;if(-1==z)//if中的“==”判断容易出错，把常量写在左边，容易查错z=3;}else{//向右搜索，逆时针旋转方向 z++;if(z==4)z=0;}}return 0;//如果找不到下一步可达的方格，就返回0}int main(){ifstream in("test.txt");int count;in>>count;while(count--){//count--,先判断，后执行减运算in>>width>>height;for(int i=0;i<height ; i++){//这样直接输入的前提是字符之间不能有空格,因为空格也会被当做一个字符 in>>map[i];//cout<<map[i]<<endl;for( int j=0; j< width ;j++)if( map[i][j] == 'S'){startX=i;startY=j;}}lFlag=1;lStep=1;DFS(startX,startY,0);lFlag=0;rStep=1;DFS(startX,startY,0);cout<<lStep<<" "<<rStep<<" "<<BFS(startX,startY)<<endl;}}

 

这道题目中，由于要求就出的是向左走和向右走为高优先级的路径，所以在方向的变换上要注意：向左走，就需要始终保持以左方向为高优先级，这点是最重要的。