LeetCode-题目详解（十一）：回溯算法【递归回溯、迭代回溯】【DFS是一个劲往某一个方向搜索；回溯算法建立在DFS基础之上，在搜索过程中，达到结束/裁剪条件后，恢复状态，回溯上一层，再次搜索】

已于 2023-01-06 21:05:59 修改
阅读量408 收藏 3
点赞数
文章标签： 递归 回溯算法
于 2021-06-14 22:50:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013250861/article/details/117914039
版权

这里写目录标题

一、概述

1、深度优先遍历（DFS） 和回溯算法区别

DFS 是一个劲的往某一个方向搜索，而回溯算法建立在 DFS 基础之上的，但不同的是在搜索过程中，达到结束条件后，恢复状态，回溯上一层，再次搜索。因此回溯算法与 DFS 的区别就是有无状态重置

「回溯法」实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就「回溯」返回，尝试别的路径。

回溯法是一种算法思想，而递归是一种编程方法，回溯法可以用递归来实现。

回溯法的整体思路是：搜索每一条路，每次回溯是对具体的一条路径而言的。对当前搜索路径下的的未探索区域进行搜索，则可能有两种情况：

  • 当前未搜索区域满足结束条件，则保存当前路径并退出当前搜索；
  • 当前未搜索区域需要继续搜索，则遍历当前所有可能的选择：如果该选择符合要求，则把当前选择加入当前的搜索路径中，并继续搜索新的未探索区域。

上面说的未搜索区域是指搜索某条路径时的未搜索区域，并不是全局的未搜索区域。

回溯法搜所有可行解的模板一般是这样的：

res = []
path = []

def backtrack(未探索区域, res, path):
    if 未探索区域满足结束条件:
        res.add(path) # 深度拷贝
        return
    for 选择 in 未探索区域当前可能的选择:
        if 当前选择符合要求:
            path.add(当前选择)
            backtrack(新的未探索区域, res, path)
            path.pop()

2、 何时使用回溯算法

当问题需要 “回头”，以此来查找出所有的解的时候，使用回溯算法。即满足结束条件或者发现不是正确路径的时候(走不通)，要撤销选择，回退到上一个状态，继续尝试，直到找出所有解为止

3、回溯算法步骤

  1. 画出递归树，找到状态变量(回溯函数的参数)，这一步非常重要※
  2. 根据题意，确立结束条件
  3. 找准选择列表(与函数参数相关),与第一步紧密关联※
  4. 判断是否需要剪枝
  5. 作出选择，递归调用，进入下一层
  6. 撤销选择

4、回溯问题的类型

在这里插入图片描述
注意：子集、组合与排列是不同性质的概念。子集、组合是无关顺序的，而排列是和元素顺序有关的，如 [1，2] 和 [2，1] 是同一个组合(子集)，但 [1,2] 和 [2,1] 是两种不一样的排列！！！！因此被分为两类问题

二、LeetCode案例

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

  • 所有数字（包括 target）都是正整数。
  • 解集不能包含重复的组合。

示例 1：

输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
  [7],
  [2,2,3]
]

示例 2：

输入：candidates = [2,3,5], target = 8,
所求解集为：
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

提示：

  • 1 <= candidates.length <= 30
  • 1 <= candidates[i] <= 200
  • candidate 中的每个元素都是独一无二的。
  • 1 <= target <= 500

在这里插入图片描述

思路分析：根据示例 1：输入: candidates = [2, 3, 6, 7]，target = 7。

  • 候选数组里有 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
  • 同理考虑 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。

基于以上的想法，可以画出如下的树形图。建议大家自己在纸上画出这棵树，这一类问题都需要先画出树形图，然后编码实现。

编码通过 深度优先遍历 实现，使用一个列表，在 深度优先遍历 变化的过程中，遍历所有可能的列表并判断当前列表是否符合题目的要求，成为「回溯算法」（个人理解，非形式化定义）。

在这里插入图片描述

  • 以 target = 7 为 根结点 ，创建一个分支的时 做减法 ；
  • 每一个箭头表示：从父亲结点的数值减去边上的数值，得到孩子结点的数值。边的值就是题目中给出的 candidate 数组的每个元素的值；
  • 减到 00 或者负数的时候停止，即：结点 00 和负数结点成为叶子结点；
  • 所有从根结点到结点 00 的路径（只能从上往下，没有回路）就是题目要找的一个结果。

这棵树有 44 个叶子结点的值 00，对应的路径列表是 [[2, 2, 3], [2, 3, 2], [3, 2, 2], [7]]，而示例中给出的输出只有 [[7], [2, 2, 3]]。即：题目中要求每一个符合要求的解是 不计算顺序 的。下面我们分析为什么会产生重复。

产生重复的原因是：在每一个结点，做减法，展开分支的时候，由于题目中说 每一个元素可以重复使用，我们考虑了 所有的 候选数，因此出现了重复的列表。

一种简单的去重方案是借助哈希表的天然去重的功能，但实际操作一下，就会发现并没有那么容易。

可不可以在搜索的时候就去重呢？答案是可以的。遇到这一类相同元素不计算顺序的问题，我们在搜索的时候就需要 按某种顺序搜索。具体的做法是：每一次搜索的时候设置 下一轮搜索的起点 begin，请看下图。

在这里插入图片描述
即：从每一层的第 22 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。

如果题目要求，结果集不计算顺序，此时需要按顺序搜索，才能做到不重不漏。「力扣」第 47 题（ 全排列 II ）、「力扣」第 15 题（ 三数之和 ）也使用了类似的思想，使得结果集没有重复。

在这里插入图片描述

回溯算法模板【Python】：

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.path = []

        self.back_tracking(candidates, target, 0, 0)

        return self.result

    def back_tracking(self, nums, target, total, start):
        if total > target:
            return

        if total == target:
            curr_path = self.path[:]    # 对于python来说，必不可少
            self.result.append(curr_path)
            return
        
        for i in range(start, len(nums)):
            self.path.append(nums[i])
            total += nums[i]
            self.back_tracking(nums, target, total, i)
            self.path.pop()
            total -= nums[i]

回溯算法模板【C++】：

class Solution {
   
public:
    vector<vector<int>> result;
    vector<int> path;

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
   
        backTracking(candidates, target, 0, 0);
        return result;
    }

    void backTracking(vector<int>& nums, int target, int total, int start){
   
        if(total > target){
   
            return;
        }
        if(total == target){
   
            result.push_back(path);
            return;
        }
        for(int i = start; i < nums.size(); i++){
   
            path.push_back(nums[i]);
            total += nums[i];
            backTracking(nums, target, total, i);
            path.pop_back();
            total -= nums[i];
        }
    }
};

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:

        result = []

        # 回溯算法
        def dfs(nums, temp_target, path):

            # 递归结束条件
            if temp_target < 0:
                return
            
            # 逻辑主体部分
            if temp_target == 0:
                result.append(path)

            # 递归
            for idx, num in enumerate(nums):
                dfs(nums[idx:], temp_target - num, path + [num])


        dfs(candidates, target, [])
        
        return result

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.dfs(candidates, target, [])
        return self.result

    def dfs(self, nums, target, path):
        if sum(path) > target:
            return

        if sum(path) == target:
            self.result.append(path)
            return
        
        for idx, num in enumerate(nums):
            self.dfs(nums[idx:], target, path + [num])

剪枝提速

  • 根据上面画树形图的经验，如果 target 减去一个数得到负数，那么减去一个更大的树依然是负数，同样搜索不到结果。基于这个想法，我们可以对输入数组进行排序，添加相关逻辑达到进一步剪枝的目的；
  • 排序是为了提高搜索速度，对于解决这个问题来说非必要。但是搜索问题一般复杂度较高，能剪枝就尽量剪枝。实际工作中如果遇到两种方案拿捏不准的情况，都试一下。

回溯算法模板【Python】：

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.path = []

        candidates.sort()   # 排序不是必须操作
        self.back_tracking(candidates, target, 0, 0)

        return self.result

    def back_tracking(self, nums, target, total, start):
        if total > target:
            return

        if total == target:
            curr_path = self.path[:]    # 对于python来说，必不可少
            self.result.append(curr_path)
            return
        
        for i in range(start, len(nums)):
            self.path.append(nums[i])
            total += nums[i]
            self.back_tracking(nums, target, total, i)
            self.path.pop()
            total -= nums[i]

回溯算法模板【C++】：

class Solution {
   
public:
    vector<vector<int>> result;
    vector<int> path;

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
   
        sort(candidates.begin(), candidates.end()); // 排序不是必须操作
        
        backTracking(candidates, target, 0, 0);
        return result;
    }

    void backTracking(vector<int>& nums, int target, int total, int start){
   
        if(total > target){
   
            return;
        }
        if(total == target){
   
            result.push_back(path);
            return;
        }
        for(int i = start; i < nums.size(); i++){
   
            path.push_back(nums[i]);
            total += nums[i];
            backTracking(nums, target, total, i);
            path.pop_back();
            total -= nums[i];
        }
    }
};

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:

        result = []

        # 回溯算法
        def dfs(nums, temp_target, path):

            # 递归结束条件【剪枝：如果当前temp_target < 0，没必要枚举了，直接return】
            if temp_target < 0:
                return
            
            # 逻辑主体部分
            if temp_target == 0:
                result.append(path)

            # 递归
            for idx, num in enumerate(nums):
                # 在搜索的时候就去重：这一类相同元素不计算顺序的问题，我们在搜索的时候就按某种顺序搜索。
                # 从每一层的第 2 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。
                dfs(nums[idx:], temp_target - num, path + [num])

        candidates.sort()   # 排序不是必须操作

        dfs(candidates, target, [])
        
        return result

40. 组合总和II

给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

说明：

  • 所有数字（包括目标数）都是正整数。
  • 解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
所求解集为:
[
  [1,2,2],
  [5]
]

一句话题解：按顺序搜索，设置合理的变量，在搜索的过程中判断是否会出现重复集结果。

与第 39 题（组合之和）的差别：

  • 第 39 题：candidates 中的数字可以无限制重复被选取；
  • 第 40 题：candidates 中的每个数字在每个组合中只能使用一次。

相同点是：相同数字列表的不同排列视为一个结果。

为了避免产生重复解，本题candidates务必排序。

如何去掉重复的集合（重点），为了使得解集不包含重复的组合。有以下 2 种方案：

  • 使用 哈希表 天然的去重功能，但是编码相对复杂；
  • 这里我们使用和第 39 题和第 15 题（三数之和）类似的思路：不重复就需要按 顺序 搜索， 在搜索的过程中检测分支是否会出现重复结果 。注意：这里的顺序不仅仅指数组 candidates 有序，还指按照一定顺序搜索结果。

在这里插入图片描述
在这里插入图片描述
由第 39 题我们知道，数组 candidates 有序，也是 深度优先遍历 过程中实现「剪枝」的前提。

将数组先排序的思路来自于这个问题：去掉一个数组中重复的元素。很容易想到的方案是：先对数组 升序 排序，重复的元素一定不是排好序以后相同的连续数组区域的第 1 个元素。也就是说，剪枝发生在：同一层数值相同的结点第 2、3 … 个结点，因为数值相同的第 1 个结点已经搜索出了包含了这个数值的全部结果，同一层的其它结点，候选数的个数更少，搜索出的结果一定不会比第 1 个结点更多，并且是第 1 个结点的子集。

class Solution:
    def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:
        self.result = []
        nums.sort() # 排序是必须操作
        self.dfs(nums, target, [])
        return self.result
    
    # 回溯算法
    def dfs(self, nums, target, path):
        # 递归结束条件【剪枝：如果当前total > target，没必要枚举了，直接return】
        if target < 0:
            return
        # 逻辑主体部分
        if target == 0:
            self.result.append(path)
        # 递归
        for idx, num in enumerate(nums):
            # 在搜索的时候就去重：这一类相同元素不计算顺序的问题，我们在搜索的时候就按某种顺序搜索。
            # 从每一层的第 2 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。
            # 而且重复的元素要跳过，防止产生重复数组
            if idx > 0 and nums[idx] == nums[idx - 1]:
                continue
            self.dfs(nums[idx + 1:], target - num, path + [num])

回溯算法模板【Python】：

class Solution:
    def combinationSum2(self, nums: List[int], target: int) -> List[List[int]]:
        self.result = []
        self.path = []
        nums.sort() # 排序是必须操作
        self.back_tracking(nums, target, 0, 0)
        return self.result
    
    # 回溯算法
    def back_tracking(self, nums, target, total, start):
        # 递归结束条件【剪枝：如果当前total > target，没必要枚举了，直接return】
        if total > target:
            return
        # 逻辑主体部分
        if total == target:
            curr_path = self.path[:]    # 深拷贝
            self.result.append(curr_path)
        # 递归
        for i in range(start, len(nums)):
            # 在搜索的时候就去重：这一类相同元素不计算顺序的问题，我们在搜索的时候就按某种顺序搜索。
            # 从每一层的第 2 个结点开始，都不能再搜索产生同一层结点已经使用过的 candidate 里的元素。
            # 而且重复的元素要跳过，防止产生重复数组
            if i > start and nums[i] == nums[i - 1]:
                continue
            self.path.append(nums[i])
            total += nums[i]
            self.back_tracking(nums, target, total, i + 1)
            self.path.pop()
            total -= nums[i]

回溯算法模板【C++】：

class Solution {
   
public:
    vector<vector<int>> result; // 存放组合集合
    vector<int> path;           // 符合条件的组合

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
   
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0, 0);
        return result;
    }

    void backTracking(vector<int>& nums, int target, int total, int start){
   
        // 递归结束条件【剪枝：如果当前total < 0，没必要枚举了，直接return】
        if(total > target){
   
            return;
        }

        // 逻辑主体部分
        if(total == target){
   
            result.push_back(path);
        }

        // 递归
        for(int i = start; i < nums.size(); i++){
   
            // 要对同一树层使用过的元素进行跳过
            if(i > start && nums[i] == nums[i - 1]){
   
                continue;
            }

            //记忆【将当前元素加入到path中】
            path.push_back(nums[i]);
            total += nums[i];

            backTracking(nums, target, total, i + 1);

            // 回溯【将当前元素从path删除】
            path.pop_back();
            total -= nums[i];
        }
    }
};

class Solution {
   
public:
    vector<vector<int>> result; // 存放组合集合
    vector<int> path;           // 符合条件的组合

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
   
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0, 0);
        return result;
    }

    void backTracking(vector<int>& nums, int target, int total, int start){
   
        // 递归结束条件【剪枝：如果当前total < 0，没必要枚举了，直接return】
        if(total > target){
   
            return;
        }

        std::cout << "total = " << total << "; ";
        std::cout << "path = [";
        for(auto num: path) {
   
            std::cout << num;
        }
        std::cout << "]" << std::endl;

        // 逻辑主体部分
        if(total == target){
   
            result.push_back(path);
        }

        // 递归
        for(int i = start; i < nums.size(); i++){
   
            // 要对同一树层使用过的元素进行跳过
            if(i > start && nums[i] == nums[i - 1]){
   
                continue;
            }

            //记忆【将当前元素加入到path中】
            path.push_back(nums[i]);
            total += nums[i];

            backTracking(nums, target, total, i + 1);

            // 回溯【将当前元素从path删除】
            path.pop_back();
            total -= nums[i];
        }
最低0.47元/天 解锁文章
u013250861
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索+回溯问题（DFS\BFS详解）
Jormungand_V的博客
04-27 338
文章目录题目思路DFS思路代码复杂度分析BFS思路代码复杂度分析 题目 地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？ 示例 1： 输入：m
Leetcode回溯算法经典题目总结
qq_41605114的博客
05-29 1410
回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就 “回溯” 返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为 “回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。 回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 链接：h
dfs算法
2301_79824503的博客
05-07 1807
深度优先搜索是一种用于遍历或搜索树或图的算法。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。注意：这个示例仅用于说明DFS的基本思路，并不包含图的完整初始化和边的添加代码。：如果当前节点的所有邻居节点都已被访问过，那么从访问列表（或栈）中弹出当前节点，并将前一个节点设置为当前节点（回溯到上一个节点）。：重复步骤3和4，直到访问列表（或栈）为空，即所有可达节点都已被访问。
力扣93 - 复原IP地址【回溯算法】
做技术人 · 产优质博客 · 找好工作
08-06 822
对应力扣上93题 - 复原IP地址，手画结构图，详细讲解，带你领略回溯算法的精妙
数据结构与算法分析（十七）--- 怎么用回溯剪枝高效穷举所有可行解？
流云
01-10 1397
当我们遇到一个比较复杂的问题时，通常会想到将一个复杂的问题分解为多个简单的等价子问题去解决。关键是如何分解复杂问题呢？我们可以从两个大的维度去分解：一个是从空间维度上将原大规模问题分解为多个等价的小规模子问题，再把容易求得的小规模子问题的解合并即可得到原大规模问题的解，这就是分治算法；另一种是从时间维度上将原多阶段决策问题分解为多个等价的单阶段决策子问题，再按照DFS 深度优先遍历顺序尝试所以的决策组合，所有满足约束条件的解的组合共同构成原多阶段决策问题的解，这就是回溯剪枝算法，本文以排列组合为例介绍其原理
回溯法dfs详解——针对LeetCode131题
麋鹿麋鹿迷了路
03-29 244
所有的回溯问题都是由三个步骤组成：choose、explore、unchoose 因此对每个问题需要知道： 1.choosewhat？对于这个问题，我们选择每个字符串 2.howtoexplore？对于这个问题，我们对剩余的字符串做同样的事情。 3.unchoose 做相反的操作选择 让我们以此问题为例： 1.Definehelper()，通常我们...
LeetCode专题：回溯与图论（完结，已更30题）
清风微浪又何妨的博客
03-12 776
已完结的LeetCode的回溯与图论专题刷题总结，题目分类参考了宫水三叶https://github.com/SharingSource/LogicStack-LeetCode/wiki。
回溯详解及其应用：Leetcode 39 combination sum
I AM BACK
01-31 4392
原理 初入门 基本定义和概念 举栗子 编程思路 实践 生成符合规范的括号 combination sum n queen原理初入门有时会遇到这样一类题目，它的问题可以分解，但是又不能得出明确的动态规划或是递归解法，此时可以考虑用回溯法解决此类问题。回溯法的优点 在于其程序结构明确，可读性强，易于理解，而且通过对问题的分析可以大大提高运行效率。但是，对于可以得出明显的递推公式迭代求解的问题，还是不要用
LeetCode专题：树与回溯（完结，已更50题）
清风微浪又何妨的博客
02-01 676
关于LeetCode的树专题刷题总结，由于篇幅原因仅更新至50题。题目分类参考了宫水三叶https://github.com/SharingSource/LogicStack-LeetCode/wiki。
LeetCode-算法
strdhgthbbh的博客
03-25 788
文章目录4.4位运算常见的位运算布赖恩·克尼根算法/popcount/汉明权重lowbit算法位运算进行整数加法格雷码4.5排序选择排序(简单选择、堆)插入排序(直接插入、折半、希尔)交换排序(冒泡排序、快速排序)归并排序(二路归并)几种排序算法的对比(待完成)4.6 查找二分查找基本思路框架二分查找之旋转排序数组二分查找练习题目4.x 贪心算法贪心算法求解区间调度问题贪心法经典题目4.x 动态规划概述状态机动态规划求解背包问题动态规划求解最长公共子序列问题(LCS)动态规划求解最长递增子序列问题(LIS)
leetcode-js:LeetCode精选习题，直通BAT大厂
05-04
在编程领域，LeetCode是一个备受推崇的在线平台，它提供了大量的编程题目，帮助开发者提升算法技能，特别是对于准备面试和求职的程序员，LeetCode是提升算法能力、熟悉面试题目的不二之选。本文将专注于LeetCode中的...
leetcode-java:leetcode在线判断的Java解决方案
06-30
在编程学习与面试准备过程中，LeetCode是一个备受推崇的平台，它提供了大量的编程题目，旨在提升开发者的问题解决能力和算法理解。本篇文章将聚焦于如何使用Java来解决LeetCode上的问题，并分享一套完整的Java解决...
leetcode：我的Leetcode Python解决方案
02-05
在编程领域，LeetCode是一个广受欢迎的在线平台，它提供了大量的编程题目，旨在帮助开发者提升算法和数据结构能力。在这个主题中，我们聚焦于使用Python语言解决LeetCode中的问题。Python以其简洁易读的语法和强大的...
leetcode解决方案：leetcode解决方案
02-15
LeetCode是一个广受欢迎的在线编程挑战平台，它为程序员提供了海量的算法题目，旨在提升编程技能、算法理解以及问题解决能力。本资料集专注于Java语言在LeetCode上的应用，通过一系列精心挑选的解决方案，帮助你深入...
LeetCode:此回购包含leacecode解决方案，用于解决Peaceman94所遇到的问题
03-28
在编程领域，LeetCode是一个广受欢迎的在线平台，它提供了各种算法问题以提升程序员的技能。本资源包含了一组针对LeetCode问题的C++解决方案，旨在帮助用户，尤其是Peaceman94，解决他们在平台上遇到的挑战。 ...
基于Springboot和Vue的在线视频教育平台源码 在线视频教育平台代码（高分毕设项目）
08-03
在线视频教育平台源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
MATLAB实现的生成对抗网络AAE-内含数据集和结果文件.zip
08-03
MATLAB实现的生成对抗网络AAE-内含数据集和结果文件.zip
java毕业作品-VB.NET构建跨平台聊天通信软件(源代码+论文+开题报告+答辩PPT)
最新发布
08-03
java毕业作品_VB.NET构建跨平台聊天通信软件(源代码+论文+开题报告+答辩PPT)
LeetCode算法资料：迭代与递归解题技巧解析
"LeetCode算法资料是一个综合性的在线学习平台，汇集了众多算法题目和解题资源，旨在帮助用户提升编程和算法能力。该平台覆盖了数据结构（如链表、数组等）、动态规划、字符串、图论等多个核心领域，提供详细的题目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值