LeetCode刷题之搜索（Java）
Posted 哈喽喔德
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode刷题之搜索（Java）相关的知识，希望对你有一定的参考价值。
一、深度优先搜索
基本模型：基于栈的递归
void dfs(step)
判断边界
尝试每一种可能 for(int i=0;i<n;++i)
继续下一步 dfs(step+1);
返回
DFS力扣例题
695.岛屿的最大面积
分析：
对是陆地的位置向四个方向进行深度优先搜索，如果下一个位置仍然是陆地，则加上由新陆地向四个方向搜索的值。遍历过的陆地应该设置为0，以避免重复被计入。
题解：
class Solution
public static int maxAreaOfIsland(int[][] grid)
int maxArea = 0;
for(int i=0;i<grid.length;++i)
for(int j=0;j<grid[i].length;++j)
if (grid[i][j]==1)
maxArea = Math.max(maxArea, dfs(grid, i, j));
return maxArea;
private static int dfs(int[][] grid, int i, int j)
if (i<0 || j<0 || i>=grid.length || j>=grid[i].length || grid[i][j]==0)
//超出边界，返回0
//当前位置是水，返回0
return 0;
else
//计入当前陆地面积1
int sum = 1;
//当前陆地已经计算过，设为0
grid[i][j] = 0;
sum += dfs(grid, i+1,j);
sum += dfs(grid, i-1,j);
sum += dfs(grid, i,j+1);
sum += dfs(grid, i,j-1);
return sum;
547. 省份数量
分析：
本题拥有的行数即是节点的个数，列数即是每行的边。以此转换为图的模型进行深度优先搜索。同时需要一个数组标记该节点是否被访问过。
题解：
**class Solution
public int findCircleNum(int[][] isConnected)
int count = 0;
boolean[] isVisited = new boolean[isConnected.length];
Arrays.fill(isVisited,false);
for(int i=0;i<isConnected.length;++i)
if (!isVisited[i])
++count;
dfs(isConnected, isVisited, i);
return count;
private void dfs(int[][] isConnected, boolean[] isVisited, int i)
isVisited[i] = true;
for(int j=0;j<isConnected[i].length;++j)
if (isConnected[i][j]==1 && !isVisited[j])
dfs(isConnected, isVisited, j);
**
417. 太平洋大西洋水流问题
分析：
考虑到如果对每个点进行深度优先搜索复杂度较高，因此采用从两个大洋逆流的想法进行搜索，设置代表两个大洋搜索结果的两个数组。这样只需要搜索四个边界即可。搜索完后，只需要遍历一遍矩阵，如果当前位置的两个大洋都能到达，即为题目所求。
题解：
class Solution
public List<List<Integer>> pacificAtlantic(int[][] heights)
List<List<Integer>> result = new ArrayList<List<Integer>>();
if (heights.length==0 || heights[0].length==0)
return result;
//判断是否能够的布尔型数组
int m = heights.length;
int n = heights[0].length;
boolean[][] reachPacific = new boolean[m][n];
boolean[][] reachAtlantic = new boolean[m][n];
for(int i=0;i<m;++i)
Arrays.fill(reachPacific[i],false);
Arrays.fill(reachAtlantic[i],false);
for (int i=0;i<m;++i)
//对左边界进行dfs
dfs(heights, reachPacific, i, 0);
//对右边界进行dfs
dfs(heights, reachAtlantic, i, n-1);
for (int i=0;i<n;++i)
//对上边界进行dfs
dfs(heights, reachPacific, 0, i);
//对下边界进行dfs
dfs(heights, reachAtlantic, m-1, i);
for (int i=0;i<m;++i)
for(int j=0;j<n;++j)
//两个大洋都能流到的位置
if (reachAtlantic[i][j] && reachPacific[i][j])
List<Integer> temp = new ArrayList<>();
temp.add(i);
temp.add(j);
result.add(temp);
return result;
private void dfs(int[][] heights, boolean[][] reach, int start, int end)
if (reach[start][end])
return;
//能够流经的位置记为true
reach[start][end] = true;
//向四个方向开始搜索
int x = start-1;
int y = end;
if (x>=0 && x<heights.length && y>=0 && y<heights[0].length && heights[start][end] <= heights[x][y])
dfs(heights, reach, x, y);
x = start+1;
y = end;
if (x>=0 && x<heights.length && y>=0 && y<heights[0].length && heights[start][end] <= heights[x][y])
dfs(heights, reach, x, y);
x = start;
y = end-1;
if (x>=0 && x<heights.length && y>=0 && y<heights[0].length && heights[start][end] <= heights[x][y])
dfs(heights, reach, x, y);
x = start;
y = end+1;
if (x>=0 && x<heights.length && y>=0 && y<heights[0].length && heights[start][end] <= heights[x][y])
dfs(heights, reach, x, y);
二、回溯法
回溯法是优先搜索的一种特殊情况，又称为试探法，常用于需要记录节点状态的深度优先搜索。通常来说，排列、组合、选择类问题使用回溯法比较方便。在搜索到某一结点的时候，如果我们发现目前节点不是需求目标时，需要回退到原来的节点，并且把目前节点修改的状态还原。
通常有两个小窍门：1. 按引用传状态；2. 所有的状态修改在递归完成后回改。
回溯的修改有两种情况：1. 修改最后一位输出，如排列组合；2. 修改访问标记
46. 全排列
分析：
对于每一个当前位置i，我们可以将其于之后的任意位置交换，然后继续处理位置i+1，，直到处理到最后一位。为了防止每次遍历时都要创建一个子数组存储位置i之前已经交换好的数字，可以利用回溯法，只对原数组进行修改，在递归完成后再改回来。
题解：
class Solution
public List<List<Integer>> permute(int[] nums)
List<List<Integer>> result = new ArrayList<List<Integer>>();
backtracking(nums, 0, result);
return result;
public void backtracking(int[] nums, int level, List<List<Integer>> result)
//处理到最后一位，进行结果的保存
if (level == nums.length-1)
List<Integer> temp = new ArrayList<>();
for(int i:nums)
temp.add(i);
result.add(temp);
return;
for (int i=level;i<nums.length;++i)
//交换当前位置
swap(nums, i, level);
//进行下一位数的处理
backtracking(nums, level+1, result);
//改回状态，进行回溯
swap(nums, i, level);
public void swap(int[] num, int i, int j)
int temp = num[i];
num[i] = num[j];
num[j] = temp;
77. 组合
分析：
声明一个待选列表，回溯遍历所有可能的搜索起点，如果加入待选列表的数已经有了k个，则将其加入最后的结果。因为组合数不能有重复的数出现，因此每次搜索的起点要+1。回溯算法在进入递归前后要改变状态和恢复状态。
在上述算法的基础上，可以进行剪枝，也即是在每次进行递归时，当待选列表的长度加上剩余未判断区间的长度小于k，则不可能构造出最后的结果，直接结束该次递归即可。
题解：
class Solution
List<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> temp = new ArrayList<>();
public List<List<Integer>> combine(int n,int k)
backtracking(1, n, k);
return result;
private void backtracking(int current, int n, int k)
//如果待选列表的长度加上剩余未确定区间的长度小于k
//则不可能构造出长度为k的结果
if (temp.size()+(n-current+1)<k)
return;
//长度到达k，记录结果
if (temp.size()==k)
result.add(new ArrayList<Integer>(temp));
return;
//回溯遍历所有可能的搜索起点
for (int i=current;i<=n;++i)
//将当前的数加入待选列表中
temp.add(i);
//从下一个数开始搜索
backtracking(i+1,n,k);
//回溯，将加入的数从待选数列中删除
temp.remove(temp.size()-1);
79. 单词搜索
分析：
为每个访问的节点设置一个访问位，来表示是否被访问过。然后在递归过程中，分别向四个方向进行深搜，该节点为起点的深搜结束后，要进行回溯。
在传递结果find的时候容易犯错，Java的boolean类型是值传递不是引用传递，因此作为全局变量使用。
题解：
class Solution
boolean find = false;
public boolean exist(char[][] board, String word)
if (board.length==0||board[0].length==0)
return false;
int m = board.length;
int n = board[0].length;
boolean[][] visited = new boolean[m][n];
for(int i=0;i<m;++i)
Arrays.fill(visited[i],false);
for (int i=0;i<m;++i)
for (int j=0;j<n;++j)
backtracking(board,word,visited,i,j,0)
return find;
public void backtracking(char[][] board, String word, boolean[][] visited, int i, int j, int position)
//边界判断
if (i<0 || j<0 || i>=board.length || j>=board[0].length)
return;
//找到单词、该位置被访问、当前位置不等于需要的单词字母
//满足上述任一项返回
if (find || visited[i][j] || board[i][j]!=word.charAt(position))
return;
//找到该单词，返回结果
if (position+1==word.length())
find = true;
return;
//修改当前节点状态
visited[i][j] = true;
//递归子节，深搜向四个方向拓展
backtracking(board, word, visited, i+1, j, position+1);
backtracking以上是关于LeetCode刷题之搜索（Java）的主要内容，如果未能解决你的问题，请参考以下文章