【基础算法】回溯算法相关题目

系列综述：
目的：本系列是个人整理为了秋招算法的，整理期间苛求每个知识点，平衡理解简易度与深入程度。
来源：材料主要源于代码随想录进行的，每个算法代码参考leetcode高赞回答和其他平台热门博客，其中也可能含有一些的个人思考。
结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢！！！
【C++】秋招&实习面经汇总篇

---

---

点此到文末惊喜↩︎

---

一、回溯算法理论基础

定义

1. 回溯算法 = 穷举 + 剪枝
2. 回溯算法解决的问题一般为npc问题，难以使用常规算法进行解决
   • 组合问题：N个数里面按一定规则找出k个数的集合
     • 切割问题：一个字符串按一定规则有几种切割方式
     • 子集问题：一个N个数的集合里有多少符合条件的子集
   • 排列问题：N个数按一定规则选出M个，有几种排列方式
   • 棋盘问题：N皇后，解数独等等
3. 组合是不强调元素顺序的，排列是强调元素顺序。
4. 所有的回溯法解决的问题都可以抽象为树形结构
5. 回溯基本结构
   • 根节点是总数据集合，树枝节点是可选数据集合
   • 叶子节点为根节点到叶子节点的路径的选择集合
     

   // 合法性判断
   bool isValid(const type &data){
   	// type中数据项的合法性判断
   }
   // 回溯函数
   vector<vector<type> res;
   vector<type> path;
   void backtracking(vecotr<type> candidates, int startIndex) {
   	auto is_ok = [](const type &data){
   		
   	};
   	// 递归出口：路径值判断
       if (符合条件isValid) {
           res.push_back(path);
           return;
       }
   	// 延申和回撤路径时，可能涉及多个状态标记变量的改动
       for (int i = startIndex; i < candidates.size(); ++i) {
       	剪枝判断;
       	// 状态延申改动
           path.push_back(candidates[i]);// 向下延申
           backtracking(剩余可选列表); // 回溯
           // 状态回撤改动
           path.pop_back();// 回撤延申
       }
   }
   // 主函数
   vector<vector<int>> combine(vector<type>& candidates) {
       res.clear(); // 可以不写
       path.clear();// 可以不写
       backtracking(candidates, 0);
       return result;
   }
   

---

二、回溯基础算法模板

模板使用的初衷：通过模板的深入理解和背诵，可以做题过程中，比较快的进行问题的划分和抽象转换，然后调用背诵（或者微修改）的回溯模板进行求解。即将模板视为一个功能函数，通过抽象的问题输入进行求解。

组合问题

- 无重复元素的组合

1. 基本概述
   • 问题：从无重复元素的组合中选出若干元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
   • 举例：从元素集合{1，2，3}中选择2个元素的组合为{(1,2)，(1,3)，(2,3)}。
     
2. 代码
   • 解决的问题：给定一个线性表，求该线性表中满足条件的组合
   • 示例：求线性表中所有个数为target的结果。
   • 剪枝：列表中剩余元素(vec.size() - i) >= 所需需要的元素个数(target - path.size())

   class Solution {
   public:
       vector<vector<int>> combine(vector<int>vec, int k) {
           result.clear(); // 可以不写
           path.clear();   // 可以不写
           BackTracking(vec, 0,  k);
           return result;
       }
   private:
       // 回溯核心算法
       vector<vector<int>> result; // 存放符合条件结果的集合
       vector<int> path; // 用来存放符合条件结果
       void Backtracking(vector<int> &vec, int start, int target) {
       	// 递归出口：满足条件则加入结果集中
           if (path.size() == target) {
               result.push_back(path);	
               return ;
           }
           // 回溯算法
           for (int i = start; i < vec.size(); ++i) {
           	// 剪枝条件
           	if (i > vec.size() - (target-path.size()))    
           		continue;
               path.push_back(vec[i]); 	// 做出选择
               Backtracking(vec, i + 1, target);// 递归
               path.pop_back(); 			// 撤销选择
           }
       }
   };
   

- 有重复元素的组合

1. 基本概述
   • 问题：从有重复元素的组合中选出若干元素组成组合，每个元素只能被选取一次，且选出的元素之间没有顺序之分。
   • 举例：从集合{1, 2, 2, 3}中选择2个元素的组合为{1, 2}、{1, 3}、{2, 2}、{2, 3}。
2. 代码
   • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复

   class Solution {
   public:
       vector<vector<int>> combine(vector<int> vec, int k) {
           result.clear(); // 可以不写
           path.clear();   // 可以不写
           sort(vec.begin(), vec.end()); // 注意需要先进行一个排序
           BackTracking(vec, 0,  k);
           return result;
       }
   };
   private:
       // 回溯核心算法
       vector<vector<int>> result; // 存放符合条件结果的集合
       vector<int> path; // 用来存放符合条件结果
       void BackTracking(vector<int> &vec, int start, int target) {
       	// 递归出口：满足条件则加入结果集中
           if (path.size() == target) {
               result.push_back(path);	
               return ;
           }
           // 回溯算法
           for (int i = start; i < vec.size(); i++) {
           	// 剪枝：重复选择只选一次，需要配合sort使用
           	if (i > start && vec[i] == vec[i - 1]) 
               	continue;
     			// 回溯步骤
               path.push_back(vec[i]); 	// 做出选择
               BackTracking(vec, i + 1, target);// 递归
               path.pop_back(); 			// 撤销选择
           }
       }
   

排列问题

- 无重复元素的全排列

1. 基本概述
   • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有可能的组合，每个元素只出现一次。
   • 举例：从集合{1, 2, 3}，则可以产生以下6种无重复元素的排列：{1, 2, 3}、{1, 3, 2}、{2, 1, 3}、{2, 3, 1}、{3, 1, 2}、{3, 2, 1}。
     
2. 代码
   • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复

   class Solution {
   public:
       vector<vector<int>> permute(vector<int>& nums) {
           result.clear();
           path.clear();
           vector<bool> used(nums.size(), false);
           backtracking(nums, used);
           return result;
       }
   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 (used[i] == true) continue; // path里已经收录的元素，直接跳过
               // 增加选择
               used[i] = true;
               path.push_back(nums[i]);
               // 回溯
               backtracking(nums, used);
               // 撤销选择
               path.pop_back();
               used[i] = false;
           }
       }
   };
   

- 有重复元素的全排列

1. 基本概述
   • 问题：无重复元素的排列是指在给定一组不同的元素中，按照一定的顺序排列出所有的不重复组合
   • 举例：从集合[1,1,2]，则可以产生无重复的全排列： [1,1,2], [1,2,1], [2,1,1]
2. 代码
   • 解决问题：给定一个线性表，求该线性表中满足条件的组合，因为有重复元素，所以选择重复元素时只能使用一次，否则会出现集合中的重复
   • 去重操作需要对线性数组中的元素进行排序

   class Solution {
   public:
       vector<vector<int>> permuteUnique(vector<int>& nums) {
           // 重复计数
           unordered_map<int, int> umap;
           for (auto i : nums) ++umap[i];
           backtrace(umap, 0, nums.size());
           return res;
       }
   private:
       vector<vector<int> > res;
       vector<int> path;
       void backtrace(unordered_map<int, int> &umap, int k, int total) {
           if (k == total) {
               res.push_back(path);
               return;
           }
           for (auto& p : umap) {	// 每轮递归结束会进入循环
               if (p.second == 0) continue;
               --p.second;
               path.push_back(p.first);
               backtrace(umap, k + 1, n);
               ++p.second;
               path.pop_back();
           }
       }
   };
   
   

---

三、回溯算法基本题目

77. 组合

1. 77. 组合
   • 题目：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
   • 组合中的元素不能重复

   // 函数式编程？
   vector<vector<int>> result; // 存放符合条件结果的集合
   vector<int> path; // 用来存放符合条件结果
   void backtracking(int n, int k, int startIndex) {
       // 递归结束条件：组合树的叶子节点的条件
       if (path.size() == k) {
           result.push_back(path);
           return ;
       }
       // 回溯的递归：
       for (int i = startIndex; i <= n; i++) {
           path.push_back(i); // 处理节点 
           backtracking(n, k, i + 1); // 递归
           path.pop_back(); // 回溯，撤销处理的节点
       }
   }
   vector<vector<int>> combine(int n, int k) {
       result.clear(); // 可以不写
       path.clear();   // 可以不写
       backtracking(n, k, 1);
       return result;
   }
   

39. 组合总和

1. 39. 组合总和
   • 问题：给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回

   vector<vector<int>> res;
   vector<int> path;
   void backtracking(vector<int> &candidates, int startIndex, int target, int sum){
   	// 结束条件
       if (sum > target) return ;
       if (sum == target) {
           res.push_back(path);
           return ;
       }
   	// 路径回溯
       for (int i = startIndex; i < candidates.size(); ++i) {
           sum += candidates[i];// 路径值累加
           path.push_back(candidates[i]);// 路径延申
           backtracking(candidates, i, target, sum);
           sum -= candidates[i];
           path.pop_back();
       }
       
   }
   
   vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
       res.clear();
       path.clear();
       backtracking(candidates, 0, target, 0);
       return res;
   }
   

40.组合总和II

1. 40.组合总和II
   • 集合（数组candidates）有重复元素，但还不能有重复的组合。
   • 同一个层不可重复选取两个相同的元素

   // 结果容器
   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++) {
           // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
           // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
           // 要对同一树层使用过的元素进行跳过
           if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
               continue;
           }
           // 延申路径：改变状态机中路径相关变量，sum、path、used
           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();
       }
   }
   
   vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
       vector<bool> used(candidates.size(), false);
       path.clear();
       result.clear();
       // 首先把给candidates排序，让其相同的元素都挨在一起。
       sort(candidates.begin(), candidates.end());
       backtracking(candidates, target, 0, 0, used);
       return result;
   }
   

131. 分割回文串

1. 131. 分割回文串
   • 获取[startIndex,i]在s中的子串s.substr(startIndex, i - startIndex + 1)

   // 判断是否为回文字符串
   bool isPalindrome(const string& s, int start, int end) {
       for (int i = start, j = end; i < j; i++, j--) {
           if (s[i] != s[j]) {
               return false;
           }
       }
       return true;
   }
   // 基本的回溯
   vector<vector<string>> result;
   vector<string> path; // 放已经回文的子串
   void backtracking (const string& s, int startIndex) {
       // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
       if (startIndex >= s.size()) {
           result.push_back(path);
           return;
       }
       for (int i = startIndex; i < s.size(); i++) {
       	// 剪枝与枝的延长
           if (isPalindrome(s, startIndex, i)) {   // 是回文子串
               // 获取[startIndex,i]在s中的子串
               string str = s.substr(startIndex, i - startIndex + 1);
               path.push_back(str);
           } else {  // 不是回文，跳过
               continue;
           }
           backtracking(s, i + 1); // 寻找i+1为起始位置的子串
           path.pop_back(); // 回溯过程，弹出本次已经填在的子串
       }
   }
   
   
   vector<vector<string>> partition(string s) {
       result.clear();
       path.clear();
       backtracking(s, 0);
       return result;
   }
   

93. 复原 IP 地址

1. 93. 复原 IP 地址
   • str.insert(1,s);在原串下标为1的字符e前插入字符串s
   • str.erase(0);删除下标为0的字符

   vector<string> result;// 记录结果
   // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
   void backtracking(string& s, int startIndex, int pointNum) {
       if (pointNum == 3) { // 逗点数量为3时，分隔结束
           // 判断第四段子字符串是否合法，如果合法就放进result中
           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)) { // 判断 [startIndex,i] 这个区间的子串是否合法
               s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
               pointNum++;
               backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
               pointNum--;                         // 回溯
               s.erase(s.begin() + i + 1);         // 回溯删掉逗点
           } else break; // 不合法，直接结束本层循环
       }
   }
   // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
   bool isValid(const string& s, int start, int end) {
       if (start > end) {
           return false;
       }
       if (s[start] == '0' && start != end) { // 0开头的数字不合法
               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) { // 如果大于255了不合法
               return false;
           }
       }
       return true;
   }
   
   vector<string> restoreIpAddresses(string s) {
       result.clear();
       if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
       backtracking(s, 0, 0);
       return result;
   }
   

---

1005. K 次取反后最大化的数组和

1. 1005. K 次取反后最大化的数组和
   • sort的使用：第三个参数为自定义的排序队则，在头文件#include
   • accumulate的使用：第三个参数为累加的初值，在头文件include

   static bool cmp(int a, int b) {
       return abs(a) > abs(b);// 绝对值的从大到小进行排序
   }
   int largestSumAfterKNegations(vector<int>& A, int K) {
   	// 将容器内的元素按照绝对值从大到小进行排序
       sort(A.begin(), A.end(), cmp); 
       // 在K>0的情况下，将负值按照绝对值从大到小依次取反
       for (int i = 0; i < A.size(); i++) { 
           if (A[i] < 0 && K > 0) {
               A[i] *= -1;
               K--;
           }
       }
       // 如果K为奇数，将最小的正数取反
       if (K % 2 == 1) 
       	A[A.size() - 1] *= -1; 
      	// 求和
       return accumulate(A.begin(),A.end(),0);
       // 第三个参数为累加的初值，在头文件include
   }
   

---

少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。 不如点赞·收藏·关注一波

---

点此跳转到首行↩︎

参考博客

1. 代码随想录
2. letcode回溯题解——空条承子
3. 大力王_leetcode全排列回溯