POJ走出迷宫

常规搜索题。给一个矩阵，有些点不能走，计算从起点到终点的最短路径的长度。
注意： 矩阵范围为100*100，DFS+剪枝也会超时（但理论上最坏情况都是O(n^2)，可能是测试点的问题？专门不让DFS过）

DFS模板：把终止条件和剪枝放在函数头，然后依次访问四个方向，先判断再标记进入，回溯。

#include <iostream>

int H,L,step=0,min=100000,X[4]={0,1,0,-1},Y[4]={-1,0,1,0},sh,sl;
char maze[110][110];
bool mark[110][110];
void dfs(int h,int l,int step){
	if(step>=min) return;
	if(maze[h][l]=='T'){
		if(step<min) min=step;
		return;
	}
	for(int i=0;i<4;i++){
		int hh=h+Y[i],ll=l+X[i];
		if((maze[hh][ll]=='.'||maze[hh][ll]=='T')&&mark[hh][ll]==0){
			mark[hh][ll]=1;
			dfs(hh,ll,step+1);
			mark[hh][ll]=0;
		} 
	}
}
int main(int argc, char** argv) {
	scanf("%d %d",&H,&L);
	for(int i=0;i<H;i++){
		getchar();
		for(int j=0;j<L;j++){
			maze[i][j]=getchar();
			if(maze[i][j]=='S'){
				sh=i;sl=j;
			}
		}
		
	}
	dfs(sh,sl,0);
	printf("%d",min);
	return 0;
}

BFS模板：用一个结构体记录每个点的横纵坐标和距离起点的步数，出队时判断是否到达终点。可以专门用一个函数来判断是否可以入队，结构更清晰。

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

struct node{
	int y,x,step;
}Node,S,T;
int H,L,step=0,min=100000,X[4]={0,1,0,-1},Y[4]={-1,0,1,0},sh,sl;
char maze[110][110];
bool mark[110][110];

//判断条件较多的，可以集合到一个函数中
bool judge(node n){
	int h=n.y,l=n.x;
	if(h>=H||h<0||l>=L||l<0) return false;//出界 
	if(mark[h][l]==true) return false;//已经访问过
	if(maze[h][l]=='#') return false;//无法访问 
	return true; 
}

int bfs(){
	queue<node> q;
	q.push(S);//起点入队 
	while(!q.empty()){
		node t=q.front();
		q.pop();
		if(t.x==T.x&&t.y==T.y) return t.step;//出队时访问，如果到达终点，则返回路径长度 
		for(int i=0;i<4;i++){
			Node.y=t.y+Y[i];
			Node.x=t.x+X[i];
			if(judge(Node)){
				Node.step=t.step+1;
				mark[Node.y][Node.x]=1;
				q.push(Node);
			} 
		}
	}
	
}
int main(int argc, char** argv) {
	scanf("%d %d",&H,&L);
	for(int i=0;i<H;i++){
		getchar();
		for(int j=0;j<L;j++){
			maze[i][j]=getchar();
			if(maze[i][j]=='S'){
				S.y=i;
				S.x=j;
				S.step=0;
			}
			if(maze[i][j]=='T'){
				T.y=i;
				T.x=j;
			}
		}
		
	}
	printf("%d",bfs());
	return 0;
}