深度优先搜索(DFS)-算法入门
深度优先搜索(DFS)-算法入门
DFS的主要六步
①递归树
②找结束条件(画出树后，结束条件比较好判断)
③找选择列表(看递归树)
④判断是否需要剪枝
⑤做出选择，递归调用，继续下一层递归
⑥撤销选择(回溯)
子集
题目描述：
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
解决方案：
class Solution {
public:
vector<int> temp;
vector<vector<int>> res;
void dfs(vector<int> &nums, int start, int n){
res.push_back(temp);
for (int i = start; i < n; i++) {
temp.push_back(nums[i]);
dfs(nums, i + 1, n);
temp.pop_back();
}
}
vector<vector<int>> subsets(vector<int>& nums) {
int n = nums.size();
dfs(nums, 0, n);
return res;
}
};
六步法分析：
①画出递归树(需要一些回溯的基础思维)
②找结束条件，很显然为空结束，可以省略不写
③找选择列表，从图中可以看出是选择走过路径之后的数，解答中的for (int i = start; i < n; i++)
就是我们的选择列表，对应我们图中的同一层的路径选择
④剪枝，显然图中的路径都是我们所需要的答案，所以不需要剪枝
⑤操作后递归，将路径保存，之后递归进入下一层
⑥回溯操作，相当于撤销该层的操作，与第⑤步中的操作反着来就可
如果我们的集合有重复元素？又该如何处理呢？
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
解决方案：
class Solution {
public:
vector<int> temp;
vector<vector<int>> res;
void dfs(vector<int> nums, int start, int n) {
res.push_back(temp);
for (int i = start; i < n; i++) {
if (i != start && nums[i] == nums[i - 1]) continue;
temp.push_back(nums[i]);
dfs(nums, i + 1, n);
temp.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
int n = nums.size();
sort(nums.begin(), nums.end());//与剪枝配套使用
dfs(nums, 0, n);
return res;
}
};
具体分析和上一题差不多，但是不一样的是需要我们去剪去一些不必要的分枝，如图
那么我们第④步的剪枝该怎么做呢，我们先需要对数组进行预处理，排序，让我们相同的值，挨在一起，当
if (i != start && nums[i] == nums[i - 1]) continue;就不用往下递归
以下有一些组合的题目，和子集类似，第⑤步稍有不同，直接贴题目和解决方案
组合
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。
class Solution {
public:
vector<int> path;
vector<vector<int>> res;
int cnt = 0;
void dfs(vector<int> nums, int start, int n, int target) {
if (cnt == target) {
res.push_back(path);
return;
}
for (int i = start; i < n; i++) {
if (cnt > target) continue;
cnt += nums[i];
path.push_back(nums[i]);
dfs(nums, i, n, target);//从i开始不用，满足题目重复选择
path.pop_back();
cnt -= nums[i];
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
int n = candidates.size();
dfs(candidates, 0, n, target);
return res;
}
};
当然还有不能重复使用的，剪枝方案和子集一样，排序后，相邻元素相同的枝条剪去。
全排列
题目描述：
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
class Solution {
public:
bool visited[6];
vector<int> path;
vector<vector<int>> res;
void dfs(vector<int>& nums, int depth, int n) {
for (int i = 0; i < path.size(); i++) cout<<path[i]<<" ";
cout << endl;
if (depth == n){
res.push_back(path);
return;
}
for (int i = 0; i < n; i++) {
if (!visited[i]){
path.push_back(nums[i]);
visited[i] = true;
dfs(nums, depth + 1, n);
visited[i] = false;
path.pop_back();
}
}
}
vector<vector<int>> permute(vector<int>& nums) {
int n = nums.size();
dfs(nums, 0, n);
return res;
}
};
分析：
因为全排列的题目，有顺序要求，所以选择列表不能，再选路径之后的数，我们需要要用一个visited数组来标记一个元素是否被访问过，本题不需要剪枝。
输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
同样的问题如果有重复元素该怎么办？还用之前的if (i != start && nums[i] == nums[i - 1]) continue;能行吗？看上去貌似可以，但是我们还需要添加一个条件if (i != start && nums[i] == nums[i - 1] && !visited[i - 1]) continue; 保证上一个元素是否被访问过，如果是即使相同也不能被减去，否则会出错，可以自行画递归树，或者调试感受。
总结
DFS的基本思考方式就是这些了，不过还有许多很难的搜索题目，需要我们去灵活运用这些基本方法，加以改进，递归的整个过程是人脑不可视的，通俗来讲，就是递归树我们的大脑很难整个去了解它的具体结构，我们往往是通过一些简单的例子去画出一个递归树，然后去揣摩它接下来的发展情况，写出代码，感觉上有点像数学上的归纳推理，所以我们没有必要去想象它整个运行的具体情况，这很费脑，也没有必要，从局部出发，推理全局。这里许多内容都借鉴了leetcode某位大佬的思想，大家也可以去大佬写的题解处看看
大佬的题解
以上题目均来自leetcode