[Medium]46. Permutations + 47. Permutations II

原题： 47. Permutations II 　　46. Permutations

初级版：46. Given a collection of distinct integers, return all possible permutations.
升级版：47. Given a collection of numbers that might contain duplicates, return all possible unique permutations.

题目大意：

初级版：46. 求一组包含不同数字的全排列
升级版：47. 求一组可能包含相同数字的全排列

解题思路：

• 解法1：递归法：
  算法思路：全排列就是从第一个数字起每个数分别与它后面的数字进行交换，全排列可以看做固定前i位，对第i+1位之后的再进行全排列，比如固定第一位，后面跟着n-1位的全排列。那么解决n-1位元素的全排列就能解决n位元素的全排列了，这样的设计很容易就能用递归实现。
  代码如下：

    void permutation(int a[], int length, int index)
  {
      int i = 0, j = 0, temp = 0;
      if(index == length)
      {
          for(i = 0; i < length; ++i)
          {
              printf("%d ", a[i]);
          }
          printf("
  ");
      }
      else
      {
          for(i = index; i < length; i++)
          {
              temp = a[i];//将两个数进行交换
              a[i] = a[index];
              a[index] = temp;
  
              permutation(a, length, index + 1); //计算剩下 n-1 个数的全排列
  
              temp = a[i]; // 还原
              a[i] = a[index];
              a[index] = temp;
          }
      }
  }
  

输入：a[3] = {1,2,3}
输出：
1 2 3
1 3 2
2 1 3
2 3 1
3 2 1
3 1 2
-----------------------------------------------------------------------------------------------------------------
输入： a[3] = {1,2,2}
输出：
1 2 2
1 2 2
2 1 2
2 2 1
2 2 1
2 1 2

可以看到，程序上面的程序是把所有的数字都当成不同的数来处理，因此，当遇到相同的数字时就出现了问题，我们可以观察到：如果一个数后面还有一个和它相同的数字，那么这两个数字的交换是无效的，其交换并没有带来序列的改变，因此可以用一个函数来进行筛选

bool IsSwap(int a[], int length, int index)
{
    for(int i = index + 1; i < length; ++i)
        if(a[i] == a[index])
            return false;
    return true;
}
void permutation(int a[], int length, int index)
{
    int i = 0, j = 0, temp = 0;
    if(index == length)
    {
        for(i = 0; i < length; ++i)
        {
            printf("%d ", a[i]);
        }
        printf("
");
    }
    else
    {
        for(i = index; i < length; i++)
        {
            if(IsSwap(a, length, i))
            {
                temp = a[i];//将两个数进行交换
                a[i] = a[index];
                a[index] = temp;

                permutation(a, length, index + 1); //计算剩下 n-1 个数的全排列

                temp = a[i]; // 还原
                a[i] = a[index];
                a[index] = temp;
            }
        }
    }
}

输入：a[3] = {1,2,2}
输出：
1 2 2
2 2 1
2 1 2

• 解法2：非递归方法，字典序
  给定数组A[N]，那么使用字典序输出全排列的方法基本过程描述如下： (此方法建议手动执行几次，与上学时学排列时的写法一样)
  （1）将A按元素大小递增排序，形成字典序最小的排列；
  （2）左起从A[0]开始寻找最后一个元素A[k]，满足A[k]<A[k+1] (k<n−1)，n为元素个数;
  （3）从A[k+1]向右开始寻找最小的一个A[i]，使得A[i]>A[k];
  （4）交换A[k]与A[i]；
  （5）对于a[k+1，n-1]，反转该区间内元素的顺序，即a[k+1]与a[n]交换，a[k+2]与a[n-1]交换，……，这样就得到了a[1…n]在字典序中的下一个排列。
  （6）重复步骤（2）至（5），直到A按元素大小递减排序，即第二步找不到满足条件的A[k]。

总的来说字典序生成全排列的就是：先排序，再由后向前找第一个替换点，然后由向后向前找第一个比替换点所在元素大的数与替换点交换，最后颠倒替换点后的所有数据。

这里之所以都是从后向前寻找，因为可以提交效率。替换点后面的元素一定是递减排列的，所以只需要从后向前找第一个大于替换点所在的元素就行了。最后颠倒替换点后的所有数据也是让替换点后的数据排列成字典序最小的状态。
代码：

void permutation(int a[], int length)
{
    int sum  = 0;
    sort(a, a + length);
    int i = 0, j = 0, temp = 0;
    while(1)
    {
        bool flag = false;
        for(i = length -1; i > 0; i--)
        {
            if(a[i]>a[i-1])
            {
                flag = true;
                for(j = length -1; j >= i; j--)
                {
                    if(a[j] > a[i-1])
                        {
                            temp = a[j];
                            a[j] = a[i-1];
                            a[i-1] = temp;
                            break;
                        }
                }

                j = length-1;
                while(i <= j)
                {
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    i++;j--;
                }
                for(i = 0; i < length; i++)
                    {
                        printf("%d ", a[i]);
                    }
                    sum++;
                printf("
%d", sum);
             break;
            }
        }
        if(flag == false)
            return ;
    }

优点：
（1）使用迭代的方式，避免了递归实现的函数栈空间的大量消耗和函数调用的时间开销；
（2）无需考虑数组中出现的重复元素。

缺点：
（1）对数组的排序，增加了时间开销。其实这个可以优化，后面再说；
（2）每次寻找下一个排列时都要对替换点后的元素进行反转，这也增加了时间开销。

-----------------------------------------------------------------------------------------------------------------------------------------
47. Permutations II 　46. Permutations AC代码：

• 递归法：

class Solution {
public:
    vector<vector<int>> ans;
    bool IfSwap(vector<int>& nums, int index)
    {
        for(int i = index + 1; i < nums.size(); i++)
            if(nums[i] == nums[index])
                return false;
        return true;
    }
    void permutation(vector<int>& nums, int index) 
    {
        int i = 0, j = 0;
        int temp = 0;
        if(index == nums.size())
        {
            ans.push_back(nums);
        }
        else        
        for(i = index; i < nums.size(); i++)
        {
            if(IfSwap(nums, i))
            {
                temp = nums[i];
                nums[i] = nums[index];
                nums[index] = temp;
                
                permutation(nums, index+1);
                
                temp = nums[i];
                nums[i] = nums[index];
                nums[index] = temp;                                
            }
        }
    }
    vector<vector<int> > permute(vector<int>& nums)
    {
        permutation(nums, 0);
        return ans;
    }
};

• 字典序

    vector<vector<int> > permute(vector<int>& nums)
    {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());
        ans.push_back(nums);
        int i = 0,j = 0, temp = 0;
        while(1)
        {
        int flag = 0;
        for(i = nums.size() - 1; i > 0; --i)
        {
            if(nums[i] > nums[i-1])
            {
                flag = 1;
                for(j = nums.size()-1; j >= i; j--)
                {
                    if(nums[j]>nums[i-1])
                    {
                        temp = nums[j];
                        nums[j] = nums[i-1];
                        nums[i-1] = temp;
                        break;
                    }
                }
                j = nums.size()-1;
                while(i <= j)
                {
                    temp = nums[i];
                    nums[i] = nums[j];
                    nums[j] = temp;
                    i++;j--;
                }
                ans.push_back(nums);
                break;
            }
        }
    if(flag == 0)
        return ans;
    }
    }
};

以上：