亲子游戏（bfs）

核心思路

求最短路径就用bfs，遍历所有可能路径就用dfs。
最短时间可以等价理解为最短距离。
开辟一个额外的二维数组去保存到达目标位置可以获得的最多糖果数量。

算法设计流程

bfs流程：
一个队列queue：存放起点。

一个while循环，条件是当队列不为空。

while循环内，将初始化好的队列元素取出起点给当前坐标x，y。

当到达目标位置坐标时，返回统计结果。

遍历下一个位置起点，越界和遇到障碍则重新选起点，否则将新的起点加入队列，并标记为访问过。
然后统计走完新起点处的结果。

主函数：
只需要初始化好队列要存放的起点，然后调用bfs即可。

代码细节

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

public class Main {
    static int[] dx={-1,1,0,0};
    static int[] dy={0,0,-1,1};//方向数组
    static int m,n;
    static boolean[][] visited;
    static int[][] map;
    static int[][] res;
   static public int bfs(Queue<int[]> queue){
        while (!queue.isEmpty()){
            int[] temp=queue.poll();
            int x=temp[0];
            int y=temp[1];
            if (map[x][y]==-2){
               return res[x][y];
            }//如果到达了目的地，就返回统计的总结果
            for (int i = 0; i < 4; i++) {
                int nx=x+dx[i];
                int ny=y+dy[i];
                if (nx<0||ny<0||nx>m-1||ny>n-1)continue;
                if (!visited[nx][ny]){
                    queue.offer(new int[]{nx,ny});
                    visited[nx][ny]=true;
                }
                res[nx][ny]=Math.max(res[nx][ny],Math.max(0,map[nx][ny])+res[x][y]);//走完下一个点后，就统计走到下一个点处的结果
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        Queue<int[]> queue=new LinkedList<>();
        Scanner scanner=new Scanner(System.in);
        int N= scanner.nextInt();
        m=N;
        n=m;
        map=new int[m][n];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                map[i][j]=scanner.nextInt();
            }
        }
        visited=new boolean[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                visited[i][j]=false;
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (map[i][j]==-1){
                    visited[i][j]=true;
                }
            }
        }
        res=new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (map[i][j]==-3){//-3是起点，-2是终点，-1是障碍
                    queue.offer(new int[]{i,j});
                    res[i][j]=0;//初始化此位置的结果
                }
            }
        }
        int result=bfs(queue);
        System.out.println(result);
    }
}