leetcode 1219. 黄金矿工

leetcode 1219. 黄金矿工

一、题目

原题链接：1219. 黄金矿工

1.题目描述

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

为了使收益最大化，矿工需要按以下规则来开采黄金：

• 每当矿工进入一个单元，就会收集该单元格中的所有黄金。
• 矿工每次可以从当前位置向上下左右四个方向走。
• 每个单元格只能被开采（进入）一次。
• 不得开采（进入）黄金数目为 0 的单元格。
• 矿工可以从网格中 任意一个 有黄金的单元格出发或者是停止。

示例 1：

输入：grid = [[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,20]]
一种收集最多黄金的路线是：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。

提示：

• 1 <= grid.length, grid[i].length <= 15
• 0 <= grid[i][j] <= 100
• 最多 25 个单元格中有黄金。

2.基础框架

C++基础框架代码如下:

int getMaximumGold(vector<vector<int> >& grid) {
}

3.解题思路

• 题目分析

1. 题目要求返回可行路线的最大利益。
2. 枚举任意一个值不为0的位置，然后进行深度搜索，直到其余三个方向都无矿可采，回溯到上一个采矿的位置，对上一层的其他可行方向继续深度搜索。
3. 每次递归返回时，向上层返回从当前位置起分叉出来的最大利益路径的元素和。
4. 每一层访问到的位置需要进行标记，从而下一层避免重复访问已访问过的位置。

• 复杂度分析：
  时间复杂度：O(3^(mn))，指数级别
  空间复杂度：O(mn)

• 实现代码：

  class Solution {
  public:
      vector<vector<int> > dirs;	// 四个方向
      vector<vector<int> > rec;	// 标记已访问的位置
      int dfs(vector<vector<int> >& grid, int i, int j)
      {
          int res = 0;
          int ans = 0;
          for (int k = 0; k < 4; ++k)
          {
              int x = i + dirs[k][0];
              int y = j + dirs[k][1];
              if (x >= 0 && x < grid.size() && y >= 0 && y < grid[i].size())
              {
                  if (!rec[x][y] && grid[x][y] != 0)
                  {
                      ++rec[x][y];
                      res = dfs(grid, x, y);
                      --rec[x][y];
                      ans = res > ans ? res : ans;
                  }
              }
          }
          return grid[i][j] + ans;
      }
  
      int getMaximumGold(vector<vector<int> >& grid) {
          vector<vector<int> > tmp = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
          dirs = std::move(tmp);
          rec.resize(16);
          for (int i = 0; i < 16; ++i)
              rec[i].resize(16);
          int ans = 0;
          for (int i = 0; i < grid.size(); ++i)
          {
              int sum;
              for (int j = 0; j < grid[i].size(); ++j)
              {
                  if (grid[i][j] == 0)
                      continue;
                  ++rec[i][j];
                  sum = dfs(grid, i, j);
                  --rec[i][j];
                  ans = sum > ans ? sum : ans;
              }
          }
          return ans;
      }
  };
  

4.知识点

​ ​ 深度优先遍历