LeetCode1219-黄金矿工，DFS深度优先搜索+枚举（Golang）

 题目链接：

        LeetCode1219

 题意：

        给定一个m*n的grid数组，你可以从数组的任意一点开始向四周取数，不可以经过重复的点，也不可以进入值为0的点，问最多可以取到多大的数值。（1≤m，n≤15）

 题解：

• 题目给定的数据范围较小，可以枚举起点，然后对起点进行深度优先搜索。
• 对于题目要求不可以去重复的点值，则可以在每次搜索过程中，将当前的点值赋值为0，当搜索完毕之后，将点值恢复

代码（Golang）：

func getMaximumGold(grid [][]int) (ans int) {
    ans=0
    sx:=len(grid)
    sy:=len(grid[0])
    dir:=[][]int{{0,1},{1,0},{-1,0},{0,-1}}
    var dfs func(x int, y int, now int)
    dfs=func(x int, y int, now int){
        now+=grid[x][y]
        if ans<now{
            ans=now
        }
        for i:=0;i<4;i++{
            nx:=x+dir[i][0]
            ny:=y+dir[i][1]
            if (nx>=0 && nx<sx && ny<sy && ny>=0 && grid[nx][ny]!=0){
                tmp:=grid[x][y]
                grid[x][y]=0
                dfs(nx,ny,now)
                grid[x][y]=tmp
            }
        }
    }
    for i:=0;i<sx;i++{
        for j:=0;j<sy;j++{
            if grid[i][j]!=0{
                dfs(i,j,0)
            }
        }
    }
    return
}

C++：

class Solution {
private:
    int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

public:
    int getMaximumGold(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        int ans = 0;
        //c++新标准下的函数定义写法，也可以在getMaximumGold()外直接声明并实现该函数
        function<void(int, int, int)> dfs = [&](int x, int y, int gold) {
            gold += grid[x][y];
            ans = max(ans, gold);

            int rec = grid[x][y];
            grid[x][y] = 0;

            for (int d = 0; d < 4; ++d) {
                int nx = x + dirs[d][0];
                int ny = y + dirs[d][1];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] > 0) {
                    dfs(nx, ny, gold);
                }
            }

            grid[x][y] = rec;
        };

        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] != 0) {
                    dfs(i, j, 0);
                }
            }
        }

        return ans;
    }
};