深度优先搜索算法
下面是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;
}
}
这道题目中，由于要求就出的是向左走和向右走为高优先级的路径，所以在方向的变换上要注意：向左走，就需要始终保持以左方向为高优先级，这点是最重要的。
文章转载出处：http://blog.csdn.net/urecvbnkuhbh_54245df/article/details/5865077
