【2.10】回溯算法-解黄金矿工问题

一、题目

        你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 m * n 的网格grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。 为了使收益最大化，矿工需要按以下规则来开采黄金：

1）每当矿工进入一个单元，就会收集该单元格中的所有黄金。

2）矿工每次可以从当前位置向上下左右四个方向走。

3）每个单元格只能被开采（进入）一次。

4）不得开采（进入）黄金数目为 0 的单元格。

5）矿工可以从网格中 任意一个 有黄金的单元格出发或者是停止。

示例 1 ：

输入 ：

g ri d = [ [ 0 , 6 , 0 ] , [ 5 , 8 , 7 ] , [ 0 , 9 , 0 ] ]

输出 ： 24

解释 ：

[ [ 0 , 6 , 0 ] ,

[ 5 , 8 , 7 ] ,

[ 0 , 9 , 0 ] ]

一种收集最多黄金的路线是：

9 -> 8 -> 7 。

示例 2 ：

输入 ：

grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]]

输出 ： 28

解释 ：

[ [ 1 , 0 , 7 ] ,

[ 2 , 0 , 6 ] ,

[ 3 , 4 , 5 ] ,

[ 0 , 3 , 0 ] ,

[ 9 , 0 , 2 0 ] ]

一种收集最多黄金的路线是：

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 。

提示：

1）1 <= grid.length, grid[i].length <= 15

2）0 <= grid[i][j] <= 100

3）最多 25  个单元格中有黄金。

二、解题思路

        这道题目要求我们在一个二维数组中，从任意位置出发，探索上下左右四个方向的路径，并找出路径上数值最大的那一条。需要注意的是，数值为0的格子视为障碍，无法通过。通过绘制一个简单的示意图，我们可以更直观地理解这一过程。

        我们需要遍历每一个位置，从任何一个位置开始找到最大路径，所以代码大致轮廓如下

int getMaximumGold(vector<vector<int>>& grid) {
    // 边界条件判断
    if (grid.empty() || grid[0].empty())
        return 0;
    
    // 保存最大路径值
    int res = 0;
    
    // 两个for循环，遍历每一个位置，让他们当做起点
    // 查找最大路径值
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[0].size(); j++) {
            // 函数dfs是以坐标(i,j)为起点，查找最大路径值
            res = max(res, dfs(grid, i, j));
        }
    }
    
    // 返回最大路径值
    return res;
}

        代码的大致轮廓写出来了，这里主要是 dfs 这个函数，他表示的是以 (i，j) 为坐标点，沿着他的上下左右4个方向查找最大路径，这里我们很容易把它想象成为一颗4叉树，就像下面这样

        这张图的流程会持续沿着每个分支深入，直至达到终止条件。一旦遇到终止条件，所有经过的位置都会被标记为0，以表示这些位置不能再被访问。终止条件包括：索引i和j均未超出边界，且当前位置的值不为0。判断如下：

 if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == 0)
        return 0;

        由于采用了递归方法，在深入递归时，会将当前位置的值设为0；而在递归返回时，需要将当前位置的值恢复原状。

三、代码实现

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int dfs(vector<vector<int>>& grid, int x, int y) {
    // 边界条件的判断，x,y都不能越界，同时当前坐标的位置如果是0，表示有障碍物或者遍历过了
    if (x < 0 || x >= grid.size() || y < 0 || y >= grid[0].size() || grid[x][y] == 0)
        return 0;
    
    // 先把当前坐标的值保存下来，最后再还原
    int temp = grid[x][y];
    
    // 当前坐标已经访问过了，要把他标记为0，防止再次访问
    grid[x][y] = 0;
    
    // 然后沿着当前坐标的上下左右4个方向查找
    int up = dfs(grid, x, y - 1); // 往上找
    int down = dfs(grid, x, y + 1); // 往下找
    int left = dfs(grid, x - 1, y); // 往左找
    int right = dfs(grid, x + 1, y); // 往右找
    
    // 这里只要4个方向的最大值即可
    int maxDirection = max({left, right, up, down});
    
    // 然后再把当前位置的值还原
    grid[x][y] = temp;
    
    // 返回最大路径值
    return grid[x][y] + maxDirection;
}

int getMaximumGold(vector<vector<int>>& grid) {
    // 边界条件判断
    if (grid.empty() || grid[0].empty())
        return 0;
    
    // 保存最大路径值
    int res = 0;
    
    // 两个for循环，遍历每一个位置，让他们当做起点
    // 查找最大路径值
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[0].size(); j++) {
            // 函数dfs是以坐标(i,j)为起点，查找最大路径值
            res = max(res, dfs(grid, i, j));
        }
    }
    
    // 返回最大路径值
    return res;
}

int main() {
    // 示例二维数组
    vector<vector<int>> grid = {
        {0, 6, 0},
        {5, 8, 7},
        {0, 9, 0}
    };
    
    // 调用getMaximumGold函数并输出结果
    int result = getMaximumGold(grid);
    cout << "Maximum gold: " << result << endl;
    
    return 0;
}