leetcode Next Permutation

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

原理讲的比较清楚的参见博客： http://www.cnblogs.com/devymex/archive/2010/08/17/1801122.html

概念

全排列的生成算法有很多种，有递归遍例，也有循环移位法等等。C++/STL中定义的next_permutation和 prev_permutation函数则是非常灵活且高效的一种方法，它被广泛的应用于为指定序列生成不同的排列。本文将详细的介绍 prev_permutation函数的内部算法。

按照STL文档的描述，next_permutation函数将按字母表顺序生成给定序列的下一个较大的序列，直到整个序列为减序为止。 prev_permutation函数与之相反，是生成给定序列的上一个较小的序列。二者原理相同，仅遍例顺序相反，这里仅以 next_permutation为例介绍算法。

下文内容都基于一个假设，即序列中不存在相同元素。对序列大小的比较做出定义：两个长度相同的序列，从两者的第一个元素开始向后比较，直到出现一个不同元素（也可能就是第它们的第一个元素），该元素较大的序列为大，反之序列为小；若一直到最后一个元素都相同，那么两个序列相等。

设当前序列为p_n，下一个较大的序列为p_n+1，那么不存在p_m，使得p_n < p_m < p_n+1。

问题

给定任意非空序列，生成下一个较大或较小的序列。

数学推导

根据上述概念易知，对于一个任意序列，最小的序列是增序，最大的序列为减序。那么给定一个p_n要如何才能生成p_n+1呢？先来看下面的例子：

我们用<a₁ a₂ ... a_m>来表示m个数的一种序列。设序列p_n=<3 6 4 2>，根据定义可算得下一个序列p_n+1=<4 2 3 6>。观察p_n可以发现，其子序列<6 4 2>已经为减序，那么这个子序列不可能通过交换元素位置得出更大的序列了，因此必须移动最高位3（即a₁）的位置，且要在子序列<6 4 2>中找一个数来取代3的位置。子序列<6 4 2>中6和4都比3大，但6大于4。如果用6去替换3得到的序列一定会大于4替换3得到的序列，因此只能选4。将4和3的位置对调后形成排列<4 6 3 2>。对调后得到的子序列<6 3 2>仍保持减序，即这3个数能够生成的最大的一种序列。而4是第1次作为首位的，需要右边的子序列最小，因此4右边的子序列应为<2 3 6>，这样就得到了正确的一个序列p_n+1=<4 2 3 6>。

下面归纳分析该过程。假设一个有m个元素的序列p_n，其下一个较大序列为p_n+1。

1) 若p_n最右端的2个元素构成一个增序子序列，那么直接反转这2个元素使该子序列成为减序，即可得到p_n+1。

2) 若p_n最右端一共有连续的s个元素构成一个减序子序列，令i = m - s，则有p_n(i) < p_n(i+1)，其中p_n(i)表示排列p_n的第i个元素。例如p_n=<1 2 5 4 3>，那么p_n的右端最多有3个元素构成一个减序子集<5 4 3>，i=5-3=2，则有p_n(i)=2 < 5=p_n(i+1)。因此若将p_n(i)和其右边的子集s {p_n(i+1), p_n(i+2), ..., p_n(m)}中任意一个元素调换必能得到一个较大的序列（不一定是下一个）。要保证是下一个较大的序列，必须保持p_n(i)左边的元素不动，并在子集s {p_n(i+1), p_n(i+2), ..., p_n(m)}中找出所有比p_n(i)大的元素中最小的一个p_n(j)，即不存在p_n(k) ∈ s且p_n(i) < p_n(k) < p_n(j)，然后将二者调换位置。现在只要使新子集{p_n(i+1), p_n(i+2), ..., p_n(i), ...,p_n(m)}成为最小序列即得到p_n+1。注意到新子集仍保持减序，那么此时直接将其反转即可得到p_n+1 {p_n(1), p_n(2), ..., p_n(j), p_n(m), p_n(m-1), ..., p_n(i), ..., p_n(i+2), p_n(i+1)}。

复杂度

最好的情况为p_n的最右边的2个元素构成一个最小的增序子集，交换次数为1，复杂度为O(1)，最差的情况为1个元素最小，而右面的所有元素构成减序子集，这样需要先将第1个元素换到最右，然后反转右面的所有元素。交换次数为1+(n-1)/2，复杂度为O(n)。因为各种排列等可能出现，所以平均复杂度即为O(n)。

扩展

1. 能否直接算出集合{1, 2, ..., m}的第n个排列？

设某个集合{a₁, a₂, ..., a_m}（a₁<a₂<...<a_m）构成的某种序列p_n，基于以上分析易证得：若a_s<a_t，那么将a_s作为第1个元素的所有序列一定都小于a_t作为第1个元素的任意序列。同理可证得：第1个元素确定后，剩下的元素中若a_s'<a_t'，那么将a_s'作为第2个元素的所有序列一定都小于作为第2个元素的任意序列。例如4个数的集合{2, 3, 4, 6}构成的序列中，以3作为第1个元素的序列一定小于以4或6作为第1个元素的序列；3作为第1个元素的前题下，2作为第2个元素的序列一定小于以4或6 作为第2个元素的序列。

推广可知，在确定前i（i<n）个元素后，在剩下的m-i=s个元素的集合{a_q1, a_q2, ..., a_q3}（a_q1<a_q2<...<a_qm）中，以a_qj作为第i+1个元素的序列一定小于以a_qj+1作为第i+1个元素的序列。由此可知：在确定前i个元素后，一共可生成s!种连续大小的序列。

根据以上分析，对于给定的n（必有n<=m!）可以从第1位开始向右逐位地确定每一位元素。在第1位不变的前题下，后面m-1位一共可以生成(m-1)!中连续大小的序列。若n>(m-1)!，则第1位不会是a₁，n中可以容纳x个(m-1)!即代表第1位是a_x。在确定第1位后，将第1位从原集合中删除，得到新的集合{a_q1, a_q2, ..., a_q3}（a_q1<a_q2<...<a_qm），然后令n₁=n-x(m-1)!，求这m-1个数中生成的第n₁个序列的第1位。

举例说明：如7个数的集合为{1, 2, 3, 4, 5, 6, 7}，要求出第n=1654个排列。

(1654 / 6!)取整得2，确定第1位为3，剩下的6个数{1, 2, 4, 5, 6, 7}，求第1654 % 6!=214个序列；

(214 / 5!)取整得1，确定第2位为2，剩下5个数{1, 4, 5, 6, 7}，求第214 % 5!=94个序列；

(94 / 4!)取整得3，确定第3位为6，剩下4个数{1, 4, 5, 7}，求第94 % 4!=22个序列；

(22 / 3!)取整得3，确定第4位为7，剩下3个数{1, 4, 5}，求第22 % 3!=4个序列；

(4 / 2!)得2，确定第5为5，剩下2个数{1, 4}；由于4 % 2!=0，故第6位和第7位为增序<1 4>；

因此所有排列为：3267514。

2. 给定一种排列，如何算出这是第几个排列呢？

和前一个问题的推导过程相反。例如3267514：

后6位的全排列为6!，3为{1, 2, 3 ,4 , 5, 6, 7}中第2个元素（从0开始计数），故2*720=1440；

后5位的全排列为5!，2为{1, 2, 4, 5, 6, 7}中第1个元素，故1*5!=120；

后4位的全排列为4!，6为{1, 4, 5, 6, 7}中第3个元素，故3*4!=72；

后3位的全排列为3!，7为{1, 4, 5, 7}中第3个元素，故3*3!=18；

后2位的全排列为2!，5为{1, 4, 5}中第2个元素，故2*2!=4；

最后2位为增序，因此计数0，求和得：1440+120+72+18+4=1654

下面是我用java实现的版本：

public class Solution4 {

    /**
     * Next Permutation
     * @param nums
     */
    public void nextPermutation(int[] nums) {
        if(nums.length<=1)
            return;
        int i = nums.length-1;
        
        while(i>0){            
            if(nums[i]>nums[i-1]){                
                break;
            }                
            else 
                i--;
        }
        quickSort(nums,i,nums.length-1);
        if(i == 0)
            return;
        int j = i-1;
        while(i<nums.length&&nums[j]>=nums[i])
            i++;
        /**
         * 5,1,1
         */
        if(i==nums.length)
            i--;
        swap(nums, j, i);
    }

    public void quickSort(int[] num,int x,int y){
        if(x>=y)
            return;
        int q = partition(num,x,y);  
        swap(num,q,y);
        
        quickSort(num, x, q-1);
        quickSort(num, q+1, y);
    }
    /**快排
     * 注意先给p-1，这样就不需要后续交换的时候多个步骤
     * @param num
     * @param p
     * @param r
     * @return
     */
    public int partition(int[] num,int p ,int r ){
        int pivotIndex = (p+r)/2;
        swap(num, pivotIndex, r);
        int pivot = num[r];
        p--;
        do{
            while(num[++p]<pivot);
            while(r>0&&num[--r]>pivot);        
            swap(num, p, r);
        }while(p<r);
        swap(num, p, r);
        return p;
    }
    /**
     * 一定要判断两个元素是否相等，不然会更新为0
     * @param ints
     * @param x
     * @param y
     */
    public  void swap(int[] ints, int x, int y) {
        if(x==y)
            return;
        ints[x] = ints[x]^ints[y];
        ints[y] = ints[x]^ints[y];
        ints[x] = ints[x]^ints[y];        
    }  
    public static void main(String[] args) {
        int[] a = {1,1};
        Solution4 so = new Solution4();
        so.nextPermutation(a);        
        
        for(int i = 0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }

}

View Code