LeetCode-Python-1219. 黄金矿工（DFS + 回溯）

你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 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 个单元格中有黄金。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/path-with-maximum-gold
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

数据规模暗示回溯，题意明示回溯。

只要能把所有的收集黄金的路线找出来，返回最大的收获值即可。

时间复杂度：O（4 * 3 ^ （K - 2）), K是黄金格子的数量，第一个格子有4种走法，其他的中间黄金格子只有3种走法，最后一个格子没得走。

空间复杂度：O（K），包括visited集合占用的空间和递归开栈的空间

class Solution(object):
    def getMaximumGold(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        dx = [1, -1, 0, 0]
        dy = [0, 0, 1, -1]
        m, n = len(grid), len(grid[0])
        visited = set()
        self.res = 0
        
        def dfs(x0, y0, tmp):
            self.res = max(self.res, tmp)
            for k in range(4):
                x = x0 + dx[k]
                y = y0 + dy[k]
                
                if 0 <= x < m and 0 <= y < n and (x, y) not in visited and grid[x][y] != 0:
                    visited.add((x, y))
                    dfs(x, y, tmp + grid[x][y])
                    visited.remove((x, y))
                    
        for i in range(m):
            for j in range(n):
                visited.add((i, j))
                dfs(i, j, grid[i][j])
                visited.remove((i, j))
        return self.res

如果不用集合，以下是染色的版本：

class Solution(object):
    def getMaximumGold(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        dx = [1, -1, 0, 0]
        dy = [0, 0, 1, -1]
        m, n = len(grid), len(grid[0])
        visited = set()
        self.res = 0
        
        def dfs(x0, y0, tmp):
            self.res = max(self.res, tmp)
            for k in range(4):
                x = x0 + dx[k]
                y = y0 + dy[k]
                
                if 0 <= x < m and 0 <= y < n and grid[x][y] > 0:
                    value = grid[x][y]
                    grid[x][y] = -1
                    dfs(x, y, tmp + value)
                    grid[x][y] = value
                    
        for i in range(m):
            for j in range(n):
                value = grid[i][j]
                grid[i][j] = -1
                dfs(i, j, value)
                grid[i][j] = value
        return self.res