回溯notebook

最新推荐文章于 2024-07-25 15:54:06 发布
最新推荐文章于 2024-07-25 15:54:06 发布
阅读量363 收藏
点赞数
分类专栏： leetcode 文章标签： 算法 回溯 LeetCode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stdleohao/article/details/121375227
版权

文章目录

回溯模板

for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
回溯和递归是相辅相成的。回溯法的效率，回溯法其实就是暴力查找，并不是什么高效的算法。
回溯法解决的问题都可以抽象为树形结构（N叉树）
回溯法可以解决几类问题，可以看出每一类问题都不简单。
组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

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

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

17. 电话号码的字母组合

题目链接

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

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

示例: 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”].

说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

class Solution {
private:
    vector<string> result;
    string path;
    // wrong: int key[10]
    string key[10] = {
        "",
        "",
        "abc",
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz"
    };
    // 键入的键盘数字 字符串， 字符串的下标
    void backtracking(string inputDigits, int index) {
        // 结束条件
        if (path.size() == inputDigits.size()) {
            result.push_back(path);
            return;
        }
        // 获取下标为index 的 输入字符串所代表的数字
        // wrong:int digit = inputDigits[index] 
        int digit = inputDigits[index] - '0';
        // 获取数字所代表的的字符串
        string letter = key[digit];
        // 处理逻辑
        for (int i = 0; i < letter.size(); i++) {
            // 循环获取index所代表的的字母
            path.push_back(letter[i]);
            // 获取下一个index所代表的的字母
            backtracking(inputDigits, index + 1);
            path.pop_back();
        }

    }
public:
    vector<string> letterCombinations(string digits) {

        result.clear();
        // wrong: 未处理空的情况
        if (digits.size() == 0) 
            return result;
        backtracking(digits, 0);
        return result;
    }
};

在这里插入图片描述

131. 分割回文串

题目链接

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = “aab” 输出：[[“a”,“a”,“b”],[“aa”,“b”]] 示例 2：

输入：s = “a” 输出：[[“a”]]

提示：

1 <= s.length <= 16 s 仅由小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
private:
    vector<vector<string>> result;
    // wrong: vector<int> path;
    vector<string> path;

    // 判断回文与否 [begin, end]
    bool isHuiWen(string s, int begin, int end) {
        for (int i = begin, j = end; i < j; i++, j--) {
            if (s[i] != s[j])
                return false;
        }
        return true;
    }

    
    void backtracking(string s, int startIndex) {
        // !!终止条件，起始位置
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }

        // 处理逻辑，
        for (int i = startIndex; i < s.size(); i++) {
            // 判断是否是回文
            if (isHuiWen(s, startIndex, i)) {
                // !!截取从startIndex开始，长度为startIndex - i + 1的子串加入到path
                // wrong: string sub = s.substr(startIndex, startIndex - i + 1);
                string sub = s.substr(startIndex, i - startIndex + 1);
                path.push_back(sub);
            } else {
                continue;
            }
            // ！！起始位置从i + 1开始
            backtracking(s, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

在这里插入图片描述

93. 复原 IP 地址

题目链接

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是
“0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’
来形成。你不能重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/restore-ip-addresses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
private:
    vector<string> result;
    string path;
    bool isValid(string s, int begin, int end) {
        if (begin > end) {
            return false;
        }
        //wrong:if (s[0] == "0" && begin != end) {
        if (s[begin] == '0' && begin != end) {
            return false;
        }
        int num = 0;
        for (int i = begin; i <= end; i++) {
            if (s[i] - '0' < 0 || s[i] - '0' > 9) 
                return false;

            // int ip = s[i] - '0';
            // wrong: num += (num * 10 + ip);
            num = num * 10 + (s[i] - '0');
            if (num > 255)
                return false;
        }
        return true;
    }
    void backtracking(string& s, int startIndex, int piontNum) {
        // 终止条件，点数为3
        if (piontNum == 3) {
            if (isValid(s, startIndex, s.size() - 1))
                result.push_back(s);
            return;    
        }

        // 什么时候插入点？
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) {
                //path.push_back(s[i]);
                //path.push_back('.');
                s.insert(s.begin() + i + 1, '.');
            // }else {
            //     break;
            // }
                piontNum++;
                backtracking(s, i + 2, piontNum);
                // path.pop_back()
                // path.pop_back()
                s.erase(s.begin() + i + 1);
                piontNum--;
            }
            else {
                break;
            }
        }
    }     
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        path.clear();
        if (s.size() > 12) return result;
        backtracking(s, 0, 0);
        return result;
    }
};
// 需要一个判断是否合法的方法
// 需要回溯分割的方法

在这里插入图片描述

78. 子集

题目链接

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

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

示例 1：

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

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

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/subsets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

    void backtracking(vector<int>& nums, int startIndex) {
        // 遍历所有！！需要放在终止条件前
        result.push_back(path);
        if (startIndex > nums.size()) {
            return ;
        }

        // 组合，从startIndex开始
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

在这里插入图片描述

90. 子集 II

题目链接

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

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

示例 1：

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

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

提示：

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

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/subsets-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // !!! 层去重
            if (i > startIndex && nums[i] == nums[i-1]) {
                continue;
            }

            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        // 去重要排序
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return result;
    }
};

在这里插入图片描述

491. 递增子序列

题目链接

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]] 示例 2：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/increasing-subsequences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        // 因为要遍历所有树枝，不能在此终止
        //wrong：if (path.size() > 0) {
        if (path.size() > 1) {
            result.push_back(path);
        }
        unordered_set<int> uset;
        for (int i = startIndex; i < nums.size(); i++) {
            // 去重,且去除前大于后的
            // wrong: 因为不能排序，所以不能通过这样来去重，if ((i > startIndex && nums[i] == nums[i-1]) || (path.size() > 0 && path.back() > nums[i])) {
            if ((!path.empty() && path.back() > nums[i]) || 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;
    }
};

在这里插入图片描述

小结

  • 和子集问题很像，但是不同的是不能排序
  • vector 末尾 back(),头front()
  • unordered_set ，insert(),

46. 全排列

题目链接

给定一个不含重复数字的数组 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 中的所有整数 互不相同

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/permutations
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
在这里插入图片描述

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++) {
            // path 中已经有了
            if (used[i] == true) {
                continue;
            }
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        
        }
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

在这里插入图片描述

小结

  • 排列问题，遍历时从0开始而不是startIndex
  • 需要used数组记录path里都放了哪些元素了

47. 全排列 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

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/permutations-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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++) {
            // wrong: used[i] == false
            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();
        // wrong:忘了要排序了
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

在这里插入图片描述

小结

  • used[i - 1] == true，说明同一树支nums[i - 1]使用过
  • used[i - 1] == false，说明同一树层nums[i - 1]使用过

332. 重新安排行程

题目链接
在这里插入图片描述

class Solution {
private:
    vector<string> result;
    unordered_map<string, map<string, int>> targets;
    bool backtracking(int ticketNum) {
        if (result.size() == ticketNum + 1) {
            return true;
        }
        //wrong: for (const pair<string, int>& target : targets[result[result.size() - 1]]) {
        //wrong: for (pair<string, int> target : targets[result[result.size() - 1]]) {
        for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
            if (target.second > 0) {
                result.push_back(target.first);
                target.second--;
                if (backtracking(ticketNum)) return true;
                result.pop_back();
                target.second++;
            }
        }
        return false;
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        result.clear();
        targets.clear();
        for (const vector<string>& ticket : tickets) {
            targets[ticket[0]][ticket[1]]++;
        }
        // wrong: 忘了起始
        result.push_back("JFK"); // 起始机场
        backtracking(tickets.size());
        return result;
    }
};

在这里插入图片描述

小结

  • for (pair<const string, int>& target : targets[result[result.size() - 1]]) pair里要有const，因为map中的key是不可修改的

51. N 皇后

题目链接
在这里插入图片描述

class Solution {
private: 
    vector<vector<string>> result;
    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, n, chessboard)) {
                chessboard[row][col] = 'Q';
                backtracking(n, row + 1, chessboard);
                chessboard[row][col] = '.';
            }
        }
    }
    
    bool isValid(int row, int col, int n, vector<string>& chessboard) {
        // 列
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }

        // 主对角线
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; j--, i-- ) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }

        // 辅对角线
        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();
        // 初始化！
        vector<string> chessboard(n, string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

在这里插入图片描述

Stdleohao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Notepad++ 插件之 TextFX (安装及作用)
kaka100
12-01 1576
《安装：打开 notepad++ 插件 -> Plugin Manager -> Show Plugin Manager -> available ->选中 TextFX ->install》 （注：如果没有插件的话--首先updates插件） Notepad++插件TextFX Characters是一款默认安装的插件，由于功能强大，被编程爱好者认为是最好的Notepad++插件，第二...
Jupyter notebook操作
热门推荐
原来是肖哈哈的博客
06-16 1万+
查看当前jupyter环境下的版本： 设置jupyter打开位置： 查看torch是否可用： ！与%的区别 !开一个新的progress,执行完之后立即终止；provided by the Jupyter %的操作会持续；provided by the IPython kernel在 Jupyter 启动 Tensorboard：...
jupyter notebook
2302_80644606的博客
07-09 647
jupyter
从入门到精通：全面掌握Jupyter Notebook
最新发布
iShare_Carlos的博客
07-25 828
Jupyter Notebook是一种交互式的计算环境，允许用户创建和共享包含实时代码、方程式、可视化和解释文本的文档。它广泛应用于数据清洗和转换、数值模拟、统计建模、机器学习和深度学习等领域。本教程旨在帮助零基础用户从零开始学习如何使用Jupyter Notebook，并逐步掌握其高级功能。Jupyter Notebook起源于IPython项目，后来发展成支持多种编程语言的独立项目。Jupyter名字来源于Julia、Python和R三种编程语言，但现在支持几十种语言。
9大Jupyter Notebook扩展工具
pypyai_的博客
01-27 1323
Jupyter Notebook是数据科学家最常使用的工具。它可以在一个文档中混合代码和文本，并且检查输出也很方便，其他编程IDE都没有提供这么方便的功能。但是，Jupyter笔记本的基本版本并不完美。你需要安装一些扩展插件，才能使Jupyter Notebook的性能更佳。 本文我们将向您展示如何通过安装一些插件增强Jupyter Notebool的功能。 什么是Jupyter Notebook插件？ Jupyter Notebook插件是在后台运行并扩展Notebook功能的JavaScript代码.
一文了解 DataLeap 中的 Notebook
字节跳动技术团队官方博客
10-27 4623
动手点关注干货不迷路一、概述Notebook 是一种支持 REPL 模式的开发环境。所谓「REPL」，即「读取-求值-输出」循环：输入一段代码，立刻得到相应的结果，并继续等待下一次输入。它通常使得探索性的开发和调试更加便捷。在 Notebook 环境，你可以交互式地在其中编写你的代码、运行代码、查看输出、可视化数据并查看结果，使用起来非常灵活。在数据开发领域，Notebook 广泛应用于数据清理和...
Jupyter Notebook基础：用IPython实现动态编程
2401_85639015的博客
07-12 1677
Jupyter Notebook前身是IPython Notebook，是一个开源的Web应用程序，允许用户创建和共享文档，这些文档包含实时代码、方程式、可视化和叙述文本。Jupyter支持40多种编程语言（包括Python、R和Julia），提供了一个灵活而强大的工具来进行数据分析和科学计算。IPython是一个增强的Python解释器，提供了更强大的交互性和易用性。它支持自动补全、语法高亮、内联可视化等功能，是Jupyter Notebook的核心组件之一。
JupyterNotebook‘s Magic
tongtongjing1765的博客
06-13 766
事情的起因是这样子的：上个星期在看代码的时候，一个意外让我了解到了jupyternotebook上的黑魔法。是这样子的：这么骚？可以这么玩？代码上面直接加了个%%time...
超强数据科学专用notebook神仙平台：多语言+多人协作，颜值能打又好用！
BigDataDigest的博客
05-07 1051
大数据文摘出品作者：魏子敏、土豆、周素云、蒋宝尚因为内涵太丰富，数据科学从业者常常感到被工具限制。除了大火的Python，一名合格的数据科学家会随时在R、Bash、Julia等语言中自由切换。并且，当前的数据科学工作无法一个人单打独斗完成，常常需要团队协作。而当前市面上的notebook，例如Colab仅支持Python 2或Python 3。有些编译器虽然也支持R、Julia等编程语言，但是需要...
Notebook
03-06
6. **版本控制**：Notebook可以保存为`.ipynb`文件，这些文件可以被Git等版本控制系统跟踪，便于团队协作和历史版本回溯。 7. **分享与发布**：Notebook可以导出为HTML、PDF等多种格式，方便分享和出版。此外，...
notebook
03-25
4. **版本控制**：可以将notebook保存为版本化的Git仓库，便于跟踪和回溯工作过程。 5. **分享与协作**：通过nbviewer服务，用户可以在线预览notebook，或将其导出为HTML、PDF等形式分享给他人。此外，JupyterLab...
jupyter:JUPYTER-NOTEBOOK
04-13
6. **版本控制**：通过Git等版本控制系统，用户可以追踪和管理Notebook的历史版本，方便协作和回溯。 7. **分享与发布**：Jupyter Notebook支持导出为HTML、PDF、Python脚本等多种格式，便于分享和发表研究成果。...
notebook:Jupyter笔记本
03-28
4. **版本控制**：通过GitHub等工具，可以对notebook进行版本控制，跟踪和回溯代码更改。 5. **分享与协作**：可以导出为多种格式（如HTML、PDF），并能通过nbviewer在线共享，便于团队协作。 **分散标识符（DID）...
Sudoku_Solver:简单但实现良好的回溯算法，使用Python（通过Notebook格式获取更多信息和测试）来解决通过求解器函数传递的任何数独。
03-30
Sudoku_Solver 简单但实现良好的回溯算法，使用Python（通过Notebook格式获取更多信息和测试）来解决通过求解器函数传递的任何数独。 数独的标准游戏从初始配置开始，根据游戏的规则，它会产生一系列可能的和不可能...
1. 两数之和(unordered_map)
stdleohao的博客
05-11 429
两数之和 思路 用map->first保存数组的值，map->second保存数组的索引 用map.find(map[target - nums[i]]) != map.end() 去判断是否存在两数和 class Solution { public: vector<int> twoSum(vector<int>& nums, int target) { unordered_map<int,int> a; // 怎么初始化？
贪心解题notebook
stdleohao的博客
12-09 325
贪心的本质是选择每一阶段的局部最优，从而达到全局最优。 文章目录[455. 分发饼干](https://leetcode-cn.com/problems/assign-cookies/)小结 455. 分发饼干 class Solution { public: int findContentChildren(vector<int>& g, vector<int>& s) { // 从小到大的排序，一一对应 // wrong.
判定字符是否唯一
stdleohao的博客
10-02 253
题目链接 class Solution { public: bool isUnique(string astr) { /** 法1 使用数组解决 由于没指定字符是字母，假设是ASCII编码共128个 int achar[128]; for (int i = 0; i < 128; i++) { achar[i] = 0; }
动态规划notebook
stdleohao的博客
03-29 233
动态规划
回溯法详解与应用
"回溯法课件教学 - 详细介绍回溯法及其应用" 回溯法是一种在解决问题时采用的算法策略，特别适用于解决那些需要找出所有解或者最优解的组合优化问题。它通过深度优先搜索的方式来探索问题的解空间，有效地避免了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值