回溯算法-【全排列】【组合总和】【n皇后】【子集】

最新推荐文章于 2023-04-08 21:36:00 发布
最新推荐文章于 2023-04-08 21:36:00 发布
阅读量355 收藏 2
点赞数 2
分类专栏： algorithm leetcode 文章标签： 回溯算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17556191/article/details/96838867
版权

回溯算法

 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。即从一条路往前走，能进则进，不能进则退回来，换一条路再试。

如何使用回溯算法

 回溯我认为也就是一种递归，有以下四个参数，当然不一定是我所举例的类型，要看题目而定
  (1)一个全局变量集合保存所有满足条件的答案，举例：List<List> res
  (2)一个集合保存一个满足条件的答案，举例：List tmpList
核心：根据各个题情况变换

  for (int i = start; i <= n; i++) {
  		//add进去的值根据题意变换
                tmplist.add(i);
                //递归,这里根据题意变换回溯，这仅仅是个例子
                backtrack( k - 1, n, i+1,tmplist, result);
                //将这个集合清空，方便下一个满足条件的答案
                tmplist.remove(tmplist.size()-1);
            }

leetcode_【46】全排列 I

https://leetcode-cn.com/problems/permutations/

题目描述：
 给定一个没有重复数字的序列，返回其所有可能的全排列。
输入：
  [1,2,3]
输出：
  [
   [1,2,3],
   [1,3,2],
   [2,1,3],
   [2,3,1],
   [3,1,2],
   [3,2,1]
   ]

解题思路：

  回溯算法：

  • 将第j个数字与第 j , j +1 , j + 2 ,…, len(nums) - 1个数字分别交换，得到 len(nums) - j 种情况；
  • 在每种情况下递归，将第j+1处数字与第j+1,j+2,…,len(nums) - 1处数字分别交换；
    • 每个递归跳出后，要将交换过的元素还原，这样才能实现第一条所说的内容。
    • 直到j == len(nums) - 1，代表此种交换组合下已经交换完毕，记录答案。

代码

第一版：

import java.util.ArrayList;
import java.util.List;
//执行用时 :41 ms, 在所有 Java 提交中击败了5.01%的用户
//内存消耗 :44.4 MB, 在所有 Java 提交中击败了5.03%的用户
public class Solution {
   public static void main(String[] args) {
       int [] arr = {1,2,1};
       permute(arr);
   }
   public static List<List<Integer>> permute(int[] nums) {
       List<List<Integer>> res = new ArrayList<>();
       backTrace(nums,0,new ArrayList<>(),res);
       return res;
   }

   private static void backTrace(int[] nums, int start,ArrayList<Integer> tempList, List<List<Integer>> res) {
       //start为左边界值，要跟右边界的数进行交换
       if(start == nums.length){
           if(!res.contains(tempList)){
               res.add(new ArrayList<>(tempList));
           }
       }
       for(int i = start;i<nums.length;i++){
           //将第j个数字与第 j , j +1 , j + 2 ,..., len(nums) - 1个数字分别交换
           swap(nums,start,i);
           tempList.add(nums[start]);
           backTrace(nums,start+1,tempList,res);
           tempList.remove(tempList.size()-1);
           // 每个递归跳出后，要将交换过的元素还原
           swap(nums,start,i);
       }
   }
   //交换
   private static void swap(int[] nums, int start, int i) {
       int temp = nums[start];
       nums[start] = nums[i];
       nums[i] = temp;
   }
}

第二版：leetcode官网解答

这里有一个回溯函数，使用第一个整数的索引作为参数 backtrack(first)。

  • 如果第一个整数有索引 n，意味着当前排列已完成。
  • 遍历索引 first 到索引 n - 1 的所有整数。
    • 在排列中放置第 i 个整数， 即 swap(nums[first], nums[i]).
    • 继续生成从第 i 个整数开始的所有排列: backtrack(first + 1).
    • 现在回溯，即通过 swap(nums[first], nums[i]) 还原.
//执行用时 :3 ms, 在所有 Java 提交中击败了87.64%的用户
//内存消耗 :38.5 MB, 在所有 Java 提交中击败了67.89%的用户
class Solution {
   public void backtrack(int n,ArrayList<Integer> nums, List<List<Integer>> output, int first) {
       //如果第一个整数有索引 n，意味着当前排列已完成。
       if (first == n)
           output.add(new ArrayList<Integer>(nums));
       // 遍历索引 first 到索引 n - 1 的所有整数。
       for (int i = first; i < n; i++) {
           //在排列中放置第 i 个整数
           Collections.swap(nums, first, i);
           //  继续生成从第 i 个整数开始的所有排列
            backtrack(n, nums, output, first + 1);
           //回溯
           Collections.swap(nums, first, i);
       }
   }

   public List<List<Integer>> permute(int[] nums) {
       List<List<Integer>> output = new LinkedList();

       // convert nums into list since the output is a list of lists
       ArrayList<Integer> nums_lst = new ArrayList<Integer>();
       for (int num : nums)
           nums_lst.add(num);

       int n = nums.length;
       backtrack(n, nums_lst, output, 0);
       return output;
   }
}

leetcode_【47】全排列 II

https://leetcode-cn.com/problems/permutations-ii/

题目描述：
 给定一个可能包含重复数字的序列，返回其所有可能的不重复全排列。
输入：
  [1,1,2]
输出：
  [
   [1,1,2],
   [1,2,1],
   [2,1,1],
   ]

代码

第一版：

import java.util.ArrayList;
import java.util.List;
//执行用时 :742 ms, 在所有 Java 提交中击败了8.80%的用户
//内存消耗 :45.7 MB, 在所有 Java 提交中击败了44.99%的用户
public class Solution{
        public static  List<List<Integer>> permuteUnique(int[] nums) {
            List<List<Integer>> res = new ArrayList<>();
            backTrace(nums,0,new ArrayList<>(),res);
            return res;
        }

        private static void backTrace(int[] nums, int start,ArrayList<Integer> tempList, List<List<Integer>> res) {
            //start为边界值
            if(start == nums.length){
                //加了这一句
                if(!res.contains(tempList)){
                    res.add(new ArrayList<>(tempList));
                }
            }
            for(int i = start;i<nums.length;i++){
                swap(nums,start,i);
                tempList.add(nums[start]);
                backTrace(nums,start+1,tempList,res);
                tempList.remove(tempList.size()-1);
                swap(nums,start,i);
            }
        }
        
        private static void swap(int[] nums, int start, int i) {
            int temp = nums[start];
            nums[start] = nums[i];
            nums[i] = temp;
        }
    }

优化的第二版:leetcode官网解答
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

//执行用时 :6 ms, 在所有 Java 提交中击败了63.63%的用户
//内存消耗 :42.8 MB, 在所有 Java 提交中击败了76.28%的用户
public class Solution {

    private List<List<Integer>> res = new ArrayList<>();
    private boolean[] used;

    private void findPermuteUnique(int[] nums, int depth, Stack<Integer> stack) {
        if (depth == nums.length) {
            res.add(new ArrayList<>(stack));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                // 修改 2：因为排序以后重复的数一定不会出现在开始，故 i > 0
                // 和之前的数相等，并且之前的数还未使用过，只有出现这种情况，才会出现相同分支
                // 这种情况跳过即可
                if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                    continue;
                }
                used[i] = true;
                stack.add(nums[i]);
                findPermuteUnique(nums, depth + 1, stack);
                stack.pop();
                used[i] = false;
            }
        }
    }

    public List<List<Integer>> permuteUnique(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return res;
        }
        // 修改 1：首先排序，之后才有可能发现重复分支
        Arrays.sort(nums);
        used = new boolean[len];
        findPermuteUnique(nums, 0, new Stack<>());
        return res;
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 2};
        Solution solution = new Solution();
        List<List<Integer>> permuteUnique = solution.permuteUnique(nums);
        System.out.println(permuteUnique);
    }
}

leetcode_【77】组合

https://leetcode-cn.com/problems/combinations/

 给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入:
  n = 4, k = 2
输出:
   [
   [2,4],
   [3,4],
   [2,3],
   [1,2],
   [1,3],
   [1,4],
   ]

//执行用时 :40 ms, 在所有 Java 提交中击败了52.77%的用户
//内存消耗 :52.5 MB, 在所有 Java 提交中击败了26.41%的用户
public class Solution {
   public static List<List<Integer>> combine(int n, int k) {
       List<List<Integer>> res = new ArrayList<>();
       backtrack(k,n,1,new ArrayList(),res);
       return res;
   }
   public static void backtrack(int k,int n,int start,List<Integer> tmplist,List<List<Integer>> result){
       if(k == 0){
           result.add(new ArrayList<>(tmplist));
       }else {
           for (int i = start; i <= n; i++) {
               tmplist.add(i);
               //递归，这里回溯 从 i+1  ~ n 中 k-1 个数的组合，直到k == 0就可将这次结果存到res里面
               backtrack( k - 1, n, i+1,tmplist, result);
               tmplist.remove(tmplist.size()-1);
           }
       }
   }
}

leetcode_【39】组合总和 I

   https://leetcode-cn.com/problems/combination-sum/

 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以>使数字和为 target 的组合。
 candidates 中的数字可以无限制重复被选取。
说明：
  (1)所有数字（包括 target）都是正整数。
 (2)解集不能包含重复的组合。
示例 1:
输入:
   candidates = [2,3,6,7], target = 7,
所求解集为:
   [
   [7],
   [2,2,3]
   ]
示例 2:
输入:
  candidates = [2,3,5], target = 8,
所求解集为:
  [
  [2,2,2,2],
   [2,3,3],
   [3,5]
  ]

代码

//执行用时 :7 ms, 在所有 Java 提交中击败了81.11%的用户
//内存消耗 :39.1 MB, 在所有 Java 提交中击败了87.66%的用户
class Solution {
    public static List<List<Integer>> combinationSum(int[] candidates, int target) {
          //存放结果
          List<List<Integer>> res = new ArrayList<>();
          //排序
          Arrays.sort(candidates);
          //从第一个数开始递归
          calculate(candidates,target,0,new ArrayList<>(),res);

          return res;
      }
     public static void calculate(int[] candidates,int target,int start,ArrayList<Integer> tmpList,List<List<Integer>> result) {
        //回溯
        if (target < 0) {
            return;
        }
        //存入结果集
        else if (target == 0) {
            result.add(new ArrayList<>(tmpList));
            return;
        } else {
            for (int i = start; i < candidates.length && target >= candidates[i]; i++) {
                //加入
                tmpList.add(candidates[i]);
                //递归,candidates 中的数字可以使用无数次，故start还是从 i 开始
                calculate( candidates, target - candidates[i], i, tmpList,result);
                //清空所得到的一次结果的list
                tmpList.remove(tmpList.size() - 1);
            }
        }
    }

leetcode_【40】组合总和 II

   https://leetcode-cn.com/problems/combination-sum-ii/

  给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 candidates 中的数字可以只能使用一次。
说明：
  (1)所有数字（包括 target）都是正整数。
 (2)解集不能包含重复的组合。
输入:
  candidates = [10,1,2,7,6,1,5], target = 8，
所求解集为:
   [
   [1, 7],
   [1, 2, 5],
   [2, 6],
   [1, 1, 6]
   ]
示例 2:
输入:
   candidates = [2,5,2,1,2], target = 5,
所求解集为:
   [
  [1,2,2],
   [5]
   ]

代码

//执行用时 :30 ms, 在所有 Java 提交中击败了22.59%的用户
//内存消耗 :45 MB, 在所有 Java 提交中击败了27.34%的用户
public class Solution {
  public static List<List<Integer>> combinationSum2(int[] candidates, int target) {
      List<List<Integer>> res = new ArrayList<>();
      //排序
      Arrays.sort(candidates);
      //从下标为0，目标为target的开始回溯
      backTrace(candidates,target,0,new ArrayList<>(),res);
      return res;
  }

  private static void backTrace(int[] candidates, int target,int start, ArrayList<Integer> tmpList, List<List<Integer>> res) {
      if(target<0)
          return;
       //
      else if(target == 0){
         //解集不能包含重复的组合。 
          Collections.sort(tmpList);
          if(!res.contains(tmpList)){
              res.add(new ArrayList<>(tmpList));
          }
      }else {
          for (int i = start; i < candidates.length && target >= candidates[i]; i++) {
              tmpList.add(candidates[i]);
              //回溯,因为candidates 中的数字可以只能使用一次，所以这里start变成了i+1
              backTrace(candidates, target - candidates[i], i + 1, tmpList, res);
              tmpList.remove(tmpList.size() - 1);
          }
      }
  }

leetcode_【216】组合总和III

https://leetcode-cn.com/problems/combination-sum-iii/submissions/

  找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
 所有数字都是正整数。
  解集不能包含重复的组合。
示例 1:
输入:
   k = 3, n = 7
输出:
   [[1,2,4]]
示例 2:
输入:
  k = 3, n = 9
输出:
   [[1,2,6], [1,3,5], [2,3,4]]

代码

//执行用时 :5 ms, 在所有 Java 提交中击败了8.96%的用户
//内存消耗 :34.1 MB, 在所有 Java 提交中击败了28.88%的用户
class Solution {
   public static List<List<Integer>> combinationSum3(int k, int n) {
       List<List<Integer>> res = new ArrayList<>();
       backTrace(k,n,1,new ArrayList<>(),res);
       return res;
   }

   private static void backTrace(int k, int target,int start, ArrayList<Integer> tmpList, List<List<Integer>> res) {
       if(0 == k && target == 0){
           Collections.sort(tmpList);
           if(!res.contains(tmpList))
               res.add(new ArrayList<>(tmpList));
       }else{
        // 组合数中只包含1-9的数，故i<=9
           for(int i = start;i <= 9 ;i++){
               tmpList.add(i);
               backTrace(k-1,target - i,i+1,tmpList,res);
               tmpList.remove(tmpList.size()-1);
           }
       }
   }
}

leetcode_【377】组合总和 IV

 给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。
示例:
   nums = [1, 2, 3]
  target = 4
所有可能的组合为：
   (1, 1, 1, 1)
   (1, 1, 2)
   (1, 2, 1)
   (1, 3)
   (2, 1, 1)
   (2, 2)
   (3, 1)
请注意，顺序不同的序列被视作不同的组合。
因此输出为 7。

代码

回溯超出内存限制

public static int combinationSum4(int[] nums, int target) {
     List<List<Integer>> res = new ArrayList<>();
     Arrays.sort(nums);
     backTrace(nums,target,0,new ArrayList<>(),res);
     return res.size();
 }

private static void backTrace(int[] nums, int target, int start, ArrayList<Integer> tmpList, List<List<Integer>> res) {
     if(target < 0){
         return;
     }else if(target == 0){
         res.add(new ArrayList<>(tmpList));
     }else{
         for(int i = 0;i<nums.length && target >= nums[i];i++){
             tmpList.add(nums[i]);
             backTrace(nums,target - nums[i],i,tmpList,res);
             tmpList.remove(tmpList.size()-1);
         }
     }
}

动态规划：dp[i] 代表组成i 能有多少种组合数，即dp[1] = 2代表 和为1的组合个数为2

  • 初始化
    • dp[0] = 1;即组成和为0的组合数为1，即都nums里面的数都不取
  • 状态转移方程：
    • dp[i]=dp[ i - nums[0] ]+dp[ i - nums[1] ]+dp[ i - nums[2] ] + ...
      举个例子 : 比如nums=[1,3,4],target=7;dp[7]=dp[6]+dp[4]+dp[3]
//执行用时 :5 ms, 在所有 Java 提交中击败了68.54%的用户
//内存消耗 :34.3 MB, 在所有 Java 提交中击败了39.00%的用户
public static int combinationSum6(int[] nums, int target) {
    int dp[] = new int[target + 1];
    //初始化
    dp[0] = 1;
    for(int i = 1;i<=target;i++){
        for(int j = 0;j<nums.length;j++){
            if(i - nums[j] >= 0 ){
                dp[i] += dp[i-nums[j]];
            }
        }
    }
    return dp[target];
}

leetcode_【51】N皇后 I

https://leetcode-cn.com/problems/n-queens/

  n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
  给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
  每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
示例:
输入:
  4
输出:
    [
    [".Q…", // 解法 1
    “…Q”,
    “Q…”,
    “…Q.” ],
    [ “…Q.”, // 解法 2
    “Q…”,
    “…Q”,
    “.Q…”]
    ]
解释: 4 皇后问题存在两个不同的解法。

代码

  • 回溯函数 backtrack(row = 0).
    • 从第一个 row = 0 开始.
    • 循环列并且试图在每个 column 中放置皇后.
      • 如果方格 (row, column) 不在攻击范围内
        • 在 (row, column) 方格上放置皇后
        • 排除对应行，列和两个对角线的位置。
        • If 所有的行被考虑过，row == NunOfQueen
          • 意味着我们找到了一个解
        • else
          • 继续考虑接下来的皇后放置 backtrack(row + 1).
        • 回溯：将在 (row, column) 方格的皇后移除.
package leetcode.Arrays.回溯;

import java.lang.reflect.Array;
import java.util.*;
//执行用时 :9 ms, 在所有 Java 提交中击败了53.89%的用户
//内存消耗 :39.3 MB, 在所有 Java 提交中击败了84.75%的用户
public class Main_51 {
    public static List<List<String>> solveNQueens(int n) {
        //用于存储行
        List<Integer> col = new ArrayList<>();
        //用于存储正对角线
        List<Integer> z_diagonal = new ArrayList<>();
        //用于存储负对角线
        List<Integer> f_diagonal = new ArrayList<>();
        //存储结果
        List<List<String>> res = new ArrayList<>();
        //从第一个row = 0开始
        backtrack(0, n, res, new ArrayList<String>(), col, z_diagonal, f_diagonal);
        return res;
    }
    public static void backtrack(int row, int NumOfQueen, List<List<String>> res, ArrayList<String> tmplist, List<Integer> col, List<Integer> z_diagonal, List<Integer> f_diagonal) {
        //到达了最后一行
        if (row == NumOfQueen) {
            res.add(new ArrayList<>(tmplist));
            return;
        }
        //从第0列开始遍历
        for (int column = 0; column < NumOfQueen; column++) {
            //如果不在攻击范围内（不在同一行或者同一列 && 负对角线和相等 &&  正对角线差相等）
            if (!col.contains(column) && !f_diagonal.contains(row + column) && !z_diagonal.contains(row - column)) {
                col.add(column);
                f_diagonal.add(row + column);
                z_diagonal.add(row - column);
                char[] s = new char[NumOfQueen];
                Arrays.fill(s, '.');
                //这一行的j位置放皇后
                s[column] = 'Q';
                tmplist.add(new String(s));
                //回溯算法
                backtrack(row+1,NumOfQueen,res,tmplist,col,z_diagonal,f_diagonal);
                tmplist.remove(tmplist.size() - 1);
                col.remove(Integer.valueOf(column));
                f_diagonal.remove(Integer.valueOf(row + column));
                z_diagonal.remove(Integer.valueOf(row - column));
            }
        }
    }
   
}

leetcode_【52】N皇后 II

https://leetcode-cn.com/problems/n-queens-ii/

  n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
  给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
  每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
示例:
输入:
  4
输出:
  2
解释：4皇后存在两种不同的解法
    [
    [".Q…", // 解法 1
    “…Q”,
    “Q…”,
    “…Q.” ],
    [ “…Q.”, // 解法 2
    “Q…”,
    “…Q”,
    “.Q…”]
    ]

如leetcode_【51】代码返回res.size();

代码

//执行用时 :29 ms, 在所有 Java 提交中击败了5.45%的用户
//内存消耗 :34.8 MB, 在所有 Java 提交中击败了41.25%的用户
public class Solution {
 public static int totalNQueens(int n) {
     //用于存储行
     List<Integer> col = new ArrayList<>();
     //用于存储正对角线
     List<Integer> z_diagonal = new ArrayList<>();
     //用于存储负对角线
     List<Integer> f_diagonal = new ArrayList<>();
     //存储结果
     List<List<String>> res = new ArrayList<>();
     //从第一个row = 0开始
     backtrack(0, n, res, new ArrayList<String>(), col, z_diagonal, f_diagonal);
     return res.size();
 }
 public static void backtrack(int row, int NumOfQueen, List<List<String>> res, ArrayList<String> tmplist, List<Integer> col, List<Integer> z_diagonal, List<Integer> f_diagonal) {
     //到达了最后一行
     if (row == NumOfQueen) {
         res.add(new ArrayList<>(tmplist));
         return;
     }
     //从第0列开始遍历
     for (int column = 0; column < NumOfQueen; column++) {
         //如果不在攻击范围内（不在同一行或者同一列 && 负对角线和相等 &&  正对角线差相等）
         if (!col.contains(column) && !f_diagonal.contains(row + column) && !z_diagonal.contains(row - column)) {
             col.add(column);
             f_diagonal.add(row + column);
             z_diagonal.add(row - column);
             char[] s = new char[NumOfQueen];
             Arrays.fill(s, '.');
             //这一行的j位置放皇后
             s[column] = 'Q';
             tmplist.add(new String(s));
             //回溯算法
             backtrack(row+1,NumOfQueen,res,tmplist,col,z_diagonal,f_diagonal);
             tmplist.remove(tmplist.size() - 1);
             col.remove(Integer.valueOf(column));
             f_diagonal.remove(Integer.valueOf(row + column));
             z_diagonal.remove(Integer.valueOf(row - column));
         }
     }
  }
}

leetcode_【78】子集I

https://leetcode-cn.com/problems/subsets/

 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
 说明：解集不能包含重复的子集。
 示例:
输入:
  nums = [1,2,3]
输出:
   [
   [3],
   [1],
   [2],
   [1,2,3],
   [1,3],
   [2,3],
   [1,2],
   []
   ]

代码

//执行用时 :2 ms, 在所有 Java 提交中击败了87.86%的用户
//内存消耗 :37 MB, 在所有 Java 提交中击败了44.12%的用户
class Solution {
     public static List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        backTrace(nums,0,new ArrayList<>(),res);
        return res;
    }

    private static void backTrace(int[] nums, int start, ArrayList<Integer> tmplist, List<List<Integer>> res) {
        res.add(new ArrayList<>(tmplist));
        for(int i = start;i<nums.length;i++){
            tmplist.add(nums[i]);
            backTrace(nums,i+1,tmplist,res);
            tmplist.remove(tmplist.size()-1);
        }
    }
}

leetcode_【90】子集 II

https://leetcode-cn.com/problems/subsets-ii/

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例:
输入:
  [1,2,2]
输出:
    [
    [2],
    [1],
    [1,2,2],
    [2,2],
    [1,2],
    []
    ]

代码

//执行用时 :3 ms, 在所有 Java 提交中击败了87.52%的用户
//内存消耗 :38.5 MB, 在所有 Java 提交中击败了47.42%的用户
class Solution {
      public static List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        backTrace(nums,0,new ArrayList<>(),res);
        return res;
    }
    private static void backTrace(int[] nums, int start, ArrayList<Integer> tmplist, List<List<Integer>> res) {
        res.add(new ArrayList<>(tmplist));
        for(int i = start;i<nums.length;i++){
            //和上一个数字相等则跳过
            if(i > start && nums[i] == nums[i-1] ){
                continue;
            }else{
                tmplist.add(nums[i]);
                backTrace(nums,i+1,tmplist,res);
                tmplist.remove(tmplist.size()-1);
            }

        }
    }
}
扎个冲天揪
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python算法题源代码-LeetCode(力扣)-子集
02-27
子集 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。 示例 1： 输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],...
回溯算法(两种方法实现)--全排列
CppYyds的博客
04-07 146
文章目录题目：利用used数组标记来实现利用交换来实现 题目： 全排列 利用used数组标记来实现 //特点在于used数组，设置used数组和nums长度一致，当下标i对应的nums元素被使用过，就让used数组对应的i下标元素值为1来标记。 class Solution { public: vector<vector<int>> permute(vector<int>& nums) { vector<int> used(n
39. 组合总和---回溯算法
小小核桃
06-26 317
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 示例 1: 输入: candidates = [2,3,6,7], target = 7,...
组合总和-回溯法
weixin_62434171的博客
12-25 132
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。2 和 3 可以形成一组候选，2 + 2 + 3 = 7。输入：candidates = [2,3,6,7], target = 7。输入: candidates = [2,3,5], target = 8。输出: [[2,2,2,2],[2,3,3],[3,5]]输出：[[2,2,3],[7]]
算法设计之扒回溯算法（全排列问题）
云澈的博客
04-25 1079
给定一个 没有重复 数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 废话不多说，直接上回溯算法框架。解决一个回溯问题，实际上就是一个决策树的遍历过程。你只需要思考 3 个问题： 1、路径：也就是已经做出的选择。 2、选择列表：也就是你当前可以做的选择。...
回溯法之----N皇后问题,全排列问题,求子集问题
weixin_42413719的博客
03-29 306
N皇后问题 N皇后问题是八皇后问题的升级版主要思路也是通过回溯法来实现的 这列通过对角线判断进行了适当的优化 首先先贴上代码 #include <iostream> using namespace std; int cnt; int a[12]; int col[12]; int dig1[24]; int dig2[24]; void placeQueen(int k,int &am...
装载问题-回溯算法-java实现
12-30
本例采用java实现的装载问题，采用的是回溯算法，参考书籍为：算法设计和分析（第二版）
n皇后排列树
06-04
算法n皇后排列树代码 一、 理解回溯法深度优先搜索策略 掌握用回溯法解题的算法框架： （1）递归回溯 （2）子集树算法框架 （3）迭代回溯 （4）排列树算法框架 二、实验内容： 问题描述 用排列树实现8皇后问题 ...
回溯算法 子集和数
05-20
在一个集合A[1~n]中找出所有元素之和等于S的子集。 ①确定解向量：X[1~n], X[i]=1表示A[i]被选入子集，X[i]=0表示弃选，本质：划分成2个子集。②解空间树
Python基于回溯法子集树模板解决数字组合问题实例
01-20
本文实例讲述了Python基于回溯法子集树模板解决数字组合问题。分享给大家供大家参考，具体如下： 问题 找出从自然数1、2、3、…、n中任取r个数的所有组合。 例如，n=5，r=3的所有组合为： 1,2,3 1,2,4 1,2,5 1,3,4 1...
回溯算法全排列----详细分析
weixin_73548574的博客
03-28 850
回溯算法，详解，过程
理解回溯算法——从全排列问题开始
csdnzzt的博客
04-08 299
一、简介 回溯法(backtracking)是优先搜索的一种特殊情况，又称为试探法，常用于需要记录节点状态的深度优先搜索。通常来说，排列、组合、选择类问题使用回溯法比较方便。 解题套路： result = [] def backtrack(路径, 选择列表): if 满足结束条件: result.add(路径) return for 选...
leetcode 刷题 46 47
微信号：RunsenLiu
05-20 1138
class Solution: def permute(self, nums: List[int]) -> List[List[int]]: ans = [nums] for i in range(1, len(nums)): m = len(ans) for k in range(m): ...
回溯法：全排列
weixin_40759186的博客
11-28 1306
全排列 递归实现：把元素换到数组首位，剩下的部分做全排列 def constraint(): return True def bound(): return True def perm_backtracking(depth,lst): size = len(lst) if depth == size: print(lst) el...
枚举字符串的排列, 八皇后,枚举&回溯2种解法
gcs的博客
07-03 818
输入一个字符串,打印出该字符串中字符的所有排列。 例如输入字符串abc,则打印出由字符a、b、c所能排列出来的所有字符串abc, acb , bac、bca, cabcba。 由于字符串的长度不同, 使用for循环嵌套枚举是不行的, 需要使用递归才能处理不定长度的字符串. 需要把字符全排列, 每个字符都可能出现在第一位置, 可以看成 完整字符 = 单个字符 + 剩余字符的全排列 , 剩余字符的全排列 = 单个字符 + (剩余字符-单个字符)的全排列, 这样下去,剩余字符会越来越少, 当剩余字符没有...
Java之使用回溯算法解决多个数和的问题（Sum It Up）
玹之空间
12-21 671
提示：养成看目录的好习惯哦！！ 文章目录前言一、实验目的二、实验内容二、设计思路1.定义变量2.构造方法3.运行4.结果总结 前言 回溯法 – 深度优先搜素 简单概述 回溯法思路的简单描述是：把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 基本思想类同于： 图的深度优先搜索 二叉树的后序遍历 实验八：使用回溯算法解决多个数和的问题（Sum It Up）（完成实验报告三、四、五、六的内容） 一、实验目的
动态规划-零钱兑换问题
qiulig
07-15 3437
1.题目描述 leetcode-322:零钱兑换  给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。 示例1： 输入：  coins=[1,2,5],amount = 11 >输出：  3 示例2： 输入：  coins=[1,2,5],amount = 11 输出：   -...
Shopee的办公室
qiulig
07-17 1625
1.题目描述  shopee的办公室非常大，小虾同学的位置坐落在右上角，而大门却在左下角，可以把所有位置抽象为一个网格（门口的坐标为0，0），小虾同学很聪明，每次只向上，或者向右走，因为这样最容易接近目的地，但是小虾同学不想让自己的boss们看到自己经常在他们面前出没，或者迟到被发现。他决定研究一下如果他不通过boss们的位置，他可以有多少种走法？ 输入描述:  第一行 x,y,n (0<...
【俄罗斯套娃信封问题】【堆积木】
qiulig
07-30 746
俄罗斯套娃信封问题 https://leetcode-cn.com/problems/russian-doll-envelopes/  给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。  请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封...
0-1背包问题和n皇后问题
最新发布
11-15
n皇后问题是一个经典的回溯算法问题，其问题描述为：在一个n×n的棋盘上放置n个皇后，使得每行、每列和每条对角线上都只有一个皇后。其中，对角线包括正对角线和反对角线。 以下是两个问题的解决方法： 0-1背包...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值