算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习一（leetcode真题剖析）

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量1.9k 收藏 51
点赞数 79
分类专栏： 算法沉淀 文章标签： 算法 剪枝 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingxzq/article/details/136208157
版权

在这里插入图片描述

算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习一

01.全排列

题目链接：https://leetcode.cn/problems/permutations/

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

  • 1 <= nums.length <= 6
  • -10 <= nums[i] <= 10
  • nums 中的所有整数 互不相同

思路
这是一个典型的回溯问题，需要在每个位置上考虑所有可能情况，并确保不出现重复。通过深度优先搜索的方式，不断枚举每个数在当前位置的可能性，然后回溯到上一个状态，直到枚举完所有可能性得到正确的结果。

在这个问题中，可以通过一个递归函数 backtrack 和一个标记数组 visited 来实现全排列。递归函数的核心思想是在当前位置尝试放置每个数字，然后递归到下一层。同时，使用 visited 数组来判断某个数字是否已经在之前的位置出现过，以确保全排列的唯一性。

代码

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[7];
public:
    vector<vector<int>> permute(vector<int>& nums) {
        dfs(nums);
        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(!cheak[i]){
                path.push_back(nums[i]);
                cheak[i]=true;
                dfs(nums);
                path.pop_back();
                cheak[i]=false;
            }
        }
    }
};

02.子集

题目链接：https://leetcode.cn/problems/subsets/

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10
  • nums 中的所有元素 互不相同

思路

这里我们我们可以有下面两种写法，我们结合代码解释

代码一

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return ret;
    }

    void dfs(vector<int>& nums, int pos) {
        ret.push_back(path);

        for (int i = pos; i < nums.size(); ++i) {
            path.push_back(nums[i]);
            dfs(nums, i + 1);
            path.pop_back();
        }
    }
};

这段代码使用深度优先搜索（DFS）的思想。主要过程如下：

  1. 在dfs函数的一开始，将当前子集 path 加入结果集 ret。
  2. 然后使用循环，从当前位置 pos 开始遍历数组 nums。
  3. 对于每个元素，将其加入当前子集 path，然后递归调用 dfs 函数，继续生成包含当前元素的子集。
  4. 递归完成后，回溯，将刚刚加入的元素从当前子集 path 移出，继续循环遍历下一个元素。

这样，通过深度优先搜索，代码逐步生成了包含不同数量元素的所有子集。

代码二

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(nums, 0);
        return ret;
    }

    void dfs(vector<int>& nums, int pos) {
        if (pos == nums.size()) {
            ret.push_back(path);
            return;
        }

        path.push_back(nums[pos]);
        dfs(nums, pos + 1);
        path.pop_back();

        dfs(nums, pos + 1);
    }
};

这段代码同样使用深度优先搜索的思想。主要过程如下：

  1. 在dfs函数的一开始，检查当前位置 pos 是否等于数组 nums 的大小。如果相等，表示已经处理完所有元素，将当前子集 path 加入结果集 ret，然后返回结束当前 DFS 分支。
  2. 如果当前位置 pos 不等于数组大小，将当前元素加入子集 path，然后递归调用 dfs 函数，继续生成包含当前元素的子集。
  3. 递归完成后，回溯，将刚刚加入的元素从当前子集 path 移出。
  4. 继续递归调用 dfs 函数，生成不包含当前元素的子集。

这样，同样通过深度优先搜索，代码逐步生成了包含不同数量元素的所有子集。这种实现方式在递归的不同阶段进行了两次递归调用，一次是包含当前元素的情况，一次是不包含当前元素的情况。

03.找出所有子集的异或总和再求和

题目链接：https://leetcode.cn/problems/sum-of-all-subset-xor-totals/

一个数组的 异或总和 定义为数组中所有元素按位 XOR 的结果；如果数组为 空 ，则异或总和为 0 。

  • 例如，数组 [2,5,6] 的 异或总和 为 2 XOR 5 XOR 6 = 1 。

给你一个数组 nums ，请你求出 nums 中每个 子集 的 异或总和 ，计算并返回这些值相加之 和 。

**注意：**在本题中，元素 相同 的不同子集应 多次 计数。

数组 a 是数组 b 的一个 子集 的前提条件是：从 b 删除几个（也可能不删除）元素能够得到 a 。

示例 1：

输入：nums = [1,3]
输出：6
解释：[1,3] 共有 4 个子集：
- 空子集的异或总和是 0 。
- [1] 的异或总和为 1 。
- [3] 的异或总和为 3 。
- [1,3] 的异或总和为 1 XOR 3 = 2 。
0 + 1 + 3 + 2 = 6

示例 2：

输入：nums = [5,1,6]
输出：28
解释：[5,1,6] 共有 8 个子集：
- 空子集的异或总和是 0 。
- [5] 的异或总和为 5 。
- [1] 的异或总和为 1 。
- [6] 的异或总和为 6 。
- [5,1] 的异或总和为 5 XOR 1 = 4 。
- [5,6] 的异或总和为 5 XOR 6 = 3 。
- [1,6] 的异或总和为 1 XOR 6 = 7 。
- [5,1,6] 的异或总和为 5 XOR 1 XOR 6 = 2 。
0 + 5 + 1 + 6 + 4 + 3 + 7 + 2 = 28

示例 3：

输入：nums = [3,4,5,6,7,8]
输出：480
解释：每个子集的全部异或总和值之和为 480 。

提示：

  • 1 <= nums.length <= 12
  • 1 <= nums[i] <= 20

思路

这一题实际上还是和上一题类似的子集问题，只不过我们将存下的数组变为了一个值，进数组变为子集累计异或的值，出临时数组变为异或相同值，也就是删除异或过的数。

代码

class Solution {
    int sum=0,path=0;
public:
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return sum;
    }

    void dfs(vector<int>& nums,int pos){
        sum+=path;

        for(int i=pos;i<nums.size();++i){
            path^=nums[i];
            dfs(nums,i+1);
            path^=nums[i];
        }
    }
};
  1. int sum = 0, path = 0;: 这两个类成员变量用于追踪异或和的总和 (sum) 和当前正在生成的子集异或和 (path)。
  2. int subsetXORSum(vector<int>& nums): 这是主函数，用于调用 DFS 函数，并返回最终的异或和结果。
  3. void dfs(vector<int>& nums, int pos): 这是深度优先搜索（DFS）函数，用于递归生成所有子集的异或和。
    • sum += path;: 在每一层递归中，将当前子集的异或和加到总和中。
    • for(int i = pos; i < nums.size(); ++i) {: 循环从当前位置 pos 开始遍历数组 nums。
    • path ^= nums[i];: 将当前元素 nums[i] 异或到当前子集异或和中。
    • dfs(nums, i + 1);: 递归调用 DFS 函数，以 i + 1 为新的起点，生成包含当前元素的子集异或和。
    • path ^= nums[i];: 回溯，将刚刚异或的元素从当前子集异或和中移出，继续循环遍历下一个元素。
  4. 最终，sum 存储了所有子集的异或和总和，该值作为结果返回。

04.全排列 II

题目链接：https://leetcode.cn/problems/permutations-ii/

定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

  • 1 <= nums.length <= 8
  • -10 <= nums[i] <= 10

思路

这里要考虑全排列，在同一节点的所有组合中，相同的元素只能选择一次，所以这里我们要有一个标记元素是否使用的数组，在后面的主逻辑递归中，有两种写法，第一种是只关心“不合法”分支，第二种是只关心“合法”分支。

代码一

class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos){
        if(pos==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();++i){
            if(cheak[i]||(i!=0&&nums[i]==nums[i-1]&&cheak[i-1]==false))
                continue;
            path.push_back(nums[i]);
            cheak[i]=true;
            dfs(nums,pos+1);
            path.pop_back();
            cheak[i]=false;
        }
    }
};

  1. vector<vector<int>> ret;: 用于存储所有的全排列结果。

  2. vector<int> path;: 用于存储当前正在生成的排列。

  3. bool cheak[9];: 一个布尔数组，用于标记在当前生成排列的过程中哪些元素已经被选择。

  4. vector<vector<int>> permuteUnique(vector<int>& nums): 主函数，用于调用 DFS 函数，并返回最终的全排列结果。

  5. sort(nums.begin(), nums.end());: 在开始生成排列之前，先将输入数组排序，以便处理重复元素。

  6. void dfs(vector<int>& nums, int pos): 深度优先搜索函数，递归生成全排列。

    • if(pos == nums.size()): 如果当前位置 pos 等于数组的大小，表示已经处理完所有元素，将当前排列加入结果集。
      • ret.push_back(path);: 将当前排列加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(int i = 0; i < nums.size(); ++i): 遍历数组中的每个元素。
      • if(cheak[i] || (i != 0 && nums[i] == nums[i-1] && cheak[i-1] == false)): 如果当前元素已经被选择（cheak[i] 为 true）或者当前元素与前一个元素相同，且前一个元素未被选择，则跳过当前循环。这是为了处理重复元素的情况，确保不会生成重复的排列。
        • continue;: 跳过当前循环，进入下一个循环。
      • path.push_back(nums[i]);: 将当前元素加入排列。
      • cheak[i] = true;: 将当前元素标记为已选择。
      • dfs(nums, pos + 1);: 递归调用 DFS 函数，继续生成下一个元素的排列。
      • path.pop_back();: 回溯，将刚刚加入的元素移出排列。
      • cheak[i] = false;: 回溯，将刚刚标记为已选择的元素重新标记为未选择。

    代码二

    class Solution {
    vector<vector<int>> ret;
    vector<int> path;
    bool cheak[9];
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return ret;
    }

    void dfs(vector<int>& nums,int pos){
        if(pos==nums.size())
        {
            ret.push_back(path);
            return;
        }

        for(int i=0;i<nums.size();++i){
            if(!cheak[i]&&(i==0||nums[i]!=nums[i-1]||cheak[i-1]==true))
            {
                path.push_back(nums[i]);
                cheak[i]=true;
                dfs(nums,pos+1);
                path.pop_back();
                cheak[i]=false;
            }
        }
    }
};
    1. vector<vector<int>> ret;: 用于存储所有的全排列结果。
    2. vector<int> path;: 用于存储当前正在生成的排列。
    3. bool cheak[9];: 一个布尔数组，用于标记在当前生成排列的过程中哪些元素已经被选择。
    4. vector<vector<int>> permuteUnique(vector<int>& nums): 主函数，用于调用 DFS 函数，并返回最终的全排列结果。
    5. sort(nums.begin(), nums.end());: 在开始生成排列之前，先将输入数组排序，以便处理重复元素。
    6. void dfs(vector<int>& nums, int pos): 深度优先搜索函数，递归生成全排列。
      • if(pos == nums.size()): 如果当前位置 pos 等于数组的大小，表示已经处理完所有元素，将当前排列加入结果集。
        • ret.push_back(path);: 将当前排列加入结果集。
        • return;: 返回结束当前 DFS 分支。
      • for(int i = 0; i < nums.size(); ++i): 遍历数组中的每个元素。
        • if(!cheak[i] && (i == 0 || nums[i] != nums[i-1] || cheak[i-1] == true)): 如果当前元素未被选择且（是第一个元素或者与前一个元素不相同或者前一个元素已被选择），则进入循环。
          • path.push_back(nums[i]);: 将当前元素加入排列。
          • cheak[i] = true;: 将当前元素标记为已选择。
          • dfs(nums, pos + 1);: 递归调用 DFS 函数，继续生成下一个元素的排列。
          • path.pop_back();: 回溯，将刚刚加入的元素移出排列。
          • cheak[i] = false;: 回溯，将刚刚标记为已选择的元素重新标记为未选择。

05.电话号码的字母组合

题目链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。

思路

这里比前面的排列组合更为简单，只不过在这里我们需要额外创建一个哈希结构来建立数字和字母的映射关系。

代码

class Solution {
    string hash[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs","tuv", "wxyz"};
    string path;
    vector<string> ret;
public:
    vector<string> letterCombinations(string digits) {
        if(!digits.size()) return ret;
        dfs(digits,0);
        return ret;
    }

    void dfs(string& digits,int pos){
        if(pos==digits.size()){
            ret.push_back(path);
            return;
        }

        for(auto ch:hash[digits[pos]-'0']){
            path+=ch;
            dfs(digits,pos+1);
            path.pop_back();
        }
    }
};
  1. string hash[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs","tuv", "wxyz"};: 数字与对应的字母组合的映射关系，hash[2] 对应 “abc”，hash[3] 对应 “def”，以此类推。
  2. string path;: 用于存储当前正在生成的字母组合。
  3. vector<string> ret;: 用于存储所有的字母组合结果。
  4. vector<string> letterCombinations(string digits): 主函数，用于调用 DFS 函数，并返回最终的字母组合结果。
  5. if(!digits.size()) return ret;: 如果输入的数字序列为空，则直接返回空的结果集。
  6. void dfs(string& digits, int pos): 深度优先搜索函数，递归生成数字序列对应的所有字母组合。
    • if(pos == digits.size()): 如果当前位置 pos 等于数字序列的大小，表示已经处理完所有数字，将当前字母组合加入结果集。
      • ret.push_back(path);: 将当前字母组合加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(auto ch : hash[digits[pos] - '0']): 遍历当前数字对应的所有字母。
      • path += ch;: 将当前字母加入字母组合。
      • dfs(digits, pos + 1);: 递归调用 DFS 函数，继续生成下一个数字对应的字母组合。
        )`: 主函数，用于调用 DFS 函数，并返回最终的字母组合结果。
  7. if(!digits.size()) return ret;: 如果输入的数字序列为空，则直接返回空的结果集。
  8. void dfs(string& digits, int pos): 深度优先搜索函数，递归生成数字序列对应的所有字母组合。
    • if(pos == digits.size()): 如果当前位置 pos 等于数字序列的大小，表示已经处理完所有数字，将当前字母组合加入结果集。
      • ret.push_back(path);: 将当前字母组合加入结果集。
      • return;: 返回结束当前 DFS 分支。
    • for(auto ch : hash[digits[pos] - '0']): 遍历当前数字对应的所有字母。
      • path += ch;: 将当前字母加入字母组合。
      • dfs(digits, pos + 1);: 递归调用 DFS 函数，继续生成下一个数字对应的字母组合。
      • path.pop_back();: 回溯，将刚刚加入的字母移出字母组合。
爱学习的鱼佬
关注
  • 79
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 35
    评论
专栏目录
算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习三（leetcode真题剖析）
立志做一个高产且细节博主
02-22 1356
在检查皇后是否冲突时，可以使用一个数组来记录每一列是否已经放置了皇后，并检查当前要放置的皇后是否会和已经放置的皇后冲突。对于对角线，可以使用两个数组来记录从左上角到右下角的每一条对角线上是否已经放置了皇后，以及从右上角到左下角的每一条对角线上是否已经放置了皇后。通过深度优先搜索的方式，不断地枚举每个数在当前位置的可能性，并回溯到上一个状态，直到枚举完所有可能性，得到正确的结果。首先，在每一行放置第一个皇后，然后遍历棋盘的第二行，在可行的位置放置第二个皇后，再遍历第三行，以此类推，直到放置了n个皇后为止。
算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习四（leetcode真题剖析）
立志做一个高产且细节博主
02-23 1050
通过深度优先搜索的方式，不断地枚举相邻元素作为下一个字母出现的可能性，并在递归结束时回溯，直到枚举完所有可能性，得到正确的结果。这里和上面的回溯不太一样的地方在于我们必须通过所有的0标记位置，首先我们要计算出所有0的个数，再加上1个2的位置就是我们要走的路的长度，依照要走的长度和起始位置找到不同的路线，这里可以使用深度优先遍历找到不同的路径。为了存储每个位置的元素，我们需要定义一个二维数组。特别地，在本题中，我们需要直接修改给出的数组，因此在找到一种可行的方法时，应该停止递归，以防止正确的方法被覆盖。
算法沉淀——穷举、暴搜、深搜、回溯、剪枝综合练习二（leetcode真题剖析）
立志做一个高产且细节博主
02-22 1234
为了提高时间复杂度，可以事先计算数组中所有数字的和 以及数组的长度。这道题目要求从1到n中选择k个数的所有组合，其中不考虑顺序，即[1,2]和[2,1]等价。这样的判断方式确保了在递归的过程中，左括号数量始终大于等于右括号数量，并且左括号的总数量与右括号的总数量相等，保证生成的括号序列是合法的。因此，在选择当前元素并向下传递下标时，应该直接传递当前元素的下标。这样的流程能够确保生成所有的组合，并且通过限制选择元素的大小顺序，避免了重复计算。代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且。
c语言动态规划回溯的原理,「算法思想」分治、动态规划、回溯、贪心一锅炖...
weixin_39570777的博客
05-24 204
观感度：?????口味：东北一锅出烹饪时间：10min本文已收录在Github github.com/Geekhyt，感谢Star。数据结构与算法系列专栏第四弹来袭，往期专栏链接如下：初学者一听到算法思想，就会觉得它们高深莫测，只能望而却步。但如果你看过《事实》这本书，你就不会被大脑中的惯性思维所影响。只要我们理解算法思想的关键点，多做题练习并加深理解记忆。其实算法思想就像切菜一样简单。上一篇算法...
十道经典面试算法真题详解
热门推荐
weixin_62650212的博客
04-01 2万+
分享一下腾讯常考的十道算法题（真题）。在金三银四，希望对大家有帮助呀。重排链表最长递增子序列环形链表反转链表最长回文子串全排列LRU 缓存合并K个升序链表无重复字符的最长子串删除链表的倒数第 N 个结点1.  重排链表给定一个单链表 L 的头节点 head ，单链表 L 表示为：L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为：L0...
将分治、动态规划、回溯、贪心一锅炖
童欧巴的博客
06-14 528
分治算法 Divide and Conquer、动态规划 Dynamic Programming、LeetCode题解、爬楼梯、贪心算法 Greedy、分发饼干、回溯算法 Backtracking、电话号码的字母组合、
【学习笔记】【C++】【Leetcode 分门别类讲解】
多丰富下自己呀
06-27 547
目录概述一、时间复杂度分析二、数组问题。 概述 一、时间复杂度分析 图的遍历：邻接表实现 ：O(e+V) ；邻接矩阵实现O（e2) ；e为节点数，V为边数。 字符串数组，先对字符串排顺序，再将数组按照字典序排序：时间复杂度：O( nslogs+snlogn),因为排序n个字符串+n个字符串的排序（字符串也得遍历一遍） 均摊时间复杂度问题： 对动态数组的扩容和缩容来说，均摊下去时间复杂度只是O(1)；所以造成动态数组的操作，整体的均摊时间复杂度为O(1)； 但是要注意用lazy resize，避免复杂
用递归与分治策略求解网球循环赛日程表_分治、动态规划、回溯、贪心一锅炖
weixin_39756192的博客
11-23 423
「观感度：五颗星」「口味：东北一锅出」「烹饪时间：10min」本文已收录在Github github.com/Geekhyt，感谢Star。数据结构与算法系列专栏第四弹来袭，往期专栏链接如下：前端如何搞定数据结构与算法JavaScript算法时间、空间复杂度分析你真的懂递归吗？初学者一听到算法思想，就会觉得它们高深莫测，只能望而却步。但如果你看过《事实》这本书，你就不会被大脑中的惯性思维所影响。 ...
【C++】【学习笔记】【动态规划问题详解与例题】记忆化搜索与暴力穷举思想 ；0-1 背包问题；子序列问题；
多丰富下自己呀
07-05 441
目录总框架总目录：九、动态规划问题1、参考练习题2、记忆化搜索与暴力穷举思想的重要性3、0-1 背包问题4、0-1 背包问题- 变种5、0-1 背包问题- 例题6、 最长上升子序列7、 最长上升子序列 -例题7、 最长公共子序列 LCS8、 动态规划找出具体解1、子序列具体解2、0 - 1 背包问题具体解参考 总框架 总目录： 【学习笔记】玩转算法面试-- Leetcode真题分门别类讲解 九、动态规划问题 经典动态规划问题：斐波那契数列； 记忆化搜索：递归的基础上，添加记忆化；自上而下解决问题。 动态
python算法练习——解空间的穷举搜索与Google方程式
01-07
目录解空间的穷举搜索与Google方程式解空间的穷举搜索解空间的定义穷举解空间的策略Google方程式解决策略算法实现运行致谢 解空间的穷举搜索与Google方程式 解空间的穷举搜索 解空间又称为状态空间，是所有可能是解...
算法与程序设计——穷举法.doc
05-12
算法与程序设计——穷举法是一种解决问题的方法，它通过穷举所有可能的情况来找到答案。在本文档中，我们将探讨穷举法的基本概念、设计算法的基本过程、穷举法的应用范围以及如何使用穷举法设计程序解决问题。 一、...
五大常用算法——回溯算法详解及经典例题，算法数据结构 五大常用算法
04-07
回溯算法是一种常用的搜索算法，它可以用于解决许多复杂的问题。回溯算法的基本思想是，通过不断地尝试和回溯来找到问题的解。它可以看作蛮力法穷举搜索的改进，能够避免搜索所有可能的解，从而提高搜索效率。 在...
5G中基于穷举搜索的D2D资源分配算法
04-30
针对传统复用算法的系统中断概率过高和用户资源消耗较大的问题，提出一种基于穷举搜索的D2D资源分配算法。该算法引入穷举搜索法初步确定用户发射功率；同时参考蜂窝与D2D用户状态以确定复用组合；应用调整功率步骤...
穷举n位二进制数.rar_穷举问题_算法设计与分析
09-24
总的来说，这个压缩包文件中的内容可能包含了一段实现上述逻辑的代码示例，用于教学或自我练习，帮助理解穷举算法在生成二进制数问题上的应用。学习者可以通过分析和运行这段代码，加深对穷举算法和二进制数的理解。
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 611
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 670
后缀表示法。
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 266
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
【算法】插入排序
贱贱的剑
07-03 1008
介绍了两种不同的插入排序算法，以及效率对比
常用算法设计方法.doc
09-20
算法应具备正确性、可靠性和高效性，常见的设计技术包括迭代法、穷举搜索法、递推法、贪婪法、回溯法、分治法以及动态规划法。文中特别提到了迭代法，作为求解方程或方程组近似根的一种常见策略，通过迭代过程逐步...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 35
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的鱼佬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值