深度优先搜索算法

下面是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 0 using namespace std; #define MAX 30 int 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; else return 0; } void DFS(int step,int x,int y){ if( step >= 10 ) //剪枝条件“>=10”放弃搜索 return; step++; //换一个方向才算步数加1 for(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或target nextY += dir[k][1]; } if( map[nextX][nextY]==3){ //到达目标点 if(step<minStep) minStep=step; //cout<<minStep<<endl; return; } else if( map[nextX][nextY]==1){ //撞到block map[nextX][nextY]=0; //清空block nextX -= 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; else cout<<-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; } else pos[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 30 int board[MAXSIZE][MAXSIZE]; //board int 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 knight int p,q; //记录棋盘的x，y int sign; //用来标记棋盘的所有空格都已经走完 int step; //记录当前的步数 void DFS(int i,int j){ //DFS search if( 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 board DFS(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; } else cout<<"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 path struct 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/y int 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; } }

 

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