代码随想录Day 25|回溯篇完结，题目：491.递增子序列、46、全排列、47.全排列Ⅱ

于 2024-08-25 23:58:07 发布
阅读量338 收藏 7
点赞数 9
文章标签： c++ leetcode 算法 数据结构 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LuckyYH__/article/details/141537384
版权

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

第七章 回溯算法part05

回溯算法的收尾

一、题目

题目一：491.递增子序列

93. 复原 IP 地址

解题思路：

这个递增子序列比较像是取有序的子集。而且本题也要求不能有相同的递增子序列。

取子集 + 去重

本题求自增子序列，在处理自增子序列问题时，应避免对原数组进行排序，并且可以考虑使用 set 来有效地去除重复的子序列。这种方法既保持了数组的原始顺序，又能够确保结果的正确性。

使用used数组进行去重是更通用的一种方式。

本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。

为了有鲜明的对比，我用[4, 7, 6, 7]这个数组来举例，抽象为树形结构如图：

491. 递增子序列1

回溯三部曲

本题求子序列，很明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。

  • 递归函数参数
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex)
  • 递归终止条件

本题收集结果有所不同，题目要求递增子序列大小至少为2，所以代码如下：

if (path.size() > 1) {
    result.push_back(path);
    // 注意这里不要加return，因为要取树上的所有节点
}
  • 单层搜索的逻辑
491. 递增子序列1

在图中可以看出，同一父节点下的同层上使用过的元素就不能再使用了

那么单层搜索代码如下：

unordered_set<int> uset; // 使用set来对本层元素进行去重
for (int i = startIndex; i < nums.size(); i++) {
    if ((!path.empty() && nums[i] < path.back())
            || uset.find(nums[i]) != uset.end()) {
            continue;
    }
    uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
    path.push_back(nums[i]);
    backtracking(nums, i + 1);
    path.pop_back();
}

这也是需要注意的点，unordered_set<int> uset; 是记录本层元素是否重复使用，新的一层uset都会重新定义（清空），所以要知道uset只负责本层！

最后整体C++代码如下：

// 版本一
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
            // 注意这里不要加return，要取树上的节点
        }
        unordered_set<int> uset; // 使用set对本层元素进行去重
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || uset.find(nums[i]) != uset.end()) {
                    continue;
            }
            uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};
  • 时间复杂度: O(n * 2^n)
  • 空间复杂度: O(n）

优化

在这个特定问题中，用一个简单的数组来记录哪些元素已经被用过，比用复杂的unordered_set要来得快，因为数组访问速度快，不需要额外的哈希计算和扩容操作。

  1. 使用unordered_set的问题：在编程中，unordered_set是一个用来存放不重复元素的数据结构，它通过哈希函数来快速查找元素。但是，当你频繁地往里面添加元素时，如果元素很多，unordered_set就需要花时间来重新调整自己的内部结构，这个过程叫做“扩容”，是挺耗时间的。
  2. 数组作为哈希表的优势：题目告诉我们数值的范围是[-100, 100]，也就是说元素的取值范围很小，只有201个可能的数值（包括0）。这样，我们就可以用一个大小为201的数组来代替unordered_set。数组的每个位置对应一个数值，如果数组的某个位置已经被用过了，我们就不往那个位置再放东西，这样就避免了重复。
  3. 效率问题：使用数组来做这件事情，效率会更高。因为数组的访问速度很快，几乎是立即可以知道一个元素是否已经被使用过，不需要像unordered_set那样每次都要计算哈希值，然后再查找。
  4. 为什么不用unordered_set：虽然unordered_set在元素数量很多且分布广泛时很有用，但在这个问题中，由于元素数量有限且范围已知，使用数组作为哈希表会更简单、更快速。

完整代码:

// 版本二
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
        }
        int used[201] = {0}; // 这里使用数组来进行去重操作，题目说数值范围[-100, 100]
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back())
                    || used[nums[i] + 100] == 1) {
                    continue;
            }
            used[nums[i] + 100] = 1; // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

数组，set，map都可以做哈希表，而且数组干的活，map和set都能干，但如果数值范围小的话能用数组尽量用数组。

题目二：46.全排列

46. 全排列

解题思路：

抽象成树形结构如下：

全排列

回溯三部曲

  • 确定递归函数参数

首先排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方。

可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。

但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:

全排列 
vector<vector<int>> result;
vector<int> path;
void backtracking (vector<int>& nums, vector<bool>& used)
  • 确定终止条件

当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

// 此时说明找到了一组
if (path.size() == nums.size()) {
    result.push_back(path);
    return;
}
  • 单层搜索过程

used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。

代码如下：

for (int i = 0; i < nums.size(); i++) {
    if (used[i] == true) continue; // path里已经收录的元素，直接跳过
    used[i] = true;
    path.push_back(nums[i]);
    backtracking(nums, used);
    path.pop_back();
    used[i] = false;
}

回溯算法的模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

回溯三部曲分析完了，整体C++代码如下：

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue; // path里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};
  • 时间复杂度: O(n!)
  • 空间复杂度: O(n)

小结：

排列问题的不同：

  • 每层都是从0开始搜索而不是startIndex
  • 需要used数组记录path里都放了哪些元素了

题目三：47.全排列 II

47. 全排列 II

解题思路

强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。

以示例中的 [1,1,2]为例 （为了方便举例，已经排序）抽象为一棵树，去重过程如图：

47.全排列II1

图中我们对同一树层，前一位（也就是nums[i-1]）如果使用过，那么就进行去重。

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

完整的代码如下：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end()); // 排序
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

// 时间复杂度: 最差情况所有元素都是唯一的。复杂度和全排列1都是 O(n! * n) 对于 n 个元素一共有 n! 中排列方案。而对于每一个答案，我们需要 O(n) 去复制最终放到 result 数组
// 空间复杂度: O(n) 回溯树的深度取决于我们有多少个元素
  • 时间复杂度: O(n! * n)
  • 空间复杂度: O(n)

拓展

去重最为关键的代码为：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

如果改成 used[i - 1] == true， 也是正确的!，去重代码如下：

if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) {
    continue;
}

这是为什么呢，如果要对树层中前一位去重，就用used[i - 1] == false，如果要对树枝前一位去重用used[i - 1] == true。

对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！

题目四：51. N皇后

51. N 皇后

解题思路

都知道n皇后问题是回溯算法解决的经典问题，但是用回溯解决多了组合、切割、子集、排列问题之后，遇到这种二维矩阵还会有点不知所措。

首先来看一下皇后们的约束条件：

  1. 不能同行
  2. 不能同列
  3. 不能同斜线

确定完约束条件，来看看究竟要怎么去搜索皇后们的位置，其实搜索皇后的位置，可以抽象为一棵树。

51.N皇后

从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。

那么我们用皇后们的约束条件，来回溯搜索这棵树，只要搜索到了树的叶子节点，说明就找到了皇后们的合理位置了。

  • 验证棋盘是否合法
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}

完整的C++回溯代码：

class Solution {
private:
vector<vector<string>> result;
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
    if (row == n) {
        result.push_back(chessboard);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
            chessboard[row][col] = 'Q'; // 放置皇后
            backtracking(n, row + 1, chessboard);
            chessboard[row][col] = '.'; // 回溯，撤销皇后
        }
    }
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};
  • 时间复杂度: O(n!)
  • 空间复杂度: O(n)

棋盘的宽度就是for循环的长度，递归的深度就是棋盘的高度，这样就可以套进回溯法的模板里了。

题目五：37.解数独

37. 解数独

解题思路：

棋盘搜索问题可以使用回溯法暴力搜索，只不过这次我们要做的是二维递归。

怎么做二维递归呢？

树形结构太大了，抽取一部分，如图所示：

37.解数独

回溯三部曲

  • 递归函数以及参数

递归函数的返回值需要是bool类型，为什么呢？

因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。

bool backtracking(vector<vector<char>>& board)
  • 递归终止条件

本题递归不用终止条件，解数独是要遍历整个树形结构寻找可能的叶子节点就立刻返回。

不用终止条件会不会死循环？

递归的下一层的棋盘一定比上一层的棋盘多一个数，等数填满了棋盘自然就终止（填满当然好了，说明找到结果了），所以不需要终止条件！

  • 递归单层搜索逻辑

在树形图中可以看出我们需要的是一个二维的递归 （一行一列）

一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！

代码如下：（详细看注释）

bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';              // 回溯，撤销k
                }
            }
            return false;                           // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

注意这里return false的地方，这里放return false 是有讲究的。

因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！

那么会直接返回， 这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！

判断棋盘是否合法

判断棋盘是否合法有如下三个维度：

  • 同行是否重复
  • 同列是否重复
  • 9宫格里是否重复
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    for (int i = 0; i < 9; i++) { // 判断行里是否重复
        if (board[row][i] == val) {
            return false;
        }
    }
    for (int j = 0; j < 9; j++) { // 判断列里是否重复
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}

最后的完整代码；

class Solution {
private:
bool backtracking(vector<vector<char>>& board) {
    for (int i = 0; i < board.size(); i++) {        // 遍历行
        for (int j = 0; j < board[0].size(); j++) { // 遍历列
            if (board[i][j] == '.') {
                for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                        board[i][j] = '.';              // 回溯，撤销k
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false
            }
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    for (int i = 0; i < 9; i++) { // 判断行里是否重复
        if (board[row][i] == val) {
            return false;
        }
    }
    for (int j = 0; j < 9; j++) { // 判断列里是否重复
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

总结

  • 使用unordered_set,作为去重的逻辑。只限于自增子序列，不能手动排序。
  • 全排列无startIndex的使用，顺序是必要的。
  • 使用used数组，在排列问题上，树层和树枝去重都可以。
LluckyYH
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录算法day22 | 回溯算法part04 | 491.递增子序列，46.全排列，47.全排列 II
最新发布
m0_62415132的博客
08-24 629
本题题解清一色都说是深度优先搜索，但我更倾向于说它用回溯法，而且本题我也是完全使用回溯法的逻辑来分析的。相信大家在本题中处处都能看到是 求子集 的身影，但处处又都是陷阱。对于养成思维定式或者套模板套嗨了的同学，这道题起到了很好的警醒作用。更重要的是拓展了大家的思路！每层都是从 0 开始搜索而不是 startIndex需要 used 数组记录 path 里都放了哪些元素了排列问题是回溯算法解决的经典题目，大家可以好好体会体会。continue;continue;
代码随想录Day31 | 回溯 491.递增子序列 46.全排列 47.全排列 II
weixin_44645059的博客
05-17 464
三数之和。
代码随想录算法训练营Day 29| 回溯算法part05 | 491.递增子序列、46.全排列、47.全排列 II
m0_51759998的博客
04-28 322
在90.子集II (opens new window)中我们是通过排序，再加一个标记数组来达到去重的目的。而本题求自增子序列，是不能对原数组进行排序的，排完序的数组都是自增子序列了。每层都是从0开始搜索而不是startIndex。需要used数组记录path里都放了哪些元素了。所以不能使用之前的去重逻辑！
【力扣一刷】代码随想录day29（回溯算法part5：491.递增子序列、46.全排列、47.全排列 II）
weixin_46135891的博客
04-04 498
1、处理当前节点如果到当前节点的路径长度为1或者为0，直接遍历访问子节点即可如果到当前节点的路径长度大于/等于2，则判断是否递增如果递增，则记录路径如果不是递增，则不记录路径，不访问子节点，直接返回在for循环遍历前，定义Set对象，用于记录当前层遍历过的子节点（注意：不能定义为全局变量，因为递归的时候会加入其它层的节点）。在for循环遍历时，如果当前层前面出现过相同值的子节点，就不遍历该子节点，跳过。需要【判断子序列是否递增】和【考虑如何去重】
代码随想录27期|Python|Day29|回溯算法|491.递增子序列|46.全排列|47.全排列 II
m0_57527624的博客
12-27 892
比如：[4,5,6,7]和[4,6,5,7]相比，后者就不能选择[5,6,7]这个排列，因为违反了设置的顺序。本题需要明确“层间”还是“树枝”上去重，对于组合问题，前面的数字不能再取，所以是层间去重，回溯的时候不用修改当前层的used数组，但是在树枝上去重的时候，需要在。（1）去重：当且仅当前一个数字已经被遍历，而且现在的数字和之前的是一样的时候，需要continue。1、参数和返回值：和上一题的排列一致，也是全局的used数组加入到模版写法里，返回值为空。，used就是一个用来标记的“伴随”数组。
代码随想录算法训练营day25：回溯04：491.递增子序列；46.全排列
weixin_65180740的博客
07-27 930
我们需要给「不选择」做一个限定条件，只有当当前的元素不等于上一个选择的元素的时候，才考虑不选择当前元素，直接递归后面的元素。其中第二种情况和第三种情况其实是等价的，我们这样限制之后，舍弃了第二种，保留了第三种，于是达到了去重的目的。使序列合法的办法非常简单，即给「选择」做一个限定条件，只有当前的元素大于等于上一个选择的元素的时候才能选择这个元素，这样枚举出来的所有元素都是合法的。大家应该很清晰的看到，树层上对前一位去重非常彻底，效率很高，树枝上对前一位去重虽然最后可以得到答案，但是做了很多无用搜索。
代码随想录训练营day29|回溯：491.递增子序列、46.全排列、47.全排列2
qq_40837128的博客
05-17 88
思路：对于终止条件：可以使用temp.size()>=2来判断。但是这里只需要ans.add 即可，不可以return。return会吧大于2的都丢弃。至于去重 的时候使用了辅助的map或者数组来做。是因为这里的nums不是递增的，也不可以变成递增的。只能用map来记录是否使用过。其中比较不好理解的是used[i-1] == false.在上一题的基础上需要对横向层级上的重复元素去重，这里使用了。在for里面的横向遍历的时候，还要判断去重和递增。对于排列问题的剪枝去重，去除重复的排列。
代码随想录训练营Day 25|Python|Leetcode|491.递增子序列* 46.全排列* 47.全排列 II
qq_60959261的博客
04-17 621
当使用start_index时是为了让接下来可选择的数从当前数的下一个开始。停止条件：if len(path) == len(nums): append+return。停止条件：if len(path) == len(nums): result append。本题要注意除重，判断上一个数字是否使用过，没有使用过并且前后数字相同就进行树层除重。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。，找出并返回所有该数组中不同的递增子序列，递增子序列中。给定一个不含重复数字的数组。
Day29代码随想录回溯part05：491.递增子序列、46.全排列、47.全排列 II
Estrellazhu的博客
04-17 343
题目难度性不大，就是要记录不能重复使用（需要used数组记录path里都放了哪些元素了），同时是每一次都从第一位开始遍历的（每层都是从0开始搜索而不是startIndex）而本题求自增子序列，**是不能对原数组进行排序的，**排完序的数组都是自增子序列了。：给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。题意：给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。**题意：**给定一个 没有重复 数字的序列，返回其所有可能的全排列。
8.《代码随想录》回溯算法（V3.0）.pdf
07-21
《代码随想录》回溯算法（V3.0）解析 #### 回溯算法理论基础 **回溯算法概述** 回溯算法是一种通过尝试解决某个问题所有可能解的方法，来找到所有可行解或最优解的算法策略。这种算法常用于解决约束满足问题、...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
「代码随想录」回溯算法精讲（v1.1）.pdf
08-11
由于提供的文件内容主要是对「代码随想录」回溯算法精讲pdf文件的OCR扫描文字，其中存在识别错误和遗漏，导致内容不够连贯和准确。但是，我们依然可以从描述中提炼出关键知识点。 标题“「代码随想录」回溯算法精讲...
「代码随想录」回溯算法精讲（v2.0）.pdf
04-22
### 回溯算法精讲知识点概述 #### 一、回溯算法定义与理解 - **定义**：回溯法是一种通过尝试解决问题所有可能的解决方案来寻找一个或所有解的方法。通常用于解决约束满足问题（CSPs），如图着色问题、数独问题等。...
1_代码随想录突击版（1.0）.pdf
05-10
### 《代码随想录突击版》概览 《代码随想录突击版》是由程序员Carl整理的一份针对面试准备的高效复习资料。此版本专为时间紧迫但仍需准备算法面试的开发者设计，旨在帮助他们快速掌握高频考点，提高面试通过率。 ...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值