DFS排列组合问题

最新推荐文章于 2024-07-14 18:15:43 发布

林小果呀

最新推荐文章于 2024-07-14 18:15:43 发布

阅读量750

点赞数 27

分类专栏：数据结构与算法(java实现) 文章标签：深度优先算法 leetcode java

本文链接：https://blog.csdn.net/weixin_74144099/article/details/136278385

版权

数据结构与算法(java实现) 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

本文详细介绍了LeetCode中的四个与排列组合相关的问题：全排列、全排列II、组合以及组合总和。展示了DFS递归算法的应用，包括排列题目的有序遍历和组合题目的无序遍历。

摘要由CSDN通过智能技术生成

DFS排列组合问题

排列组合问题的标准模板

public void dfs(int[] nums,boolean[] isViseted,…………){
    if(搜索终止的条件){
        将找到的结果放入结果集中
    }
     // 若为组合题，则从上一次访问元素或上一次访问元素的下一位开始遍历
    for(int i =0;i<nums.length;i++){ 
        if(isViseted[i] == false){
            res.add(nums[i]); // 如果元素未被访问过，则将元素放入结果中
            isViseted[i] = true;
            dfs(nums,isViseted,res,res1); 
            res.remove((Integer) nums[i]); //递归结束后恢复成原先的样子
            isViseted[i] =false;
        }
    }
}

排列与组合最大的区别就是for循环中开始的元素。如果是排列题，结果是有序的，我们需要从0开始遍历；如果是组合题，结果是无序的，我们需要从i或i+1开始遍历。下面将举例说明。

排列

LeetCode46全排列

题目描述

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

代码

class Solution {
    // 直接套用上述模板，其中res为当前搜寻的结果，res1为需要返回的结果集
    public void dfs(int[] nums,boolean[] isViseted,List<Integer> res,List<List<Integer>> res1){
        if(res.size() == nums.length){
            res1.add(new ArrayList<>(res));
        }
        for(int i =0;i<nums.length;i++){
            if(isViseted[i] == false){
                res.add(nums[i]);
                isViseted[i] = true;
                dfs(nums,isViseted,res,res1);
                res.remove((Integer) nums[i]);
                isViseted[i] =false;
            }
        }
    }

    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        int len = nums.length;
        dfs(nums,new boolean[len],new ArrayList<Integer>(),res);
        return res;
    }
}

LeetCode47全排列Ⅱ

题目描述

给定一个可包含重复数字的序列 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

代码

class Solution {
    public static void rm(List<Integer> l,Integer num){
        for(int i=l.size()-1;i>=0;i--){
            if(l.get(i) == num){
                l.remove(i);
                return;
            }
        }
    }

    public static void dfs(int[] nums,boolean[] isVisited,
                           List<Integer> ele,List<List<Integer>> res){
        int len = nums.length;
        if(ele.size() == len){
            for(List<Integer> l : res){
                if(l.equals(ele)){
                    return;
                }
            }
            res.add(new ArrayList<>(ele));
            return;
        }
        for(int i =0;i<len;i++){
            if(!isVisited[i]){
                ele.add(nums[i]);
                isVisited[i] = true;
                dfs(nums,isVisited,ele,res);
                isVisited[i] = false;
                Integer tem = nums[i];
                rm(ele,tem);
            }
        }
    }

    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(nums,new boolean[nums.length],new ArrayList<>(),res);
        return res;
    }
}

本题与上一题的区别在于结果中会出现重复数字，因此我们在恢复元素的时候就不能直接调用remove方法（因为remove方法删除的是从前往后找到的一个元素，但我们需要删除的元素在列表尾部），需要自己写一个rm方法，从后向前找元素并删除。

组合

LeetCode77组合

题目描述

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

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

示例 1：

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

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

1 <= n <= 20
1 <= k <= n

代码

class Solution {
    public static void dfs(int n,int k,int begin,List<Integer> ele,List<List<Integer>> res){
        if(ele.size() == k){
            res.add(new ArrayList<>(ele));
            return;
        }
        for(int i=begin;i<=n;i++){
            ele.add(i);
            dfs(n,k,i+1,ele,res);
            ele.remove((Integer) i);
        }
    }
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(n,k,1,new ArrayList<>(),res);
        return res;
    }
}

与排列问题的不同之处就在于我们把for循环中的起始位置改成了begin（上一次访问元素的下一位）

LeetCode39组合总和

题目描述

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

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

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

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40

代码

class Solution {

    public static void dfs(int[] candidates,int target,int count,int begin,List<Integer> ele,List<List<Integer>> res){
        if(count > target){
            return;
        }else if(count == target){
            res.add(new ArrayList<>(ele));
            return;
        }
        for(int i =begin;i<candidates.length;i++){
            ele.add(candidates[i]);
            dfs(candidates,target,count + candidates[i],i,ele,res);
            ele.remove((Integer) candidates[i]);
        }
    }

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(candidates,target,0,0,new ArrayList<>(),res);
        return res;
    }
}

本题需要我们在递归的同时计算当前的和，只需多加个count参数来记录总和。

LeetCode40组合总和Ⅱ

题目描述

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

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

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

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

1 <= candidates.length <= 100
1 <= candidates[i] <= 50
1 <= target <= 30

代码

class Solution {
    public static void dfs(int[] candidates,int target,int count,int begin,List<Integer> ele,List<List<Integer>> res){
        if(count > target){
            return;
        }else if(count == target){
            for(List<Integer> l : res){
                if(l.equals(ele)){
                    return;
                }
            }
            res.add(new ArrayList<>(ele));
            return;
        }
        for(int i =begin;i<candidates.length;i++){
            ele.add(candidates[i]);
            dfs(candidates,target,count + candidates[i],i+1,ele,res);
            int rem = candidates[i];
            ele.remove((Integer) candidates[i]);
            while(i < candidates.length-1 && rem == candidates[i+1]){
                i++;
            }
        }
    }

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> res = new ArrayList<>();
        dfs(candidates,target,0,0,new ArrayList<>(),res);
        return res;
    }
}

本题与上一题的区别在于数组里含有重复数字，我们需要先将数组进行排序，将重复数字放在一起，这样我们就不会将结果相同但顺序不同的数组当成不同的结果放入结果集。

whie循环在递归结束后判断下一个要递归的元素是否与当前元素相同，如果相同则可以直接跳过。

LeetCode216组合总和Ⅲ

题目描述

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

只使用数字1到9
每个数字 最多使用一次

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

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

2 <= k <= 9
1 <= n <= 60

代码

class Solution {
    public static void dfs(int k,int n,int begin,int count, List<Integer> target,List<List<Integer>> res){
        if(count > n){
            return;
        }
        if(target.size() == k){
            if(count == n){
                res.add(new ArrayList<Integer>(target));
            }
            return;
        }
        for(int i=begin;i<=9;i++){
            target.add(i);
            dfs(k,n,i+1,count+i,target,res);
            target.remove((Integer) i);
        }
    }

    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> res = new ArrayList<>();
        dfs(k,n,1,0,new ArrayList<>(),res);
        return res;
    }
}

林小果呀

关注

27
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
DFS排列组合问题

本题与上一题的区别在于结果中会出现重复数字，因此我们在恢复元素的时候就不能直接调用remove方法（因为remove方法删除的是从前往后找到的一个元素，但我们需要删除的元素在列表尾部），需要自己写一个rm方法，从后向前找元素并删除。如果是组合题，结果是无序的，我们需要从i或i+1开始遍历。本题与上一题的区别在于数组里含有重复数字，我们需要先将数组进行排序，将重复数字放在一起，这样我们就不会将结果相同但顺序不同的数组当成不同的结果放入结果集。如果至少一个数字的被选数量不同，则两种组合是不同的。
复制链接

扫一扫