描述

这有一个迷宫，有0~8行和0~8列：

 1,1,1,1,1,1,1,1,1
 1,0,0,1,0,0,1,0,1
 1,0,0,1,1,0,0,0,1
 1,0,1,0,1,1,0,1,1
 1,0,0,0,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,1,0,0,1
 1,1,0,1,0,0,0,0,1
 1,1,1,1,1,1,1,1,1

0表示道路，1表示墙。

现在输入一个道路的坐标作为起点，再如输入一个道路的坐标作为终点，问最少走几步才能从起点到达终点？

（注：一步是指从一坐标点走到其上下左右相邻坐标点，如：从（3，1）到（4,1）。）

输入

第一行输入一个整数n（0<n<=100），表示有n组测试数据;
随后n行,每行有四个整数a,b,c,d（0<=a,b,c,d<=8）分别表示起点的行、列，终点的行、列。

输出

输出最少走几步。

样例输入

2
3 1  5 7
3 1  6 7

样例输出

12
11

 对于DFS要注意两点：

     一：递归结束的条件，要清除递归会在什么时间结束。

     二：递归继续执行下去的条件。

import java.util.Scanner;
public class Test06DFS {
    static int[][] map={
            {1,1,1,1,1,1,1,1,1},
            {1,0,0,1,0,0,1,0,1},
            {1,0,0,1,1,0,0,0,1},
            {1,0,1,0,1,1,0,1,1},
            {1,0,0,0,0,1,0,0,1},
            {1,1,0,1,0,1,0,0,1},
            {1,1,0,1,0,1,0,0,1},
            {1,1,0,1,0,0,0,0,1},
            {1,1,1,1,1,1,1,1,1}
    };
    static int[] dirX={-1,0,1,0};
    static int[] dirY={0,-1,0,1};
    static int minStep;
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        int t = in.nextInt();
        int sx,sy,ex,ey;
        while((t--)>0) {
            minStep=100;
            sx = in.nextInt();
            sy = in.nextInt();
            ex = in.nextInt();
            ey = in.nextInt();
            if (sx == ex && sy == ey) {
                System.out.println("0");
                continue;
            }
            map[sx][sy]=1;
            DFS(sx,sy,ex,ey,0);
            System.out.println(minStep);
            map[sx][sy]=0;   //因为测试数据不止一组，所以应该还原本来面貌
        }
    }

    private static void DFS(int sx,int sy,int ex,int ey,int step){
        if(sx==ex&&sy==ey){    //递归结束条件
            if(step<minStep){
                minStep=step;
            }
            return;
        }else {
            for (int i = 0; i < 4; i++) {
                int x=sx+dirX[i];
                int y=sy+dirY[i];
                if(map[x][y]==0&&step+1<minStep){
                    map[x][y]=1;
                    DFS(x,y,ex,ey,step+1);
                    map[x][y]=0;
                }
            }
        }
    }
}

BFS：

import java.util.Deque;
import java.util.LinkedList;
import java.util.Scanner;

public class Test05BFS {
    private static class Node{ //写一个静态内部类，保存每个位置的步数   
        int x;
        int y;
        int step;
    }
    static int[][] map={
            {1,1,1,1,1,1,1,1,1},
            {1,0,0,1,0,0,1,0,1},
            {1,0,0,1,1,0,0,0,1},
            {1,0,1,0,1,1,0,1,1},
            {1,0,0,0,0,1,0,0,1},
            {1,1,0,1,0,1,0,0,1},
            {1,1,0,1,0,1,0,0,1},
            {1,1,0,1,0,0,0,0,1},
            {1,1,1,1,1,1,1,1,1}
    };
    static int[] dirX={-1,0,1,0};
    static int[] dirY={0,-1,0,1};
    public static void main(String[] args) {
        Deque<Node> list=new LinkedList<>();   //创建一个LinkedList，它实现了Deque接口，所以可以用作栈或队列
        Scanner in =new Scanner(System.in);
        int t = in.nextInt();
        int sx,sy,ex,ey;
        while((t--)>0){
            sx=in.nextInt();
            sy=in.nextInt();
            ex=in.nextInt();
            ey=in.nextInt();
            if(sx==ex&&sy==ey){
                System.out.println("0");
                continue;
            }
            int[][] vis=new int[10][10];    //标记
            //使用BFS进行
            Node node=new Node();
            node.x=sx;
            node.y=sy;
            node.step=0;
            int lastStep=100;
            list.push(node);
            vis[sx][sy]=1;  //标记
            while(list.size()!=0){
                Node oldNode = list.removeLast();
                for(int i=0;i<4;i++){
                    Node newNode=new Node();
                    newNode.x=oldNode.x+dirX[i];
                    newNode.y=oldNode.y+dirY[i];
                    newNode.step=oldNode.step+1;

                    if(newNode.x>0&&newNode.x<8&&newNode.y>0&&newNode.y<8&&   //判断这一点是否满足条件
                            vis[newNode.x][newNode.y]==0&&
                            map[newNode.x][newNode.y]==0&&
                            newNode.step<lastStep){
                        if(newNode.x==ex&&newNode.y==ey&&newNode.step<lastStep){ //是否已到终点
                            lastStep=newNode.step;
                        }else {                                              //加入到队列
                            vis[newNode.x][newNode.y]=1;
                            list.push(newNode);
                        }
                    }
                }
            }
            System.out.println(lastStep);
        }
    }
}