递归算法的关键在于回复现场，dfs（）函数返回值、结束条件、它的作用。
目录
1.综合练习
关键在画出的决策树当中，前面使用过的2、3，后面的3、2，就不需要再次使用了，下次是从 i 位置开始继续向下进行递归操作。同时需要注意当 sum 的值超过 aim 的时候就需要结束循环条件。（因为刚做过就不画出详细的图片了）
class Solution {
public:
int aim = 0;
vector<vector<int>> ret;
vector<int> path;
unordered_map<int, vector<int>> hash();
vector<vector<int>> combinationSum(vector<int>& candidates, int target)
{
aim = target;
dfs(candidates, 0, 0);
return ret;
}
void dfs(vector<int>& nums, int pos, int sum)
{
if(aim == sum)
{
ret.push_back(path);
return;
}
//如果是加的特别多了，就要向前进行返回
if(sum > aim || pos >= nums.size())
{
return;
}
for(int i = pos; i < nums.size(); i++)
{
path.push_back(nums[i]);
dfs(nums, i, sum += nums[i]);//递归到当前的位置继续进行选择，进行递归的是下一次的和，要不然返回来的时候
sum -= nums[i];
path.pop_back();
}
}
};
加 或者是 减有两种情况可以。注意最后的返回是 nums.size() == n 即可。
class Solution {
public:
int cnt = 0,sum = 0,n = 0,_target = 0;
int findTargetSumWays(vector<int>& nums, int target)
{
//使用 dfs，进行暴力传递 nums，以及pos位置
n = nums.size();
_target = target;
dfs(nums, 0);//从 0 位置开始进行递归
return cnt;
}
void dfs(vector<int>& nums, int pos)
{
if(nums.size() == pos)
{
if(sum == _target) cnt++;
return ;
}
//进行分别进行选与不选的操作
sum += nums[pos];
dfs(nums, pos + 1);
sum -= nums[pos];
sum -= nums[pos];
dfs(nums, pos + 1);
sum += nums[pos];
}2. 二叉树的深搜
2331. 计算布尔二叉树的值 - 力扣（LeetCode）
计算布尔值，知道左子树的布尔值，右子树的布尔值，以及此时根结点的布尔值，如此一来，这就是一个后续遍历二叉树。定义 dfs(TreeNode* root),返回值就是布尔值。关键在于以当前的位置为视角去判断左右子树。(由于是二次刷题，此处只展示核心代码部分).
if(root->left == NULL && root->right == NULL) return root->val == 0 ? false : true;
bool left = evaluateTree(root->left);
bool right = evaluateTree(root->right);
if(root->val == 2)
{
return left | right;
}
else return left & right;
这道题不是二叉树深搜的题目，是一道寻找子问题的题目,但是还是需要进行一次深度优先遍历dfs(ListNode* head),这个函数的操作就是将 head 以后的结点后进行翻转操作。
子问题为：进行到当前的位置，如果是他的下一个位置不为 NULL，就需要将他下一个的下一个指向头位置.
if(head == NULL || head->next == NULL) return head;
ListNode* Fhead = reverseList(head->next);
head->next->next = head;
head->next = NULL;
return Fhead;129. 求根节点到叶节点数字之和 - 力扣（LeetCode）
需要注意的是，在这个函数里面 ret 的不可定义为全局的变量，因为我们控制的 dfs 的意义为在当前位置的时候计算一下左右子树的和。其实每回进行的时候 ret 都要初始化为 0；
int sumNumbers(TreeNode* root) {
//通过递归进行实现，现在一个函数已经无法满足
return dfs(root, 0);
//dfs 返回的是当前点加上 左右结点的和，还有另外一个函数表示的是到当前位置的时候此时前面的和
}
int dfs(TreeNode* root, int pernum)
{
int ret = 0;
//dfs 表示从 0 开始向下进行遍历的求和
pernum = pernum * 10 + root->val;
if(root->left == NULL && root->right == NULL)
{
return pernum;
}
//相当于遍历到了最后的一个位置，然后计算左右子树的和
if(root->left) ret += dfs(root->left, pernum);
if(root->right) ret += dfs(root->right, pernum);
return ret;
}
一看到这种题，就应当想到以当前位置结点，判断左子树，右子树的情况，如果是当前位置空直接返回，当前位置的左为空，右为空，同时 root->val == 0。我们就将当前位置变成 NULL；
TreeNode* pruneTree(TreeNode* root) {
//通过分析判断得到，这个函数跟我想要的一样
if(root == nullptr) return nullptr;
//1.分别处理左右子树
root->left = pruneTree(root->left);
root->right = pruneTree(root->right);
//处理完之后去处理一下根
if(root->left == nullptr && root->right == nullptr && root->val == 0)
{
root = nullptr;
}
return root;
}
这道题需要使用 搜索二叉树的一个性质为：中序遍历完全符合升序的特点，如果是不符合就使用剪枝进行返回一个 false。dfs（）表示以当前的位置为结点时候为二叉搜索树，返回值为 ture 或者是 false,递归出去的条件为：左右子树都为空的情况。
long prev = LONG_MIN;
if(root->left == NULL && root->right == NULL) return true;//一个结点肯定是二叉搜索树
//需要判断左子树的 bool
bool left = isValidBST(root->left);
if(left == false) return false;
//判断 根时候符合
bool tmp = false;
if(root->val > perv) tmp = true;
perv = root->val;
//进行剪枝
if(tmp == false) return false;
//判断右子树
bool right = isValidBST(root->right);
if(right == false) return false;
if(right && left && tmp) return true;
return false;//照顾编译器，防止最后出错230. 二叉搜索树中第 K 小的元素 - 力扣（LeetCode）
dfs(TreeNode* root)就是进行遍历，当前结点为 NULL 的时候进行返回。需要定义全局变量 cnt 表示进行到了第几个，ret 表示最后的结果。每次判断根部的时候就cnt --；
class Solution {
public:
//定义两个全局变量，一个表示还需要进行的次数，直到小于 0 为止，另外一个表示最后的结果
// int cnt;
// int ret;
void dfs(TreeNode* root)
{
if(root == NULL || cnt == 0 ) return;
dfs(root->left);
cnt--;
if(cnt == 0)
{
ret = root->val;
return;
}
dfs(root->right);
}
int kthSmallest(TreeNode* root, int k) {
// cnt = k;
// dfs(root);//通过深度优先遍历来修改ret的值
// return ret;
cnt = k;
dfs(root);
return ret;
}
int cnt = 0;
int ret = 0;
dfs(root, path)，除了定义一个 root，还需要定义一个path，表示通过的路径。如果不在这里定义就需要将遍历一遍就进行复原。定义一个 path 会方便很多。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
//定义两个全局变量
//string path;
vector<string> ret;
vector<string> binaryTreePaths(TreeNode* root)
{
string path;
dfs(root, path);
return ret;
}
void dfs(TreeNode* root, string path)
{
path += to_string(root->val);
if(root->left == NULL && root->right == NULL)
{
ret.push_back(path);
return;
}
path.push_back('-');
path.push_back('>');
if(root->left)
{
dfs(root->left, path);
}
if(root->right)
{
dfs(root->right, path);
}
}
};
经典中的经典。
class Solution {
public:
vector<vector<int>> ret;//表示最后结果
vector<int> path;//走的路径
bool used[8];//表示当前的数是否被使用了
vector<vector<int>> permute(vector<int>& nums) {
dfs(nums);//从 0 位置开始进行遍历
return ret;
}
void dfs(vector<int>& nums)
{
if(path.size() == nums.size())
{
ret.push_back(path);
return;
}
for(int i = 0; i < nums.size(); i++)
{
if(used[i] == false)
{
path.push_back(nums[i]);
used[i] = true;
dfs(nums);
path.pop_back();
used[i] = false;
}
}
}
};
扫一扫
569
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
