每日算法之三十六：Permutations && Permutations II

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

将第0个字符和从第0开始的每个字符进行交换，对于交换后的结果，再从第1个字符开始交换。一直到最后一个字符。

首先cur等于零，123进入循环内让第0个元素依次与第零个、第一个和第二个元素交换位置，生成排序树的三个分支是123（）下面的分析以此分支为例、213和321，然后每一个分支把cue加1，进入下一次循环，从第一个开始与后面的第一个、第二个元素交换位置，分支是123,132(后续分析以此为例)，然后cur变为2，满足条件就把132加入到结果集中。

<span style="font-size:18px;">class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
        vector<vector<int> > ret;
        dfs(ret, num, 0);
        return ret;
    }

    void dfs(vector<vector<int> >& ret, vector<int>& num, int cur)
    {
        if(num.size()-1 == cur)
        {
            ret.push_back(num);
        }
        else
        {
            for(int i = cur; i < num.size(); ++i)
            {
                swap(num[cur], num[i]);
                dfs(ret, num, cur+1);
                swap(num[cur], num[i]);//还原
            }
        }
    }
};</span>

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

如果前面 Permutations 的问题已经解决了的话，这个问题就变得非常简单。先排个序，以[1, 1, 2]为例，第一个1处理过以后，第二个1就可以跳掉了。

class Solution {
public:
    void internalpermuteUnique(vector<int> &num, int index, vector<int> &perm, vector<vector<int> > &result) {
        int size = num.size();
        
        if (size == index) {
            result.push_back(perm);
        }
        else {
            for (int i = index; i < size; ++i) {
                if ((i > index) && (num[i] == num[index])) {
                  continue;
                }
                else {
                  swap(num[index], num[i]);
                }
                
                perm.push_back(num[index]);
                internalpermuteUnique(num, index + 1, perm, result);
                perm.pop_back();
            }
            
            sort(num.begin() + index, num.end());
        }
    }
    
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int> > result;
        vector<int> perm;
        
        sort(num.begin(), num.end());
        internalpermuteUnique(num, 0, perm, result);
        
        return result;
    }
};