读取网格规模：首先读取整数n，表示网格是n×n的二维数组。
读取网格数据：通过双重循环读取n×n的网格数据到vec中，同时记录：
- 起点坐标(startx, starty)：网格中值为-3的位置（代表起点）。
- 终点坐标(endx, endy)：网格中值为-2的位置（代表终点）。
方向数组：disX和disY分别存储 x 轴和 y 轴的偏移量，对应 “上、右、下、左” 四个方向（用于遍历相邻单元格）。

2. 核心数据结构

队列q：BFS 的核心容器，用于按顺序存储待处理的网格坐标（保证 “先处理近距离位置”）。
距离数组dist：dist[i][j]记录从起点到(i,j)的最短步数，初始值为INT_MAX（表示 “尚未到达”）。
糖果数组maxcandy：maxcandy[i][j]记录在 “最短步数” 前提下，到达(i,j)时能收集的最大糖果数，初始值为-1（表示 “未收集到糖果”）。

3. BFS 搜索过程（核心逻辑）

BFS 的本质是 “按距离分层扩散”，确保首次到达某位置时的步数为最短路径。这里额外处理了 “相同步数下最大化糖果数” 的需求。

初始化起点：

起点的最短距离dist[startx][starty]设为0（距离自己 0 步）。
起点的初始糖果数maxcandy[startx][starty]设为0（尚未收集任何糖果）。
将起点坐标(startx, starty)加入队列，开始 BFS。

循环处理队列中的位置：

取出队首位置：获取当前处理的坐标(x,y)，并弹出队列。
获取当前状态：记录当前位置的最短距离curDist和最大糖果数curCandy。
遍历四个方向的邻居：通过方向数组计算邻居坐标(dx, dy)（dx = x + disX[i]，dy = y + disY[i]）。
有效性检查：
- 边界检查：dx和dy必须在[0, n-1]范围内（不超出网格）。
- 障碍物检查：若vec[dx][dy] == -1（障碍物），则跳过该邻居。
计算新状态：
- 新距离newDist：当前距离 + 1（移动一步到邻居）。
- 新糖果数newCandy：当前糖果数 + 邻居位置的糖果（若邻居有糖果，即vec[dx][dy] > 0）。
更新状态并入队：
- 若newDist < dist[dx][dy]：找到更短的路径，更新dist[dx][dy]为newDist，maxcandy[dx][dy]为newCandy，并将(dx, dy)入队（继续扩散）。
- 若newDist == dist[dx][dy]且newCandy > maxcandy[dx][dy]：路径长度相同，但能收集更多糖果，更新maxcandy[dx][dy]为newCandy，并将(dx, dy)入队（其邻居可能因糖果数更新而受益）。

4. 输出结果

若dist[endx][endy] != INT_MAX：说明终点可达，输出终点的最大糖果数maxcandy[endx][endy]。
否则：终点不可达，输出-1。

代码

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int main() {
    int n; cin >> n;
    vector<vector<int>> vec(n, vector<int>(n));
    int startx, starty,endx,endy;
    for (int i = 0; i < n;i++) {
        for (int j = 0; j < n; j++) {
            cin >> vec[i][j];
            if (vec[i][j] == -3) {
                startx = i;
                starty = j;
            }
            if (vec[i][j] == -2) {
                endx = i;
                endy = j;
            }
        }
    }
    //上右下左
    int disX[4] = { -1,0,1,0 };
    int disY[4] = { 0,1,0,-1 };
    queue<pair<int, int>> q;
    q.push({startx, starty});
    vector<vector<int>> dist(n, vector<int>(n,INT_MAX));
    vector<vector<int>> maxcandy(n, vector<int>(n, -1));
    dist[startx][starty] = 0;
    maxcandy[startx][starty] = 0;
    while (!q.empty()) {
        int x= q.front().first;
        int y = q.front().second;
        q.pop();
        int curCandy = maxcandy[x][y];
        int curDist = dist[x][y];
        for (int i = 0; i < 4; i++) {
            int dx = x + disX[i];
            int dy = y + disY[i];
            if (dx < 0 || dy < 0 || dx >= n || dy >= n)continue;
            if (vec[dx][dy] == -1)continue;
            int newDist = curDist + 1;
            int newCandy = curCandy;
            if (vec[dx][dy] > 0) {
                newCandy += vec[dx][dy];
            }
            if (newDist < dist[dx][dy]) {
                dist[dx][dy] = newDist;
                maxcandy[dx][dy] = newCandy;
                q.push({ dx,dy });
            }else if (newDist == dist[dx][dy]&&newCandy> curCandy) {
                maxcandy[dx][dy] = newCandy;
                q.push({ dx,dy });
            }
        }
    }
    if (dist[endx][endy] != INT_MAX)cout << maxcandy[endx][endy];
    else cout << -1;
    return 0;
}

对您有帮助的话，可以点个免费的赞吗~