最近细读经典系列一直托更，主要原因就是刷了很多算法题，为了跟上更新节奏，我们补一补算法入门到放弃系列。
前面字符串拆分多是动规，今天我们搞点DFS，不科普基础支持，直接上题。
题前说一点小结论：DFS可以有返回值，且一定是根据我们的需求去构建DFS，算法的过程可以有模板，但是算法的细节一定是按需求，需求这里要求和，就返回int，需求是在DFS里改变状态，那就void，总之，DFS的返回值一定是按照需求的，不要死记硬背，觉得DFS没有返回值。
普通的DFS最常见的就是树的DFS，也是算法里相对简单的，上升到图（当然树也是图）这一层，比较基础的就是岛屿问题。
岛屿题也是从易到难都有，但是离不开的都是最开始的基础，我们先搞两道基础的
1、矩阵中的路径
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
例如，在下面的 3×4 的矩阵中包含单词 "ABCCED"（单词中的字母已标出）。
示例 1：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false
图的遍历一定是各个方向的遍历，可以通过树的DFS类推，树进行了左右子树的DFS，如果是图的邻接矩阵，那就四个方向遍历，思路应该有，具体实施有个模板：
public static boolean existsss(char[][] board, String word) {
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
if (dfsexist(board, i, j, word, 0)) {
return true;
}
}
}
return false;
}
public static boolean dfsexist(char[][] board, int i, int j, String word, int index) {
if (i >= board.length || i < 0 || j >= board[0].length || j < 0 || word.charAt(index) != board[i][j] || index > word.length() - 1) {
return false;
}
if (index == word.length() - 1) {
return true;
}
char temp = board[i][j];
board[i][j] = '*';
boolean res = dfsexist(board, i - 1, j, word, index + 1)
|| dfsexist(board, i, j - 1, word, index + 1)
|| dfsexist(board, i + 1, j, word, index + 1)
|| dfsexist(board, i, j + 1, word, index + 1);
board[i][j] = temp;
return res;
}这里就是需要注意，根据需要去确定dfs的返回值，我这里dfs的目的是看我当前站在[i][j]这个格子下，想要往上下左右走行还是不行，所以我返回true/false，这里千万不要想当然，应该不难理解
2、岛屿数量
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [
["1","1","1","1","0"],
["1","1","0","1","0"],
["1","1","0","0","0"],
["0","0","0","0","0"]
]
输出：1
示例 2：输入：grid = [
["1","1","0","0","0"],
["1","1","0","0","0"],
["0","0","1","0","0"],
["0","0","0","1","1"]
]
输出：3
还是我说的那个根据需要去设置dfs的返回，我站在[i][j]格子上，只要格子是1，他就是岛屿或者岛屿的一部分，我按照四个方向任意走，但凡遇到1，还是岛屿的一部分，而且这两个部分累计一个岛屿，那我的任务就是填格子，站在任意一个点，如果是0，掠过，如果是1，把所有我脚下为1的点，填成0， 直到上下左右不可填，算一个。这么看来，其实这个dfs不用返回值，只要再dfs退出的时候，给总引用值count自增即可。所以代码就是上面的改改：
public static int numIslands(char[][] grid) {
int countIsLands = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if(grid[i][j]=='1'){
dfsIsLands(grid, i, j);
countIsLands++;
}
}
}
return countIsLands;
}
public static void dfsIsLands(char[][] grid, int i, int j) {
if (i >= grid.length || i < 0 || j >= grid[0].length || j < 0 || grid[i][j] != '1') {
return;
}
grid[i][j] = 0;
dfsIsLands(grid, i, j - 1);
dfsIsLands(grid, i + 1, j);
dfsIsLands(grid, i - 1, j);
dfsIsLands(grid, i, j + 1);
}（第一版用静态变量的死活不能ac我极度怀疑leetcode对静态变量有什么误解（🐕头）），从数数游戏变成了填字游戏
3、黄金矿工
你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 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。
有了前几个题的铺垫我觉得大家看到这道题的第一感觉应该是：能做，只不过这道题又是要干两件事情，第一件事，走出来，第二件事求最大。走出来这个明显就是回溯了，试出所有道为止，然后求最大，每次进入递归出来的时候都和当前最大值判断以下即可。
public int getMaximumGold(int[][] grid) {
if (grid == null && grid.length == 0) {
return 0;
}
int result = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
//从当前点进入，到出来，能得到的最大价值路径和当前result结果取大的一个
result = Math.max(dfs(grid, i, j), result);
}
}
return result;
}
public static int dfs(int[][] grid, int i, int j) {
if (i >= grid.length || i < 0 || j >= grid[0].length || j < 0 || grid[i][j] == 0) {
return 0;
}
int temp = grid[i][j];
grid[i][j] = 0;
int up = dfs(grid, i, j - 1);
int right = dfs(grid, i + 1, j);
int left = dfs(grid, i - 1, j);
int down = dfs(grid, i, j + 1);
int max = Math.max(up, Math.max(Math.max(right, left), down));
grid[i][j] = temp;
return grid[i][j] + max;
}
4、岛屿面积
给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。
一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
示例 1:
输入: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出: 6
解释: 对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。
又回到了熟悉的填字游戏，只要挨个把1换成0，换不成就记下来已经换了几个，求最大就行，ez
public int maxAreaOfIsland(int[][] grid) {
if (grid == null && grid.length == 0) {
return 0;
}
int mianjiResult = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
dfsMianji(grid, i, j);
mianjiResult = Math.max(countResultMianji, mianjiResult);
countResultMianji = 0;
}
}
return mianjiResult;
}
static int countResultMianji = 0;
public static void dfsMianji(int[][] grid, int i, int j) {
if (i >= grid.length || i < 0 || j >= grid[0].length || j < 0 || grid[i][j] == 0) {
return;
}
countResultMianji++;
grid[i][j] = 0;
dfsMianji(grid, i, j - 1);
dfsMianji(grid, i + 1, j);
dfsMianji(grid, i - 1, j);
dfsMianji(grid, i, j + 1);
}（你又可能看到我的命名恨别扭，别在意这个细节，我所有的代码都是再一个java文件里调试的，写了几千行的算法题，每次新写一个题就得想想方法和变量该咋起名字。。。）
暂时遇到的就这些，其实还是挺简单的，举一反三也不难，需要你埋头一锤定音然后就可以吃老本了，加油加油！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
