leetcode46/47-Permutations I/II(全排列问题)

1、Permutations问题描述：

Given a collection of distinct 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].

没有重复数字。

问题求解：

利用剑指offer上的思想。采用的方法是“交换元素”，好处是不需要再新开一个新数组存储，节省一部分辅助空间。

遍历字符串，然后将当前遍历的字符和首字符交换位置，调用本函数处理首字符之后的子字符串，函数执行完后，再调换回来。
在不需要复制字符串的情况下，避免了每次递归函数相互之间的影响。

总结思路是：

for(i = start to end)循环中:
（1）swap (第begin个和第i个)
（2）递归调用(begin+1)
（3）swap back

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        if(nums.size()==0) return res;
        permuteMain(nums, 0);
        return res;
    }
private:
    vector<vector<int>> res;
    void permuteMain(vector<int>& nums, int begin)
    {
        int n=nums.size();
        if(begin==n)
        {//(1)
            res.push_back(nums);
        }
        else
        {
            for(int i=begin;i<n;i++)
            {
                swap(nums[begin], nums[i]);//(2)
                permuteMain(nums, begin+1);//(3)
                swap(nums[begin], nums[i]);//(4)
            }
        }
    }
};

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

有重复数字的全排列问题。

问题求解：

依旧使用上面的思路，只不过需要定义一个set来存储已经交换过的元素值，也就是已经做过某个排列的首元素的值存放在set中，避免重复这种情形。

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        if(nums.size()==0) return res;
        permuteUniqueMain(nums, 0);
        return res;
    }

private:
    vector<vector<int>> res;
    void permuteUniqueMain(vector<int>& nums, int begin)
    {
        int n=nums.size();
        set<int> begindata;//存储排列的首元素
        if(begin==n)
        {
            res.push_back(nums);
        }
        else
        {
            for(int i=begin;i<n;i++)
            {
                if(begindata.find(nums[i]) != begindata.end())
                {//如果nums[i]已经做过某个排列首元素，则跳过这种情况
                    continue;
                }
                //如果nums[i]没有做过某个排列首元素
                begindata.insert(nums[i]);
                swap(nums[i], nums[begin]);
                permuteUniqueMain(nums, begin+1);
                swap(nums[i], nums[begin]);
            }
        }
    }
};