【leetcode】 Permutations II

From ： https://leetcode.com/problems/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].

Hide Tags

  Backtracking

Hide Similar Problems

  (M) Permutations

Solution ：

思路：采用字典序的非递归方法。从字典顺序最小的一种排列开始，每次获得字典序刚好比前一个排列大的排列，直到得到字典序最大的排列时，就得到了所有的结果，以字符串"abc"为例，"abc"是字典序最小的排列，所有情况按字典序排列为"abc","acb","bac","bca"，"cba","cab"。

具体步骤为为：
1.字符串进行排序，得到字符串的最小字典序排列(C0C1C2...Cn)，Ci<=Ci+1。  
2.从后往前，找到一对相邻的升序元素CiCi+1，(Ci<Ci+1)，如果遍历完字符串找不到这样的相邻升序对，说明已经达到了字典序最大的全排列
3.从字符串结束位置到位置i遍历，找到比Ci大的元素Cj，交换Cj的位置
4.将Ci+1到Cn所有的字符逆序，这样得到的排列刚好比之前的字典序大(因为转换后Ci+1<Ci+2<...<Cn，为最小字典序）。
5.重复3,4,5过程直到字典序最大。

class Solution {
public:
    void swap(int &i,int &j) {
        i ^= j;
        j ^= i;
        i ^= j;
    }
    vector<vector<int>> permuteUnique(vector<int> &num) {
        vector<vector<int>> res;
        int i, j, n=num.size();
        sort(num.begin(),num.end());
        res.push_back(num);
        while(true) {
            for(i=n-2; i>=0; i--)
                if(num[i] < num[i+1])
                    break;
            if(i<=-1) return res;
            for(j=n-1; j>i; j--)
                if(num[j] > num[i])
                    break;
            swap(num[i],num[j]);
            for(int k=i+1; k<(i+1+n)/2; k++)
                swap(num[k], num[n-(k-i)]);
            res.push_back(num);
        }
        return res;
    }
};

精简优化一下结构：

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new ArrayList<List<Integer>>();  
        Arrays.sort(nums);
        do {
            ans.add(toList(nums));
        } while(hasNextPermute(nums));
        
        return ans;
    }
    private boolean hasNextPermute(int[] nums) {
        int len = nums.length, j = len-2, k = len-1;
        while(j>=0 && nums[j]>=nums[j+1]) --j;
        if(j == -1) {
            return false;
        }
        
        for(int n=nums[j]; n>=nums[k]; --k) {}
        swap(nums, k, j);
        swapAll(nums, j+1, len-1);
        
        return true;
    }
    private void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }
    private void swapAll(int[] nums, int i, int j) {
        while(i < j) {
            swap(nums, i++, j--);
        }
    }
    private List<Integer> toList(int[] nums) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i=0; i<nums.length; ++i) {
            list.add(nums[i]);
        }
        return list;
    }
}

Solution ： 

先对数组进行排序，这样在DFS的时候，可以先判断前面的一个数是否和自己相等，相等的时候则前面的数必须使用了，自己才能使用，这样就不会产生重复的排列了。

class Solution {
public:
    void dfs(int dep, vector<int> &num) {
        if(dep == n) {
            ans.push_back(cur);
            return;
        }
        
        for(int i = 0; i < n; i++) {
            if (canUse[i]) {
                if (i != 0 && num[i] == num[i-1] && canUse[i-1]) continue;
                    
                canUse[i] = false;
                cur[dep] = num[i];
                dfs(dep + 1, num);
                canUse[i] = true;
            }
		}
    }
    
    vector<vector<int>> permuteUnique(vector<int> &num) {
		n = num.size();
        sort(num.begin(), num.end());
		cur = vector<int>(n);
		canUse = vector<bool>(n, true);
        ans.clear();
        dfs(0, num);
        return ans;
    }
private:
	int n;
    vector<bool> canUse;
    vector<int> cur;
    vector<vector<int> > ans;
};

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

	private List<Integer> toList(int[] nums) {
		List<Integer> l = new ArrayList<Integer>();
		for(int i : nums) {
			l.add(i);
		}
		return l;
	}
}