Permutations II

最新推荐文章于 2020-03-29 17:21:57 发布

zephyr_be_brave

最新推荐文章于 2020-03-29 17:21:57 发布

阅读量529

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode习题分析

本文链接：https://blog.youkuaiyun.com/zephyr_be_brave/article/details/8724917

leetcode习题分析专栏收录该内容

137 篇文章

订阅专栏

本文探讨了在可能包含重复元素的数集中生成唯一排列的方法，通过两种算法优化了效率，详细介绍了排序与循环移位的基本思想，并通过实例演示了算法的应用。

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

Permutations II Mar 17 '12

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

For example,
[1,1,2] have the following unique permutations:
[1,1,2], [1,2,1], and [2,1,1].

思路一：用set来装vector，可以直接用Permutations的代码，但并没有从根本上解决产生重复排列的问题，效率也不高

class Solution {
public:

 int factorial(int n)  
    {  
        return (n==1)?1:n*factorial(n-1);  
    }  
      
    void nextPermutation(vector<int> &num) {    
        int i = 0;    
        int k = num.size();    
            
        while(k-->=1)    
        {    
            if(num[k] > num[k-1])    
            {    
                i = k;    
                break;    
            }    
        }    
        int j= i-1;    
        k = num.size();    
        while(k-- != i-1)    
        {    
            if(num[k] > num[i-1]) {    
                j = k;    
                break;    
            }    
        }              
        swap(num[i-1],num[j]);        
            
        reverse(num.begin()+i,num.end());    
    }    
      
  
    vector<vector<int> > permuteUnique(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int>> ret;  
        set<vector<int>> set;
          
        int N = factorial(num.size());  
        for(int i = 0;i < N;i++){  
            set.insert(num);  
            nextPermutation(num);  
        }  
        ret.insert(ret.end(),set.begin(),set.end());
        return ret; 
    }
};

800 milli secs

思路二：还是在permute的基础上，重点见注释

class Solution {  
public:  

    vector<vector<int> > permuteUnique(vector<int> &num) {  
        // Start typing your C/C++ solution below  
        // DO NOT write int main() function  
        vector<vector<int>> ret;  
          
        sort(num.begin(),num.end());  //重点在这步排序
        while(1){
            ret.push_back(num);  
            int i = 0;    
            int k = num.size();    
                
            while(k-->=1)    
            {    
                if(num[k] > num[k-1])    //这里是>号，所以在排好序的情况下是否有重复并无影响
                {    
                    i = k;    
                    break;    
                }    
            }    
            if(k==-1) break;          //判断是否生成了所有排列
            int j= i-1;    
            k = num.size();    
            while(k-- != i-1)    
            {    
                if(num[k] > num[i-1]) {    
                    j = k;    
                    break;    
                }    
            }              
            swap(num[i-1],num[j]);        
                
            reverse(num.begin()+i,num.end());    
        }  
        return ret;  
    }  
};

160 milli secs

其它方法暂不实现，有空再讨论吧

可以看一下这篇http://www.cnblogs.com/remlostime/archive/2012/11/13/2768816.html，提到DFS的方法