leetcode总结：permutations, permutations II, next permutation, permutation sequence

Next Permutation:

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

用的是STL里面rotate的算法：

class Solution {
public:
    void nextPermutation(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        int n=num.size();
        if ( n<=1)
            return;
        int p=n-2;
        while(p>=0&&num[p]>=num[p+1])
            p--;
        if ( p<0 )
        {
            sort(num.begin(),num.end());
            return;
        }
            
            
        int k=p+1;
        while(k<n&&num[k]>num[p])
            k++;
        k--;
        swap(num[p],num[k]);
        sort(&num[p+1],&num[n]);
        return;
    }
};

 

Permutations:

Given a collection of numbers, return all possible permutations.

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

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        vector<vector<int> > ans;
        solve(ans,num,0);
        return ans;
    }

    void solve(vector<vector<int> >& ans, vector<int>& num,int k)
    {
        int n =num.size();
        if ( k>=n )
        {
            ans.push_back(num);
            return;
        }
        for(int i=k;i<n;i++)
        {
            swap(num[i],num[k]);
            solve(ans,num,k+1);
            swap(num[i],num[k]);
        }
    }
};

Permutations II：

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].

这回是说不能要重复的。

其实如果可以用STL的函数next_permutation的话，一直next_permutation到false，每次把num加到结果里就行了，很简单吧~当然要先sort一下，不过面试时这样答的话，面试官就会让你实现next_permutation了~好在我们前面也做过啊~

另外一个方法就是用一个set记录num[i]是否已经放在K这个位置过了。

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        
        vector<vector<int> > ans;
        solve(ans,num,0);
        return ans;
    }

    void solve(vector<vector<int> >& ans, vector<int>& num,int k)
    {
        int n =num.size();
        if ( k>=n )
        {
            ans.push_back(num);
            return;
        }
            set<int> used;
        for(int i=k;i<n;i++)
        {
                    if(used.find(num[i]) != used.end())
                        continue;
            swap(num[i],num[k]);
            solve(ans,num,k+1);
            swap(num[i],num[k]);
                    used.insert(num[i]);
        }
    }
};
        

Permutation Sequence：

The set [1,2,3,…,n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order,
We get the following sequence (ie, for n = 3):

1. "123"
2. "132"
3. "213"
4. "231"
5. "312"
6. "321"

Given n and k, return the k^th permutation sequence.

Note: Given n will be between 1 and 9 inclusive.

    string getPermutation(int n, int k) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        vector<int> fac(n+1, 1);
        vector<int> nums;
        nums.push_back(0);
        int i;
        for(i = 1; i <= n; i++){
            fac[i] = fac[i-1]*i;
            nums.push_back(i);
        }
        string res = "";
        k--;
        while(n > 0){
            if(k == fac[n]){
                for(vector<int>::iterator it = nums.end()-1; it > nums.begin(); it--){
                    res += ('0' + *it);
                }
                break;
            }
            else if(k < fac[n-1]){
                res += ('0' + nums[1]);
                nums.erase(nums.begin()+1);
                n--;
            }
            else{
                i = k/fac[n-1];
                k = k%fac[n-1];
                res += ('0' + nums[1+i]);
                nums.erase(nums.begin()+1+i);
                n--;
            }
        }
        return res;
    }

 如果题目反转，是已知字符串，求是第几个，则可以用公式∑k*m!(m从0到n，k表示第m+1位之后有多少小于第m+1位个数)

 。