LeetCode-47. Permutations II [C++][Java]

最新推荐文章于 2025-08-05 17:34:52 发布

贫道绝缘子

最新推荐文章于 2025-08-05 17:34:52 发布

阅读量391

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode刷题怪文章标签： java leetcode c++

本文链接：https://blog.youkuaiyun.com/qq_15711195/article/details/123302599

LeetCode刷题怪专栏收录该内容

247 篇文章

订阅专栏

这篇博客介绍了LeetCode第47题——排列组合II的解题方法，包括C++和Java两种语言的实现。题目要求在可能存在重复元素的数列中返回所有不重复的排列。解题思路包括使用回溯法和借助集合避免重复。文章详细解析了两种解法的逻辑，并提供了示例输出和约束条件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LeetCode-47. Permutations IILevel up your coding skills and quickly land a job. This is the best place to expand your knowledge and get prepared for your next interview.https://leetcode.com/problems/permutations-ii/

题目描述

Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.

Example 1:

Input: nums = [1,1,2]
Output:
[[1,1,2],
 [1,2,1],
 [2,1,1]]

Example 2:

Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

Constraints:

1 <= nums.length <= 8
-10 <= nums[i] <= 10

解题思路

【C++】

1. 有条件的交换回溯

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> result;
        backtracking(nums, 0, result);
        return result;
    }
    
    void backtracking(vector<int>& nums, int begin, vector<vector<int>>& result) {
        if (begin == nums.size()-1){
            result.push_back(nums);
            return;
        }

        for (int i = begin; i < nums.size(); i++){
            if(NeedSwap(nums, begin, i)) {
                swap(nums[i], nums[begin]);
                backtracking(nums, begin+1, result);
                swap(nums[i], nums[begin]);
            }
        }
    }
    
    bool NeedSwap(vector<int>& nums, int begin, int end) {
        if (begin == end) {return true;}
        for (int i=begin; i<end; ++i) {if(nums[i] == nums[end]) {return false;}}
        return true;
    }
};

2. set规避重复

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        set<vector<int>> temp_set;
        backtracking(nums, temp_set, 0);
        return vector<vector<int>>(temp_set.begin(),temp_set.end());
    }
    
    void backtracking(vector<int>& nums, set<vector<int>>& temp_set, int level){
        if(level==nums.size()-1){
            temp_set.insert(nums);
            return;
        }
        for(int i=level;i<nums.size();++i){
            swap(nums[i],nums[level]);
            backtracking(nums,temp_set,level+1);
            swap(nums[i],nums[level]);
        }
    }
};

【Java】

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        boolean used[] = new boolean[nums.length];
        backtracking(result, new ArrayList<>(), nums, used);
        return result;
    }
    
    public void backtracking(List<List<Integer>> result, List<Integer> cur, int[] nums, boolean[] used) {
        if (cur.size() == nums.length) result.add(new ArrayList<Integer>(cur));
        for (int i=0;i<nums.length;i++) {
            if (used[i]) {continue;}
            if (i>0 && nums[i] == nums[i-1] && !used[i-1]) {continue;}
            cur.add(nums[i]);
            used[i]=true;
            backtracking(result, cur, nums,used);
            used[i]=false;
            cur.remove(cur.size()-1);
        }
    }
}