凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

一刷代码随想录——回溯算法

作者：凡人多烦事01 | 2024-05-24 20:00:31

踩

代码随想录

1.理论基础

【1】本质

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。

回溯是递归的副产品，只要有递归就会有回溯。

因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！

因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

【2】递归三部曲

以下以前序遍历为例：

确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：

voidtraversal(TreeNode* cur, vector<int>& vec)

确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：

if(cur ==NULL)return;

确定单层递归的逻辑：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：


vec.push_back(cur->val);// 中
traversal(cur->left, vec);// 左
traversal(cur->right, vec);// 右

【3】回溯过程

回溯函数遍历过程伪代码如下：


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

for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。

backtracking这里自己调用自己，实现递归。

大家可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。

元素可重复选取： backtracking(candidates, target, sum, i);否则i+1
避免重复：数组排序，used标记
if (i > 0 &&nums[i] == nums[i - 1]&&used[i - 1] == false) continue;
剪枝：i < n - (k - path.size()) + 1

1.组合77

题目描述：

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按任何顺序返回答案。


class Solution {
public:
    vector<vector<int>>res;
    vector<int>path;
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            res.push_back(path);
            return;
        }
        for (int i = startIndex; i < n - (k - path.size()) + 1; i++) {
            path.push_back(i);
            backtracking(n, k, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1);
        return res;
    }
};

2. 组合总和39

题目描述：

给你一个无重复元素的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有不同组合，并以列表形式返回。你可以按任意顺序返回这些组合。

candidates 中的同一个数字可以无限制重复被选取。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。


class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>&candidates,int target,int sum,int startIndex){
        if (sum == target) {
            result.push_back(path);
            return;
        }    
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, sum, i);//无限制重复被选取，因此是i
            path.pop_back();
            sum -= candidates[i];
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

3.子集 78

题目描述：

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

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


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;
        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) {
        backtracking(nums, 0);
        return result;
    }
};

4.子集II 90

题目描述：

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

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


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) {
        sort(nums.begin(), nums.end()); 
        backtracking(nums, 0);
        return result;
    }
};

和组合II 40相同


class Solution {
public:
    vector<vector<int>>res;
    vector<int>path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>used) {
        res.push_back(path);
        if (startIndex >= nums.size()) return;
        for (int i = startIndex; i < nums.size(); i++) {
            if (i > 0 &&nums[i] == nums[i - 1]&&used[i - 1] == false) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool>used(nums.size());
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return res;
    }
};

5.组合总和II 40

题目描述：

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

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

注意：解集不能包含重复的组合。


class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) continue;    
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); 
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);       
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

6.组合总和III 216

题目描述：

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9

每个数字最多使用一次

返回所有可能的有效组合的列表。该列表不能包含相同的组合两次，组合可以以任何顺序返回。


class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(int n, int k, int startIndex) {
        if (sum > n) return;
        if (path.size() == k) {
            if(sum==n) result.push_back(path);
            return;
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            path.push_back(i);
            sum += i;
            backtracking(n, k, i + 1);
            path.pop_back();
            sum -= i;
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 1);
        return result;
    }
};

7.电话号码的字母组合17

题目描述：

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

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

回溯


class Solution {
private:
    const string letterMap[10] = { "","",
       "abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"}; 
public:
    vector<string> result;
    string s;
    void backtracking(const string& digits, int index) {
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';       
        string letters = letterMap[digit];     
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            
            backtracking(digits, index + 1);    
            s.pop_back();                       
        }
    }
    vector<string> letterCombinations(string digits) {
        if (digits.size() == 0)  return result;
        backtracking(digits, 0);
        return result;
    }
};

递归


class Solution {
private:
    const string letterMap[10] = { "","",
       "abc","def","ghi","jkl","mno","pqrs","tuv","wxyz" };
public:
    vector<string> result;
    void getCombinations(const string& digits, int index, const string& s) { 
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';
        string letters = letterMap[digit];
        for (int i = 0; i < letters.size(); i++) 
            getCombinations(digits, index + 1, s + letters[i]);          
    }
    vector<string> letterCombinations(string digits) {
        if (digits.size() == 0)  return result;
        getCombinations(digits, 0, "");
        return result;
    }
};

8.复原IP地址 93

题目描述：

有效 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 中的任何数字。你可以按任何顺序返回答案。


class Solution {
private:
    vector<string> result;
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 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)) { 
                s.insert(s.begin() + i + 1, '.'); 
                pointNum++;
                backtracking(s, i + 2, pointNum);   
// 插入逗点之后下一个子串的起始位置为i+2
                pointNum--;                         
                s.erase(s.begin() + i + 1);         
            }
            else break; 
        }
    }
//左闭右闭
    bool isValid(const string& s, int start, int end) {
        if (start > end) return false;  
        if (s[start] == '0' && start != end) return false;
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') return false;      
            num = num * 10 + (s[i] - '0');
            if (num > 255) return false;     
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        if (s.size() > 12 || s.size() < 4) return result;
        backtracking(s, 0, 0);
        return result;
    }
};

9.分割回文串131

题目描述：

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

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


class Solution {
private:
    vector<vector<string>> result;
    vector<string> path;
    vector<vector<bool>> isPalindrome; // 放事先计算好的是否回文子串的结果
     // isPalindrome[i][j] 代表 s[i:j](双边包括)是否是回文字串 
    void backtracking(const string& s, int startIndex) {
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome[startIndex][i]) {                   
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            }
            else continue;                                   
            backtracking(s, i + 1); 
            path.pop_back(); 
        }
    }
    void computePalindrome(const string& s) {      
        isPalindrome.resize(s.size(), vector<bool>(s.size(), false)); 
// 根据字符串s, 刷新布尔矩阵的大小
        for (int i = s.size() - 1; i >= 0; i--) {
            // 需要倒序计算, 保证在i行时, i+1行已经计算好了
            for (int j = i; j < s.size(); j++) {
                if (j == i)  isPalindrome[i][j] = true; 
                else if (j - i == 1)  isPalindrome[i][j] = (s[i] == s[j]); 
                else  isPalindrome[i][j] = (s[i] == s[j] && isPalindrome[i + 1][j - 1]); 
            }
        }
    }
public:
    vector<vector<string>> partition(string s) {
        computePalindrome(s);
        backtracking(s, 0);
        return result;
    }
};

同子集78+IP93


class Solution {
public:
    vector<string>path;
    vector<vector<string>>res;
    void backtracking(string&s, int startindex) {
//所有元素全被使用，完成一套分组方案
        if (startindex >= s.size()) {
            res.push_back(path);
            return;
        }
        for (int i = startindex; i < s.size(); i++) {
            if (isValid(s, startindex, i)) {
                path.push_back(s.substr(startindex,i-startindex+1));
                backtracking(s, i + 1);
                path.pop_back();
            }
        }
    }
    bool isValid(const string& s, int start, int end) {
        if (start > end) return false;
        if (start == end) return true;        
        for (int i = start, j = end; i < j; i++,j--) 
            if (s[i] != s[j]) return false;
        return true;
    }
    vector<vector<string>> partition(string s) {
        if (s.size() == 0) return {};
        backtracking(s, 0);
        return res;
    }
};

10.递增子序列491

题目描述：

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

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


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) {
        backtracking(nums, 0);
        return result;
    }
};

11.全排列46

题目描述：

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


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; 
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

12.全排列 II 47

题目描述：

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


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++) {
            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) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

13.重新安排行程 332

题目描述：

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票必须都用一次且只能用一次。


class Solution {
private:
// unordered_map<出发城市, map<到达城市, 航班次数>> targets
unordered_map<string, map<string, int>> targets;
bool backtracking(int ticketNum, int index, vector<string>& result) {
    if (index == ticketNum + 1) return true;
    for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
        if (target.second > 0 ) { // 使用int字段来记录到达城市是否使用过了
            result.push_back(target.first);
            target.second--;
            if (backtracking(ticketNum, index + 1, result)) return true;
            result.pop_back();
            target.second++;
        }
    }
    return false;
}
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<string> result;
        for (const vector<string>& vec : tickets) 
            targets[vec[0]][vec[1]]++; // 记录映射关系        
        result.push_back("JFK");
        backtracking(tickets.size(), 1, result);
        return result;
    }
};

14.N皇后 51

题目描述：

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。


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, 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) {
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

15.解数独 37

题目描述：

编写一个程序，通过填充空格来解决数独问题。

数独的解法需遵循如下规则：

数字 1-9 在每一行只能出现一次。

数字 1-9 在每一列只能出现一次。

数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。


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] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {     
                if (isValid(i, j, k, board)) {
                    board[i][j] = k;               
// 如果找到合适一组立刻返回
                    if (backtracking(board)) return true; 
                    board[i][j] = '.';              
                }
            }
// 9个数都试完了，都不行，那么就返回false
            return false;                           
        }
    }
    return true;
}
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;
// 判断9方格里是否重复           
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++)  
        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);
    }
};

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/618908