全排列，字典顺序问题 ( permutations/leetcode）

46. Permutations

题目地址
https://leetcode.com/problems/permutations/

注意是distinct numbers，所以相对简单, 当然写出好的代码也是困难的，下面是ac代码（效率可能不高）

方法1：采用dfs遍历

class Solution {
private:
    vector<vector<int>> ans;
    vector<int> rs;
    map<int,int> vis;

public:

    void dfs(int len, vector<int> nums, int n)
    {
        if (len == n){
            ans.push_back(rs);
            return;
        }

        for (int i = 0; i < n; i++)
        {
            if (vis[i] == 0){
                vis[i] = 1;
                rs.push_back(nums[i]);
                dfs(len + 1, nums, n); // dfs
                rs.pop_back();
                vis[i] = 0;
            }
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        int n = nums.size();
        if (n == 0)
            return ans;
        dfs(0, nums, n);
        return ans;
    }
};

方法2： 全排列思路，就是以某个数开头，剩下的全排列，递归来做

class Solution {
private:
    vector<vector<int>> ans;

public:

    void recursion(int k,vector<int> nums, int n)
    {
        if (k >= n)
            return;
        if (k == n - 1){
        /*  for (int i = 0; i < n; i++)     
                cout << nums[i] << " ";
            cout << endl;*/
            ans.push_back(nums);
        }
        for (int i = k; i < n; i++)
        {
            swap(nums[k], nums[i]);
            recursion(k + 1, nums, n);
            swap(nums[k], nums[i]);
        }
    }

    vector<vector<int>> permute(vector<int>& nums) { // nums是distinct
        int n = nums.size();
        if (n == 0)
            return ans;
        recursion(0, nums, n);
        return ans;
    }
};

47. Permutations II

题目地址
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],
      [2,1,1]
    ]

有重复数字，采用递归做法，显然有很多重复的swap操作，需要避免

可以参考：
陆草纯
http://www.cnblogs.com/ganganloveu/p/4161693.html

ac代码：

class Solution {
private:
    vector<vector<int>> ans;
public:

    void recursion(int k, vector<int> nums, int n)
    {
        if (k >= n)
            return;
        if (k == n - 1){
            ans.push_back(nums);
        }

        sort(nums.begin() + k, nums.end()); // k之后的元素需要排序
        // 两相同元素 ， 一个元素与两个相同的元素？
        for (int i = k; i < n; i++)
        {
            if (i != k && nums[i] == nums[i-1])
                continue;
            swap(nums[k], nums[i]);
            recursion(k + 1, nums, n);  // 递归
            swap(nums[k], nums[i]);
        }
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        int n = nums.size();
        if (n == 0)
            return ans;

        recursion(0, nums, n);
        return ans;
    }
};

31. Next Permutation

题目地址
https://leetcode.com/problems/next-permutation/

求下一个字典序

思路参考：
warmland
http://www.cnblogs.com/warmland/p/5219217.html

一个老外对该题较好的解释：
http://www.geeksforgeeks.org/find-next-greater-number-set-digits/

ac代码：

class Solution {
public:

    void rev(vector<int> &nums, int left, int right){
        for (int i = left; i <= (left + right) / 2; i++){
            int tmp = nums[i];
            nums[i] = nums[right - i + left];
            nums[right - i + left] = tmp;
        }
    }

    void nextPermutation(vector<int>& nums) {
        int n = nums.size();
        if (n <= 1)
            return;

        int pos = n - 2;
        while (pos >= 0 && nums[pos] >= nums[pos + 1]){ // 递增，等号问题
            pos--;
        }
        if (pos >= 0){
            // 找到pos后面 比 nums[pos] 大的最小的一个数
            int j = n - 1;
            while (nums[j] <= nums[pos]){
                j--;
            }

            // swap
            int tmp = nums[j];
            nums[j] = nums[pos];
            nums[pos] = tmp;

            // reverse pos之后的所有数
            rev(nums, pos + 1, n - 1);
        }
        else{
            rev(nums, 0, n - 1);
        }
    }
};