深度/广度优先搜索

还是借助上一篇文章中亲子游戏的例子说明一下深度优先搜索示例：

import java.util.*;

public class CandyGameDfs {
    //    <p>  宝宝和妈妈参加亲子游戏，在一个二维矩阵（N*N）的格子地图上，宝宝和妈妈抽签决定各自的位置，地图上每个格子有不同的糖果数量，部分格子有障碍物。 </p> <p>
//    游戏规则是妈妈必须在最短的时间（每个单位时间只能走一步）到达宝宝的位置，路上的所有糖果都可以拿走，不能走障碍物的格子，只能上下左右走。 </p> <div>
//    请问妈妈在最短到达宝宝位置的时间内最多拿到多少糖果（优先考虑最短时间到达的情况下尽可能多拿糖果）。 </div>
//    -3：妈妈
//    -2：宝宝
//    -1：障碍
//    ≥0：糖果数（0表示没有糖果，但是可以走）
//    4
//    3  2  1 -3
//    1 -1  1  1
//    1  1 -1  2
//   -2  1  2  3

    static int mi = 0,mj = 0,si = 0,sj = 0;
    static Queue<Pos> queue = null; //记录已访问节点
    static boolean[][] visited = null; //标记是否已访问
    static List<Pos> posList = null; //记录所有的路线
    static int[][] arr;
    static Pos end;
    static boolean fined;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        final int n = scanner.nextInt();
        arr = new int[n][n];

        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                arr[i][j] = scanner.nextInt();
                if(arr[i][j] == -3){
                    mi = i;
                    mj = j;
                }else if(arr[i][j] == -2){
                    si = i;
                    sj = j;
                }
            }
        }
        queue = new LinkedList<>(); //记录已访问节点
        visited = new boolean[n][n];
        posList = new LinkedList<>(); //记录所有的路线
        Pos start = new Pos(mi,mj,0); //开始位置
        end = new Pos(si,sj,0);
        dfsMs(start); //深度优先搜索

        System.out.println(posList.size());
        for(Pos pos : posList){
            int size = 0;
            int sum = 0;
            while (pos != null){
                System.out.println(pos.x + " " + pos.y + " "+ pos.count);
                pos = pos.pre;
                if(pos != null && pos.count > 0){
                    sum+=pos.count;
                    size++;
                }
            }
            System.out.println(size + 1 + " "+ sum);
            System.out.println("===");
        }

    }

    //这个还是深度搜索，deap first search,访问的方向对结果是有影响的。
    public static void dfsMs(Pos start){
        if(start.equals(end)){ //找到了
            posList.add(start);
            fined = true;
            return;
        }

        visited[start.x][start.y] = true; //已访问

        //向上
        if(start.x > 0 && !visited[start.x - 1][start.y] && arr[start.x - 1][start.y] != -1 && !fined){
            Pos tmp = new Pos(start.x-1,start.y,arr[start.x-1][start.y]);
            tmp.pre = start;
            dfsMs(tmp);
        }

        //向下
        if(start.x < arr.length-1 && !visited[start.x + 1][start.y] && arr[start.x + 1][start.y] != -1 && !fined){
            Pos tmp = new Pos(start.x+1,start.y,arr[start.x+1][start.y]);
            tmp.pre = start;
            dfsMs(tmp);
        }

        //向左
        if(start.y > 0 && !visited[start.x][start.y - 1] && arr[start.x][start.y-1] != -1 && !fined){
            Pos tmp = new Pos(start.x,start.y - 1,arr[start.x][start.y-1]);
            tmp.pre = start;
            dfsMs(tmp);
        }

        //向右
        if(start.y < arr.length - 1 && !visited[start.x][start.y+1] && arr[start.x][start.y+1] != -1 && !fined){
            Pos tmp = new Pos(start.x,start.y+1,arr[start.x][start.y+1]);
            tmp.pre = start;
            dfsMs(tmp);
        }
        //回溯
        if(start.pre != null && !fined){
            visited[start.pre.x][start.pre.y] = false;
            dfsMs(start.pre);
        }
    }

    static class Pos{
        int x;
        int y;
        int count;
        Pos pre;
        public Pos(int x,int y,int count){
            this.x = x;
            this.y = y;
            this.count = count;
        }


        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pos pos = (Pos) o;
            return x == pos.x && y == pos.y;
        }

        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
    }
}