weixin_63779802的博客

它接受一个`vector<vector<int>>`类型的参数`people`，其中每个内部向量包含两个整数：第一个整数表示身高，第二个整数表示该人的k值。它接受两个`vector<int>`类型的参数`a`和`b`，并返回一个布尔值。这段代码定义了一个名为`Solution`的类，其中包含两个成员函数：一个静态比较函数`cmp`和一个成员函数`reconstructQueue`。- 使用`sort`函数对`people`向量进行排序，排序规则由静态比较函数`cmp`提供。

【代码】219.贪心算法：柠檬水找零（力扣）

在这个循环中，如果当前孩子的评分比他后一个孩子的评分高（`ratings[i]>ratings[i+1]`），则当前孩子的糖果数应该是他后一个孩子的糖果数加1和他当前糖果数中的较大值（`candyNum[i]=max(candyNum[i+1]+1,candyNum[i]);在这个循环中，如果当前孩子的评分比他前一个孩子的评分高（`ratings[i]>ratings[i-1]`），则当前孩子的糖果数应该比前一个孩子的糖果数多1（`candyNum[i]=candyNum[i-1]+1;

【代码】217.贪心算法：加油站(力扣)

【代码】214.贪心算法：K次取反后最大化的数组和（力扣）

该算法使用贪心策略，每次选择当前能跳跃的最远位置，并更新下一次能跳跃的最远位置。遍历过程中，每当到达当前能跳跃的最远位置时，增加跳跃次数，并更新当前跳跃能到达的最远位置。如果在更新过程中，发现能到达或超过终点，跳出循环。，表示最少需要跳跃两次。

这个算法使用贪心算法的思路，通过遍历数组，每一步更新能到达的最远位置。如果能到达或超过数组的最后一个位置，则返回。

表示最大利润为7。

【代码】207.贪心算法：最大子数组和（力扣）

【代码】206.贪心算法：摆动序列（力扣）

以下来源于代码随想录。

【代码】202.回溯算法：全排列||（力扣）

【代码】201.回溯算法：全排列（力扣）

【代码】200.回溯算法：子集||（力扣）

【代码】198.回溯算法：子集（力扣）

【代码】197.回溯算法：复原IP地址（力扣）

【代码】195.回溯算法：分割回文串（力扣）

【代码】194.回溯算法：组合总和||（力扣）

包含所有符合条件的组合。

这个回溯算法的时间复杂度是 O(3^n * 4^m)，其中 n 是对应 3 个字母的数字（如 2、3、4、5、6、8）的个数，m 是对应 4 个字母的数字（如 7、9）的个数。这个复杂度源于每个数字对应的字母数量及其组合的所有可能性。

回溯算法是一种系统地搜索问题解的算法，适用于满足特定条件的所有解。在这个问题中，回溯用于从数字1到9中选出k个数，使它们的和为n。每次递归调用都会在当前组合中添加一个新的数字，并继续尝试加入更多数字，直到满足条件或不满足条件而进行剪枝。通过回溯和剪枝，可以有效地找到所有满足条件的组合。

回溯算法是一种通用的算法设计技巧，特别适用于解决组合、排列、子集等问题。它通过逐步构建解决方案，并在发现部分解决方案无效时撤销（回溯）部分计算，从而寻找所有可能的解决方案。回溯算法的基本思想是通过深度优先搜索（DFS）遍历所有可能的解空间，当发现某条路径不符合条件时，返回到上一步，尝试其他路径。

代码使用了递归的方法。主要思路是使用中序遍历的方式遍历二叉搜索树，但改变遍历的顺序，即先遍历右子树，然后访问当前节点，最后遍历左子树。在遍历过程中，每次访问一个节点时，将该节点的值加上其所有右子节点的值。这个算法的时间复杂度是 O(n)，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，其中 n 是树中节点的数量。在最坏的情况下，可能需要遍历整个树来找到需要修剪的节点。空间复杂度也是 O(n)，因为需要存储递归调用的栈。代码使用了递归的方法。主要思路是首先判断当前节点是否为空，如果为空，返回空。然后，根据当前节点的值与给定范围的关系，递归地修剪左子树和右子树。

代码使用了递归的方法。主要思路是首先判断当前节点是否为空，如果为空，返回空。然后，根据当前节点的值与要删除的值的关系，递归地在左子树或右子树中删除这个节点。这个算法的时间复杂度是 O(h)，其中 h 是树的高度。在最坏的情况下，可能需要遍历整个树来找到要删除的节点。空间复杂度也是 O(h)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(h)，其中 h 是树的高度。在最坏的情况下，可能需要遍历整个树来找到合适的位置插入新值。空间复杂度也是 O(h)，因为需要存储递归调用的栈。代码使用了递归的方法。主要思路是首先判断当前节点是否为空，如果是，创建一个新节点并返回。然后，根据新值与当前节点的值的关系，递归地在左子树或右子树中插入这个新值。

代码使用了递归的方法。主要思路是首先判断当前节点是否为空，如果为空，返回空。然后，根据 p 和 q 的值与当前节点的值的关系，递归地在左子树或右子树中寻找这两个节点。如果当前节点的值大于 p 和 q 的值，则 p 和 q 都在左子树；如果当前节点的值小于 p 和 q 的值，则 p 和 q 都在右子树；如果当前节点的值介于 p 和 q 之间，或者等于 p 或 q 的值，则当前节点即为最低公共祖先。这个算法的时间复杂度是 O(h)，其中 h 是树的高度。空间复杂度也是 O(h)，因为需要存储递归调用的栈。

代码使用了递归的方法。主要思路是首先判断根节点是否为空，如果为空，返回空。然后，判断根节点是否等于给定的两个节点中的任意一个，如果是，返回根节点。否则，递归地在左子树和右子树中寻找这两个节点，如果两个节点分别在左右子树中找到，则根节点即为最低公共祖先；如果一个节点在左子树中找到，另一个在右子树中找到，则根节点不是最低公共祖先；如果一个节点都没有找到，则根节点也不是最低公共祖先。这个算法的时间复杂度是 O(n)，其中 n 是树中节点的数量。在最坏的情况下，可能需要遍历整个树来找到最低公共祖先。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。代码使用了递归的方法。主要思路是从根节点开始，递归地检查左右子树。在递归过程中，使用一个全局变量。来记录中序遍历过程中的前一个节点，以确保每个节点的值都大于前一个节点的值。

代码使用了递归的方法。主要思路是首先判断根节点是否为空或者根节点的值是否等于目标值，如果是，则返回根节点。如果目标值小于根节点的值，则在左子树中继续搜索；如果目标值大于根节点的值，则在右子树中继续搜索。这个算法的时间复杂度是 O(h)，其中 h 是树的高度。在最坏的情况下，树是完全不平衡的，时间复杂度为 O(n)，其中 n 是树中节点的数量。空间复杂度也是 O(h)，因为需要存储递归调用的栈。

que。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。

这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈和所有可能的路径。

代码解决/** * 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(nullp

代码解决/** * 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(nullpt