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

在I的基础上需要去掉重复出现的。

class Solution {
public:
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int> > result;
        permuteUtil(result, num, 0, num.size() - 1);
     
        return result;
    }
    
    void permuteUtil(vector<vector<int> > &result, vector<int> &num, int start, int end) {
        if (start == end) {
            result.push_back(num);
        }
        else {
            for (int i = start; i <= end; ++i) {
                if (!isDuplicate(num, start, i)) {
                    swap(num, start, i);
                    permuteUtil(result, num, start + 1, end);
                    swap(num, start, i);
                }
            }
        }
    }
    
    bool isDuplicate(vector<int> &num, int start, int target) {
        for (int i = start; i < target; ++i) {
            if (num[i] == num[target]) {
                return true;
            }
        }
        
        return false;
    }
    
    void swap(vector<int> &num, int i, int j) {
        int tmp = num[i];
        num[i] = num[j];
        num[j] = tmp;
    }
};

=============================

对应的另外一种解法，关键是如果两个数重复，只有前一个数使用了才能使用后一个数。

class Solution {
public:
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<vector<int> > result;
        
        sort(num.begin(), num.end());
        vector<bool> used(num.size(), false);
        vector<int> perm;
        permuteUtil(result, perm, num, used);
     
        return result;    
    }
    
    void permuteUtil(vector<vector<int> > &result, vector<int> & perm, const vector<int> &num, vector<bool> &used) {
        if (perm.size() == num.size()) {
            result.push_back(perm);
            return;
        }
        
        for (int i = 0; i < num.size(); ++i) {
            if (used[i] || i > 0 && num[i] == num[i-1] && !used[i-1]) {
                continue;
            }
            
            used[i] = true;
            perm.push_back(num[i]);
            permuteUtil(result, perm, num, used);
            perm.pop_back();
            used[i] = false;
        }
    }
};

在