回溯算法

这部分主要是学习了 labuladong 公众号中对于回溯算法的讲解

刷了些 leetcode 题，在此做一些记录，不然没几天就忘光光了

总结

概述

回溯是 DFS 中的一种技巧。回溯法采用 试错 的思想，尝试分步的去解决一个问题，在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。

通俗上讲，回溯是一种走不通就回头的算法。

摘录自：https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/backtrack

在进行回溯时，需要考虑3个问题

  1. 路径：也就是已经做出的选择。
  2. 选择列表：也就是你当前可以做的选择。
  3. 结束条件：也就是到达决策树底层，无法再做选择的条件。

算法框架如下：

  1. List<List<...>> res = new LinkedList<>();
  2. // List<...> res = new LinkedList<>();
  4. void backtrack(路径, 选择列表){
  5. 	if(满足结束条件){
  6.         res.add(路径);
  7.         return;
  8.     }
  10.     for(选择 :选择列表){
  11.         // 做选择
  12.         backtrack(路径, 选择列表)
  13.         // 撤销选择
  14.     }
  15. }

特殊说明：

在撤销选择时，若是如下定义：List<List<Integer>> res = new LinkedList<>();，List类若要移除最后一个元素：

  • 方式1：track.remove(track.size() - 1);，推荐，因为选择列表出现重复的元素时，方式2就会有问题！
  • 方式2：track.remove(Integer.valueOf(nums[i]));，直接remove(i)是不对的，因为 i 为 index 而不是添加的元素

经典问题

全排列问题

问题描述：有n个不重复的数，能排列出多少种n位数的可能，其中用过的数字是不能再用的

  1. List<List<Integer>> res = new LinkedList<>();
  3. /* 主函数，输入一组不重复的数字，返回它们的全排列 */
  4. List<List<Integer>> permute(int[] nums) {
  5.     // 记录「路径」
  6.     LinkedList<Integer> track = new LinkedList<>();
  7.     // 输入：选择列表, 路径
  8.     backtrack(nums, track);
  9.     return res;
  10. }
  12. // 路径：记录在 track 中
  13. // 选择列表：nums 中不存在于 track 的那些元素
  14. // 结束条件：nums 中的元素全都在 track 中出现
  15. void backtrack(int[] nums, LinkedList<Integer> track) {
  16.     // 触发结束条件
  17.     if (track.size() == nums.length) {
  18.         res.add(new LinkedList(track));
  19.         return;
  20.     }
  22.     for (int i = 0; i < nums.length; i++) {
  23.         // 排除不合法的选择
  24.         if (track.contains(nums[i]))
  25.             continue;
  26.         // 前序：做选择
  27.         track.add(nums[i]);
  28.         // 进入下一层决策树
  29.         backtrack(nums, track);
  30.         // 后序：取消选择
  31.         track.removeLast();
  32.         // 注意：若要用reomve的话，track.remove(i)是错误的，应该是track.remove(Integer.valueOf(i));
  33.     }
  34. }
  1. public static void main(String[] args) {
  2.  int[] nums = {1,2,3};
  3.  Demo demo = new Demo();
  4.  demo.permute(nums);
  6.  System.out.println(demo.res.toString());
  7.  // [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
  8. }

八皇后问题

题目描述：51. N 皇后

输入：4

输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]

  1. List<List<String>> res = new LinkedList<>();
  3. /* 输入棋盘边长 n，返回所有合法的放置 */
  4. public List<List<String>> solveNQueens(int n) {
  5.     // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
  6.     List<char[]> board = new LinkedList<>();
  8.     // 初始化路径
  9.     for(int i=0; i<n; i++){
  10.         char[] arr = new char[n];
  11.         Arrays.fill(arr, '.');
  12.         board.add(arr);
  13.     }
  15.     backtrack(board, 0);
  17.     return res;
  18. }
  20. // 路径：board 中小于 row 的那些行都已经成功放置了皇后
  21. // 选择列表：第 row 行的所有列都是放置皇后的选择
  22. // 结束条件：row 超过 board 的最后一行
  23. private void backtrack(List<char[]> board, int row){
  24.     // 触发结束条件
  25.     if(board.size() == row){
  26.         res.add(transform(board));
  27.         return;
  28.     }
  30.     // 第 row 行的所有列都是放置皇后的选择
  31.     int n = board.get(row).length;
  32.     for(int col=0; col<n; col++){
  33.         // 排除不合法选择
  34.         if(!isValid(board, row, col)){
  35.             continue;
  36.         }
  38.         // 做选择
  39.         board.get(row)[col] = 'Q';
  40.         // 进入下一行决策,即row行已经放好皇后了，要在row+1行放
  41.         backtrack(board, row+1);
  42.         // 撤销选择
  43.         board.get(row)[col] = '.';
  45.     }
  46. }
  48. private Boolean isValid(List<char[]> board, int row, int col) {
  49.     int n = board.size();
  51.     // 遍历所有行，固定列：检查列是否有皇后互相冲突
  52.     for(int i = 0; i < n; i++) {
  53.         if(board.get(i)[col] == 'Q'){
  54.             return false;
  55.         }
  56.     }
  58.     // 检查右上方是否有皇后互相冲突，因为是一行一行放皇后因此只要检查上方
  59.     for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--,j++){
  60.         if(board.get(i)[j] == 'Q'){
  61.             return false;
  62.         }
  63.     }
  65.     // 检查左上方是否有皇后互相冲突，因为是一行一行放皇后因此只要检查上方
  66.     for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--){
  67.         if(board.get(i)[j] == 'Q'){
  68.             return false;
  69.         }
  70.     }
  71.     return true;
  72. }
  74. private List<String> transform(List<char[]> board){
  75.     List<String> newBoard = new LinkedList<>();
  76.     for(char[] row : board){
  77.         newBoard.add(new String(row));
  78.     }
  79.     return newBoard;
  80. }

子集问题

题目描述：78. 子集

  1. // 数学归纳思想
  2. public List<List<Integer>> subsets(int[] nums) {
  3.     List<List<Integer>> res = new LinkedList<>();
  4.     // 先加入[]的情况
  5.     res.add(new LinkedList<Integer>());
  7.     for(int i=0; i<nums.length; i++){
  8. 		// 每多一个数字，都在原先的基础上添加这个数字再加到res中
  9.         int size = res.size();
  10.         for(int j=0; j<size; j++){
  11.             List<Integer> sub = new LinkedList<>(res.get(j));
  12.             sub.add(nums[i]);
  13.             res.add(sub);
  14.         }
  15.     }
  16.     return res;
  17. }
  19. // 回溯解法
  20. List<List<Integer>> res = new LinkedList<>();
  22. public List<List<Integer>> subsets(int[] nums) {
  24.     List<Integer> track = new LinkedList<>();;
  25.     backtrack(nums, 0, track);
  27.     return res;
  28. }
  30. private void backtrack(int[] nums, int start, List<Integer> track){
  31.     res.add(new LinkedList(track));
  32.     // 这里的i=start做了可选集和的限定
  33.     for(int i=start; i<nums.length; i++){
  34.         // 做选择
  35.         track.add(nums[i]);
  36.         // 回溯
  37.         backtrack(nums, i+1, track);
  38.         // 撤销选择
  39.         track.remove(Integer.valueOf(nums[i]));
  40.     }
  41. }

组合问题

题目描述：77. 组合

  1. List<List<Integer>> res = new LinkedList<>();
  2. public List<List<Integer>> combine(int n, int k) {
  4.     List<Integer> track = new LinkedList<>();
  5. 	// k限定了尺寸，start限定了选择列表
  6.     backtrack(n, k, 1, track);
  8.     return res;
  9. }
  11. private void backtrack(int n, int k, int start, List<Integer> track){
  13.     // 剪枝：可有可无，加上后效率提升很多
  14.     if(track.size() + n-start + 1 < k){
  15.         return;
  16.     }
  18.     if(k == track.size()){
  19.         res.add(new LinkedList(track));
  20.         return;
  21.     }
  23.     for(int i=start; i<=n; i++){
  24.         track.add(i);
  25.         backtrack(n, k, i+1, track);
  26.         track.remove(Integer.valueOf(i));
  27.     }
  28. }

排列问题

问题描述：46. 全排列，和之前的全排列一样，再贴一个代码吧

  1. List<List<Integer>> res = new LinkedList<>();
  3. public List<List<Integer>> permute(int[] nums) {
  5.     List<Integer> track = new LinkedList<>();
  6.     backtrack(nums, track);
  7.     return res;
  8. }
  10. private void backtrack(int[] nums, List<Integer> track){
  11.     if(nums.length == track.size()){
  12.         res.add(new LinkedList(track));
  13.         return;
  14.     }
  16.     for(int i=0; i<nums.length; i++){
  17.         // 和组合问题不同就是在这里多了一个判断，并且开始的索引不需要修改
  18.         if(track.contains(nums[i])){
  19.             continue;
  20.         }
  21.         track.add(nums[i]);
  22.         backtrack(nums, track);
  23.         track.remove(Integer.valueOf(nums[i]));
  24.     }
  25. }

数独问题

问题描述：37. 解数独

  1. public void solveSudoku(char[][] board) {
  3.     backtrack(board, 0, 0);
  4. }
  6. private boolean backtrack(char[][] board, int r, int c){
  8.     int m=9, n=9;
  10.     if(c == n){
  11.         // 穷举到最后一列的话就换到下一行重新开始
  12.         return backtrack(board, r+1, 0);
  13.     }
  15.     if(r == m){
  16.         // 找到一个可行解，触发 base case
  17.         return true;
  18.     }
  20.     // 对棋盘的每个位置进行穷举
  21.     for(int i=r; i< m; i++){
  22.         for(int j=c; j< n; j++){
  23.             if(board[i][j] != '.'){
  24.                 // 如果该位置是预设的数字，不用我们操心
  25.                 return backtrack(board, i, j + 1);
  26.             }
  27.             // 对每个数都进行穷举
  28.             for(char ch='1'; ch <= '9'; ch++){
  29.                 // 如果遇到不合法的数字，就跳过
  30.                 if( !isValid(board, i, j, ch)){
  31.                     continue;
  32.                 }
  34.                 // 做选择:
  35.                 board[i][j] = ch;
  36.                 // 继续穷举下一个位置
  37.                 // 如果找到一个可行解，立即结束
  38.                 if(backtrack(board, i, j+1)){
  39.                     return true;
  40.                 }
  41.                 // 撤销选择
  42.                 board[i][j] = '.';
  43.             }
  44.             // 穷举完 1~9，依然没有找到可行解，此路不通, 回溯
  45.             return false;
  46.         }
  47.     }
  48.     return false;
  49. }
  51. // 判断 board[i][j] 是否可以填入 n
  52. private boolean isValid(char[][] board, int r, int c, char n) {
  53.     for (int i = 0; i < 9; i++) {
  54.         // 判断行是否存在重复
  55.         if (board[r][i] == n) return false;
  56.         // 判断列是否存在重复
  57.         if (board[i][c] == n) return false;
  58.         // 判断 3 x 3 方框是否存在重复
  59.         if (board[(r/3)*3 + i/3][(c/3)*3 + i%3] == n)
  60.             return false;
  61.     }
  62.     return true;
  63. }

括号生成

题目描述：22. 括号生成

  1. List<String> res = new LinkedList<>();
  2. public List<String> generateParenthesis(int n) {
  4.     if(n == 0){
  5.         return res;
  6.     }
  8.     // 回溯过程中的路径
  9.     char[] track = new char[n*2];
  10.     Arrays.fill(track, '.');
  11.     backtrack(n, n, 0, track);
  13.     return res;
  15. }
  17. // 可用的左括号数量为 left 个，可用的右括号数量为 rgiht 个,已经放的个数index
  18. private void backtrack(int left, int right, int index, char[] track){
  20.     // 若左括号剩下的多，说明不合法
  21.     if(left > right){
  22.         return;
  23.     }
  24.     // 数量小于 0 肯定是不合法的
  25.     if(left < 0 || right < 0){
  26.         return;
  27.     }
  29.     // 当所有括号都恰好用完时，得到一个合法的括号组合
  30.     if(left == 0 && right == 0){
  31.         res.add(new String(track));
  32.         return;
  33.     } 
  35.     // 尝试放一个左括号
  36.     track[index] = '(';
  37.     backtrack(left-1, right, index+1, track);
  38.     track[index] = '.';
  40.     // 尝试放一个右括号
  41.     track[index] = ')';
  42.     backtrack(left, right-1, index+1, track);
  43.     track[index] = '.';
  44. }

回溯算法VS动态规划

题目描述：494. 目标和

  1. // 回溯算法：
  2. int res = 0;
  3. public int findTargetSumWays(int[] nums, int S) {
  5.     backbarck(nums, S, 0, 0);
  6.     return res;
  7. }
  9. private void backbarck(int[] nums, int target, int start, int sum){
  11.     if(start == nums.length){
  12.         if(sum == target){
  13.             res+=1;
  14.         }
  15.         return;
  16.     }
  18.     sum += nums[start];
  19.     backbarck(nums, target, start+1, sum);
  20.     sum -= nums[start];
  22.     sum -= nums[start];
  23.     backbarck(nums, target, start+1, sum);
  24.     sum += nums[start];
  25. }
  27. // 存在子问题：加备忘录的优化
  28. // + + +/- +/- +/-  和  + - +/- +/- +/- 后面的计算就是重复的
  29. Map<String, Integer> cache = new HashMap<>();
  30. public int findTargetSumWays(int[] nums, int S) {
  32.     return dp(nums, S, 0, 0);
  33. }
  35. private int dp(int[] nums, int target, int start, int sum){
  37.     if(start == nums.length){
  38.         if(sum == target){
  39.             return 1;
  40.         }
  41.         return 0;
  42.     }
  44.     // 把它俩转成字符串才能作为哈希表的键
  45.     // 即：前面的计算相同，只有后面不同，前面的就不用再算一遍了
  46.     String key = start + "," + sum;
  48.     // 避免重复计算
  49.     if (cache.containsKey(key)) {
  50.         return cache.get(key);
  51.     }
  53.     // 还是穷举
  54.     int res = dp(nums, target, start+1, sum+nums[start]) + dp(nums, target, start+1, sum-nums[start]);
  55.     cache.put(key, res);
  57.     return res;
  58. }
  60. // 动态规划：把 nums 划分成两个子集A和B，分别代表分配+的数和分配-的数
  61. // sum(A) - sum(B) = target
  62. // sum(A) = target + sum(B)
  63. // sum(A) + sum(A) = target + sum(B) + sum(A)
  64. // 2 * sum(A) = target + sum(nums)
  65. // sum(A) = (target + sum(nums)) / 2
  66. // 把原问题转化成：nums中存在几个子集A，使得A中元素的和为 (target + sum(nums)) / 2
  67. // 这不就是背包问题了嘛
  68. public int findTargetSumWays(int[] nums, int S) {
  70.     int n = nums.length;
  71.     int sum = 0;
  73.     for(int i=0; i<n; i++){
  74.         sum += nums[i];
  75.     }
  77.     // 不可能的情况
  78.     if(sum < S || (sum + S) %2 == 1){
  79.         return 0;
  80.     }
  82.     sum = (S + sum) / 2;
  84.     // 明确状态：dp[i][j]  当有i个物体时，背包容量为j时，有几种方式能装满背包
  85.     int[][] dp = new int[n+1][sum+1];
  87.     // base case
  88.     for(int i=0; i<=n; i++){
  89.         // 有东西可以装  但是背包已经满了  啥也不做是一种情况
  90.         dp[i][0] = 1;
  91.     }
  92.     for(int j=1; j<=sum; j++){
  93.         // 没东西了 但背包还没满 没有操作空间
  94.         dp[0][j] = 0;
  95.     }
  97.     // 状态转移：
  98.     for(int i=1; i<=n; i++){       // 可选物品的状态转移
  99.         for(int j=0; j<=sum; j++){ // 背包容量的状态转移
  100.             if(nums[i-1] > j){
  101.                 // 东西放不进背包,继承之前的状态
  102.                 dp[i][j] = dp[i-1][j];
  103.             }else{
  104.                 // 能放进去的情况
  105.                 dp[i][j] = dp[i-1][j-nums[i-1]] + dp[i-1][j];
  106.             }
  107.         }
  108.     }
  110.     return dp[n][sum];
  111. }

题目

索引

39. 组合总和

40. 组合总和 II

216. 组合总和 III

47. 全排列 II

90. 子集 II

131. 分割回文串

解题

39. 组合总和

  1. List<List<Integer>> res = new LinkedList<>();
  2. public List<List<Integer>> combinationSum(int[] candidates, int target) {
  4.     List<Integer> track = new LinkedList<>();
  5.     Arrays.sort(candidates);
  6.     backtrack(candidates, target, 0, 0, track);
  8.     return res;
  9. }
  11. // param1：可选的数组
  12. // param2: 目标值
  13. // param3: 当前的总和
  14. // param4: 开始的索引，为了避免重复的组合出现多次
  15. // param5：路径
  16. private void backtrack(int[] candidates, int target, int sum, int start, List<Integer> track){
  18.     if(sum >= target){
  19.         if(sum == target){
  20.             res.add(new LinkedList<>(track));
  21.         }
  22.         return;
  23.     }
  25.     // 剪枝：可有可无，有了效率高
  26.     if(sum+candidates[start] > target){
  27.         return;
  28.     }
  30.     for(int i=start; i<candidates.length; i++){
  31.         sum += candidates[i];
  32.         track.add(candidates[i]);
  33.         backtrack(candidates, target, sum, i, track);
  34.         sum -= candidates[i];
  35.         track.remove(Integer.valueOf(candidates[i]));
  36.     }
  37. }

40. 组合总和 II

  1. // 耗时 917ms
  2. List<List<Integer>> res = new LinkedList<>();
  3. // 用于去重，虽然效率很低，但能实现去重的效果
  4. Set<String> visited = new HashSet<>();
  5. public List<List<Integer>> combinationSum2(int[] candidates, int target) {
  7.     List<Integer> track = new LinkedList<>();
  9.     Arrays.sort(candidates);
  11.     backtrack(candidates, target, 0, 0, track);
  13.     return res;
  14. }
  16. private void backtrack(int[] candidates, int target, int sum, int start, List<Integer> track){
  18.     if(sum >= target){
  19.         if(sum == target && !visited.contains(track.toString())){
  20.             res.add(new LinkedList<>(track));
  21.             visited.add(track.toString());
  22.         }
  23.         return;
  24.     }
  26.     for(int i=start; i<candidates.length; i++){
  28.         sum += candidates[i];
  29.         track.add(candidates[i]);
  30.         backtrack(candidates, target, sum, i+1, track);
  31.         sum -= candidates[i];
  32.         track.remove(Integer.valueOf(candidates[i]));
  33.     }
  34. }
  36. // 优化版本，加入剪枝提高效率，耗时：4ms
  37. List<List<Integer>> res = new LinkedList<>();
  38. boolean[] visited;
  39. public List<List<Integer>> combinationSum2(int[] candidates, int target) {
  41.     List<Integer> track = new LinkedList<>();
  42.     visited = new boolean[candidates.length];
  44.     Arrays.sort(candidates);
  45.     backtrack(candidates, target, 0, 0, track);
  47.     return res;
  48. }
  50. private void backtrack(int[] candidates, int target, int sum, int start, List<Integer> track){
  52.     if(sum >= target){
  53.         if(sum == target){
  54.             res.add(new LinkedList<>(track));
  55.         }
  56.         return;
  57.     }
  59.     // 剪枝1：
  60.     if(start<candidates.length && sum + candidates[start] > target){
  61.         return;
  62.     }
  64.     for(int i=start; i<candidates.length; i++){
  66.         // 剪枝2：☆☆☆如果数组相连元素相等，没有先访问后面的元素，就不会存在重复
  67.         if (visited[i] || (i > 0 && candidates[i] == candidates[i - 1] && !visited[i - 1])) {
  68.             continue;
  69.         }
  71.         sum += candidates[i];
  72.         track.add(candidates[i]);
  73.         visited[i] = true;
  74.         backtrack(candidates, target, sum, i+1, track);
  75.         sum -= candidates[i];
  76.         track.remove(Integer.valueOf(candidates[i]));
  77.         visited[i] = false;
  78.     }
  79. }

216. 组合总和 III

  1. List<List<Integer>> res = new LinkedList<>();
  3. public List<List<Integer>> combinationSum3(int k, int n) {
  5.     List<Integer> track = new LinkedList<>();
  7.     backtrack(k, n, 1, 0, track);
  9.     return res;
  10. }
  12. private void backtrack(int k, int n, int start, int sum, List<Integer> track){
  14.     if(track.size() == k && sum == n){
  15.         res.add(new LinkedList<>(track));
  16.         return;
  17.     }
  19.     // 剪枝: 可有可无，有了提高效率
  20.     if(start>9 || sum > n || sum+start > n){
  21.         return;
  22.     }
  24.     for(int i=start; i<=9; i++){
  25.         sum += i;
  26.         track.add(i);
  27.         backtrack(k, n, i+1, sum, track);
  28.         sum -= i;
  29.         track.remove(Integer.valueOf(i));
  30.     }
  31. }

47. 全排列 II

  1. // 方法1：有误 但是我找不出来问题，[2,2,1,1] 少了一个可能的情况
  2. // 通过visited记录出现的排列情况
  3. // 通过indexs记录已经递归下去的index，下次这个index不能再用了
  4. List<List<Integer>> res = new LinkedList<>();
  5. Set<String> visited = new HashSet<>();
  6. boolean[] indexs;
  7. public List<List<Integer>> permuteUnique(int[] nums) {
  9.     Arrays.sort(nums);
  10.     indexs = new boolean[nums.length];
  12.     List<Integer> track = new LinkedList<>();
  13.     backtrack(nums, track);
  15.     return res;
  16. }
  18. private void backtrack(int[] nums, List<Integer> track){
  20.     if(track.size() == nums.length && !visited.contains(track.toString())){
  21.         res.add(new LinkedList<>(track));
  22.         visited.add(track.toString());
  23.         return;
  24.     }
  26.     for(int i=0; i<nums.length; i++){
  27.         if(indexs[i] == true) continue;
  29.         indexs[i] = true;
  30.         track.add(nums[i]);
  32.         backtrack(nums, track);
  34.         track.remove(track.size() - 1);
  35.         indexs[i] = false;
  36.     }
  37. }
  39. // 方法2：通过新建立一个数组，来写出所有的排列组合的可能，后续通过visited来删除重复的情况
  40. List<List<Integer>> res = new LinkedList<>();
  41. Set<String> visited = new HashSet<>();  // 记录已经出现过的情况
  42. public List<List<Integer>> permuteUnique(int[] nums) {
  44.     List<Integer> track = new LinkedList<>();
  46.     // 建立新数组，其值对应原数组的索引
  47.     int[] new_nums = new int[nums.length];
  48.     for(int i=0; i<nums.length; i++){
  49.         new_nums[i] = i;
  50.     }
  52.     backtrack(nums, new_nums, track);
  54.     return res;
  55. }
  57. private void backtrack(int[] nums, int[] new_nums, List<Integer> track){
  59.     if(track.size() == nums.length){
  61.         List<Integer> tmp = new LinkedList();
  62.         // 根据索引回到原数组
  63.         for(int index: track){
  64.             tmp.add(nums[index]);
  65.         }
  66.         // 判断是否已经出现过这种情况
  67.         if(!visited.contains(tmp.toString())){
  68.             res.add(tmp);
  69.             visited.add(tmp.toString());
  70.         }
  71.         return;
  72.     }
  74.     for(int i=0; i<nums.length; i++){
  76.         if(track.contains(new_nums[i])){
  77.             continue;
  78.         }
  80.         track.add(new_nums[i]);
  82.         backtrack(nums, new_nums, track);
  84.         track.remove(Integer.valueOf(new_nums[i]));
  85.     }
  86. }
  88. // 方法3：优化了去重的方式，效率由5% ---> 99%
  89. boolean[] visited;
  90. public List<List<Integer>> permuteUnique(int[] nums) {
  91.     List<List<Integer>> res = new ArrayList<List<Integer>>();
  92.     List<Integer> track = new ArrayList<Integer>();
  93.     visited = new boolean[nums.length];
  95.     Arrays.sort(nums);
  96.     backtrack(nums, res, 0, track);
  98.     return res;
  99. }
  101. private void backtrack(int[] nums, List<List<Integer>> ans, int idx, List<Integer> track) {
  102.     if (idx == nums.length) {
  103.         ans.add(new ArrayList<Integer>(track));
  104.         return;
  105.     }
  106.     for (int i = 0; i < nums.length; ++i) {
  107.         // ☆☆☆如果数组相连元素相等，没有先访问后面的元素，就不会存在重复
  108.         if (visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1])) {
  109.             continue;
  110.         }
  111.         track.add(nums[i]);
  112.         visited[i] = true;
  113.         backtrack(nums, ans, idx + 1, track);
  114.         visited[i] = false;
  115.         track.remove(idx);
  116.     }
  117. }

90. 子集 II

  1. // 回溯解法：正常的模版解题
  2. List<List<Integer>> res = new LinkedList<>();
  3. Set<String> visited = new HashSet<>();
  5. public List<List<Integer>> subsetsWithDup(int[] nums) {
  7.     List<Integer> track = new LinkedList<>();
  8.     // 因为集和具有无序性，因此需要排序来排除顺序造成的重复子集
  9.     // 即：两个子集如果只是元素的排列顺序不一样，则认为重复
  10.     Arrays.sort(nums);
  11.     backtrack(nums, 0, track);
  13.     return res;
  14. }
  16. private void backtrack(int[] nums, int start, List<Integer> track){
  18.     if(!visited.contains(track.toString())){
  19.         visited.add(track.toString());
  20.         res.add(new LinkedList(track));
  21.     }else{
  22.         return;
  23.     }
  25.     for(int i=start; i<nums.length; i++){
  26.         // 做选择
  27.         track.add(nums[i]);
  28.         // 回溯
  29.         backtrack(nums, i+1, track);
  30.         // 撤销选择
  31.         track.remove(Integer.valueOf(nums[i]));
  32.     }
  33. }
  35. // 回溯解法：+ 剪枝
  36. List<List<Integer>> res = new LinkedList<>();
  37. boolean[] visited;
  39. public List<List<Integer>> subsetsWithDup(int[] nums) {
  41.     visited = new boolean[nums.length];
  42.     List<Integer> track = new LinkedList<>();
  43.     // 因为集和具有无序性，因此需要排序来排除顺序造成的重复子集
  44.     // 即：两个子集如果只是元素的排列顺序不一样，则认为重复
  45.     Arrays.sort(nums);
  46.     backtrack(nums, 0, track);
  48.     return res;
  49. }
  51. private void backtrack(int[] nums, int start, List<Integer> track){
  53.     res.add(new LinkedList(track));
  55.     for(int i=start; i<nums.length; i++){
  57.         // ☆☆☆如果数组相连元素相等，没有先访问后面的元素，就不会存在重复
  58.         if (visited[i] || (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1])) {
  59.             continue;
  60.         }
  62.         // 做选择
  63.         track.add(nums[i]);
  64.         visited[i] = true;
  65.         // 回溯
  66.         backtrack(nums, i+1, track);
  67.         // 撤销选择
  68.         track.remove(track.size() - 1);
  69.         visited[i] = false;
  70.     }
  71. }

131. 分割回文串

  1. List<List<String>> res = new LinkedList<>();
  3. public List<List<String>> partition(String s) {
  4.     List<String> track = new LinkedList<>();
  6.     backtrack(s, 0, track);
  8.     return res;
  9. }
  11. private void backtrack(String s, int start, List<String> track){
  12.     if(start == s.length()){
  13.         res.add(new LinkedList<>(track));
  14.         return;
  15.     }
  17.     for(int i=start; i<s.length(); i++){
  18.         String sub = s.substring(start, i+1);
  19.         if(!isPalindrome(sub)){
  20.             continue;
  21.         }
  22.         track.add(sub);
  23.         backtrack(s, i+1, track);
  24.         track.remove(track.size()-1);
  25.     }
  26. }
  28. private boolean isPalindrome(String s){
  29.     if(s == null || s.length() <= 1){
  30.         return true;
  31.     }
  33.     int left = 0;
  34.     int right = s.length() - 1;
  36.     while(left < right){
  37.         if(s.charAt(left) == s.charAt(right)){
  38.             left++;
  39.             right--;
  40.         }else{
  41.             return false;
  42.         }
  43.     }
  45.     return true;
  46. }

LeetCode：回溯算法的更多相关文章

  1. leetcode回溯算法--基础难度

    都是直接dfs,算是巩固一下 电话号码的字母组合 给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合. 给出数字到字母的映射如下(与电话按键相同).注意 1 不对应任何字母. 思路 一直 ...

  2. LeetCode刷题191203 --回溯算法

    虽然不是每天都刷,但还是不想改标题,(手动狗头 题目及解法来自于力扣(LeetCode),传送门. 算法(78): 给定一组不含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集). 说明: ...

  3. Leetcode——回溯法常考算法整理

    Leetcode--回溯法常考算法整理 Preface Leetcode--回溯法常考算法整理 Definition Why & When to Use Backtrakcing How to ...

  4. LeetCode通关：连刷十四题，回溯算法完全攻略

    刷题路线:https://github.com/youngyangyang04/leetcode-master 大家好,我是被算法题虐到泪流满面的老三,只能靠发发文章给自己打气! 这一节,我们来看看回 ...

  5. 回溯算法 LEETCODE别人的小结 一八皇后问题

    回溯算法实际上是一个类似枚举的搜索尝试过程,主要是在搜索尝试中寻找问题的解,当发现已不满足求解条件时,就回溯返回,尝试别的路径. 回溯法是一种选优搜索法,按选优条件向前搜索,以达到目的.但是当探索到某 ...

  6. C#LeetCode刷题-回溯算法

    回溯算法篇 # 题名 刷题 通过率 难度 10 正则表达式匹配   18.8% 困难 17 电话号码的字母组合   43.8% 中等 22 括号生成   64.9% 中等 37 解数独   45.8% ...

  7. 46. Permutations 回溯算法

    https://leetcode.com/problems/permutations/ 求数列的所有排列组合.思路很清晰,将后面每一个元素依次同第一个元素交换,然后递归求接下来的(n-1)个元素的全排 ...

  8. Gray Code——陈瑶师姐面试时候要用回溯算法

    The gray code is a binary numeral system where two successive values differ in only one bit. Given a ...

  9. 算法刷题--回溯算法与N皇后

    所谓回溯算法,在笔者看来就是一种直接地思想----假设需要很多步操作才能求得最终的解,每一步操作又有很多种选择,那么我们就直接选择其中一种并依次深入下去.直到求得最终的结果,或是遇到明细的错误,回溯到 ...

随机推荐

  1. noip模拟29

    这次终于是早上考试了 早上考试手感不错,这次刷新了以前的最高排名- %%%cyh巨佬 \(rk1\) %%%CT巨佬 \(t2\) 90 纵观前几,似乎我 \(t3\) 是最低的-- 总计挂分10分, ...

  2. junit4 套件测试

    junit4 中的套件可以用来测试一个需要依赖的业务流程,如购买必须依赖与登录成功 代码实现: 测试数据存放 public class BaseTest { protected static Hash ...

  3. Python使用openpyxl模块操作Excel表格

    ''' Excel文件三个对象 workbook: 工作簿,一个excel文件包含多个sheet. sheet:工作表,一个workbook有多个,表名识别,如"sheet1",& ...

  4. Python+Selenium：初步使用Chrome谷歌浏览器

    ·············环境结合··············· 我的环境:window10 64位 Python 3.7 32-bit selenium            3.141.0 Goo ...

  5. centos7 未启用swap导致内存使用率过高。

    情况描述: 朋友在阿里云上有一台系统为CentOS7的VPS,内存为2GB,用于平时开发自己的项目时测试使用: 他在上面运行了5个docker实例,运行java程序:还有一个mysql服务: 上述5个 ...

  6. 替代jquery中的几个函数

    // https://open.alipay.com/developmentAccess/developmentAccess.htm var $ = window.jQuery; (function( ...

  7. Fiddler修改抓包请求

    hi,说到fiddler的用途,第一时间想到抓包,不过还有一个功能是:支持修改请求. 那么问题来了,怎么做呢?很简单,先定下我们需要修改哪个请求. 这里用F12跟fiddler做演示. 首先我们在F1 ...

  8. 『Python』多进程

    Python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源(os.cpu_count()查看),在Python中大部分情况需要使用多进程.Python提供了multiprocessin ...

  9. python3之工程中必须依赖的__init__.py

    1.  __init__.py 1.1  什么是__init__.py 在Python3工程里,当python3检测到一个目录下存在__init__.py文件时,Python3就会把它当成一个模块(m ...

  10. maven插件maven-install-plugin

    maven-install-plugin负责将获取的jar包安装到本地仓库 <build> <plugin> <groupId>org.apache.maven.p ...