poj3083

涉及算法：bfs、dfs
题目大意：给定一个矩形区域，由空白区域可障碍物组成，给定起点和终点，问：
以左优先的方式走，从起点走到终点需要走过多少格？
以右优先的方式走，从起点走到终点需要走过多少格？
从起点走到终点最少需要走过多少格？

题目分析：
左优先：以当前的朝向为上，若左边可以走就走左边，若左边不可以走就走上边，若左边和上边都不可以走则走右边，若左边上边右边都不可以走则走下边。则优先级依次为（左上右下）

如上图所示：现在用数字0~3表示4个方向，若当前的朝向d为0，则优先级为：3012；若d为1，则优先级为0123；若d为2，则优先级为1230；若d为3，则优先级为2301；所以起始的搜索方向k为：若d=0，k=3，否则k=d-1

右优先：同理，优先级为右上左下

代码如下：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main_3083_1
{
	static int w;//列
	static int h;//行
	static int mesh[][];//mesh[i][j]表示i行j列
	static int startx;
	static int starty;
	static int dl[][]={{0,-1},{-1,0},{0,1},{1,0}};//{0,-1}左移,{-1,0}上移,{0,1}右移,{1,0}下移
	static int dr[][]={{0,1},{-1,0},{0,-1},{1,0}};
	public static void main(String[] args)
	{
		Scanner in=new Scanner(System.in);
		int k=in.nextInt();
		while(k-->0)
		{
			w=in.nextInt();
			h=in.nextInt();
			mesh=new int[h][w];
			for(int i=0;i<h;i++)
			{
				String line=in.next();
				for(int j=0;j<w;j++)
				{
					if(line.charAt(j)=='#')
					{
						mesh[i][j]=1;
					}else if (line.charAt(j)=='.') {
						mesh[i][j]=0;
					}else if (line.charAt(j)=='S') {
						mesh[i][j]=0;
						startx=i;
						starty=j;
					}else if(line.charAt(j)=='E'){
						mesh[i][j]=2;
					}
				}
			}
			dfs_left(startx, starty, 0, 1);
			dfs_right(startx, starty, 0, 1);
			bfs(startx, starty);
		}
	}
	
	static int k;
	static int t;
	static boolean dfs_left(int x,int y,int dir,int step)//
	{
		if(mesh[x][y]==2) 
		{
			System.out.print(step+" ");
			return true;
		}
		if(dir==1) k=0;
		if(dir==2) k=1;
		if(dir==3) k=2;
		if(dir==0) k=3;
		for(int i=k;i<(k+4);i++)
		{
			t=i%4;
			int dx=x+dl[t][0];
			int dy=y+dl[t][1];
			if(dx<0 || dx>=h || dy<0 || dy>=w || mesh[dx][dy]==1) continue;
			if(dfs_left(dx, dy, t, step+1)) return true;
		}
		return false;
	}
	
	static boolean dfs_right(int x,int y,int dir,int step)
	{
		if(mesh[x][y]==2)
		{
			System.out.print(step+" ");
			return true;
		}
		if(dir==1) k=0;
		if(dir==2) k=1;
		if(dir==3) k=2;
		if(dir==0) k=3;
		for(int i=k;i<k+4;i++)
		{
			t=i%4;
			int dx=x+dr[t][0];
			int dy=y+dr[t][1];
			if(dx<0 || dx>=h || dy<0 || dy>=w || mesh[dx][dy]==1) continue;
			if(dfs_right(dx, dy, t, step+1)) return true;
		}
		return false;
	}
	
	static int vis[][];
	static int step[][];
	static int dx,dy;
	static void bfs(int startx,int starty)
	{
		vis=new int[h][w];
		step=new int[h][w];
		Queue<Integer> q=new LinkedList<Integer>();
		q.offer(startx*100+starty);
		step[startx][starty]=1;
		vis[startx][starty]=1;
		while(!q.isEmpty())
		{
			int k=q.poll();
			int x=k/100;
			int y=k%100;
			for(int i=0;i<4;i++)
			{
				dx=x+dl[i][0];
				dy=y+dl[i][1];
				if(dx<0 || dx>=h || dy<0 || dy>=w || mesh[dx][dy]==1 || vis[dx][dy]==1) continue;
				q.offer(dx*100+dy);
				vis[dx][dy]=1;
				step[dx][dy]=step[x][y]+1;
				if(mesh[dx][dy]==2)
				{
					System.out.println(step[dx][dy]);
					return;
				}
			}
			
		}
	}

}