算法-亲子游戏

1.解析：

问题简述：求从mom点到baby点时，最短路径中可获得的最多糖果数

看似bfs问题，实则没那么简单。一般的bfs只是完成点的遍历，路径中的点是无条件互斥访问的。而本题要求的是糖果数最多的路径（可能不止一条），显然对可访问的点不能再采用无条件互斥访问的方案，如下图：路径1和路径2都可能经过点pot（为简化论述，实际上可能有四条路径经过点pot），那么pot能不能无条件互斥访问？显然不能，若路径1已获得糖果数多余路径2，但pot被路径2无条件先访问了，则访问到点pot时，获得的最多糖果数就由路径2决定，而路径1的糖果数更多，所以丢失了正确统计。

既然不能采取无条件互斥访问的方式，对于子问题：访问到点pot时获得的最多糖果数，应该采取决策（dp）：谁携带的糖果数多谁访问。经过决策，应该让路径1继续访问点pot。

2.方法：

根据问题：求从mom点到baby点时，最短路径中可获得的最多糖果数。每个点pot都有：访问到pot时可得到的最多糖果数。起点是mom点，每个点可获得糖果数都是从mom点出发求得，且要求步数最少，应使用bfs。

每个点都有可能作为bfs路径中的一个节点，以该点为基点访问下一层的节点的方法是确定的（总是访问该点的所有邻节点），所以每个点最多加入队列1次（否则内存溢出），而访问到每个点时能获得的最多糖果数是动态更新的，所以在访问的过程中，要动态维护每个点的：获得的最多糖果数。

维护每个点的“获得的最多糖果数”：矩阵是二维的，点由行号和列号唯一确定，因此使用二维矩阵存储每个点的“获得的最多糖果数”，该值是决策决定的，采用贪心策略维护。

3代码

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[][] arr=new int[n][n],used=new int[n][n],changes=new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
        int[] mom=new int[2];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                arr[i][j]=in.nextInt();
                if(arr[i][j]==-3){
                    mom[0]=i;
                    mom[1]=j;
                }
            }
        }
        Deque<int[]> queue=new ArrayDeque<>();
        queue.add(new int[]{mom[0],mom[1]});
        int ans=-1;

        int[][] res=new int[n][n];
        for(int[] a:res){
            Arrays.fill(a,-1);
        }
        res[mom[0]][mom[1]]=0;
        
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                int[] cur=queue.poll();
                int row=cur[0],col=cur[1];
                used[row][col]=1;     
                if(arr[row][col]==-2){
                    //到达，本层属于最短路径层，结束后，不再搜索
                    ans=res[row][col]+2;
                    break;
                }    
                for(int[] change:changes){
                    int newRow=row+change[0],newCol=col+change[1];
                    if(newRow<0||newRow>=n||newCol<0||newCol>=n||used[newRow][newCol]==1||arr[newRow][newCol]==-1){
                        continue;
                    }
                    //保证每个点只被加入队列一次，防止内存溢出
                    if(res[newRow][newCol]==-1){
                        res[newRow][newCol]=res[row][col]+arr[newRow][newCol];
                        queue.add(new int[]{newRow,newCol});
                    }else{
                        res[newRow][newCol]=Math.max(res[newRow][newCol],res[row][col]+arr[newRow][newCol]);
                    }
                }                
            }
        }
        System.out.println(ans);
    }
}