next-permutation-ii&&permutation-index-ii

1、下一个排列

给定一个若干整数的排列，给出按正数大小进行字典序从小到大排序后的下一个排列。

如果没有下一个排列，则输出字典序最小的序列。

样例

左边是原始排列，右边是对应的下一个排列。

1,2,3 → 1,3,2

3,2,1 → 1,2,3

1,1,5 → 1,5,1

挑战

不允许使用额外的空间。

不得不吐槽，我竟然花了一个多小时来写这道题，为什么呢？因为首先不知道如何去找下一个排列，想了好久，其中有两个不完全正确的算法指导我分别卡在了28%和49%。。。然后手懒的我为了省力气少编写一个函数，选择了C++，深深的被C++的return教训了一番。

算法：这道题据说也是经典面试题目之一。本质都是字典排序的变形。

字典序法的描述如下：

        设P是1～n的一个全排列:p=p[1]p[2]......p[n]=p[1]p[2]......p[j-1]p[j]p[j+1]......pn
      1）从排列的右端(n)开始，找出第一个比相邻右边字符小的字符的序号j（j从左端开始计算），即 j=max{i|p[i]<p[i+1]}
      2）在p[j]的右边的字符中，找出所有比p[j]大的字符中最小的字符p[k]，即从右端开始的第一个比p[j]大的； （右边的字符从右至左是递增的，因此k是所有大于pj的字符中序号最大者）
      3）对换pj，pk
      4）再将pj+1......pk-1pkpk+1pn倒转得到排列p''=p1p2.....pj-1pjpn.....pk+1pkpk-1.....pj+1，这就是排列p的下一个下一个排列。

class Solution {
public:
    /**
     * @param nums: a vector of integers
     * @return: return nothing (void), do not return anything, modify nums in-place instead
     */
    void nextPermutation(vector<int> &nums) {
        // write your code here
        int len = nums.size();
        int i=len-1;
        while (i>0 && nums[i-1]>=nums[i]){
            i--;
        }
        if (i == 0)  {
            reverse(nums.begin(),nums.end());
            return;
        }
        for(int j = len-1;j>i-1;j--){
            if(nums[i-1]<nums[j]){
                int temp = nums[i-1];
                nums[i-1]=nums[j];
                nums[j]=temp;
                reverse(nums.begin()+i,nums.end());
                return;
            }
        }
    }
};

好吧，我为了省事利用C++中的reverse函数，可是我竟然不知道C++中的无返回的retrun相当于break，随便添加return 的人华丽丽的调试了10多分钟。

2、排列序号II

给出一个可能包含重复数字的排列，求这些数字的所有排列按字典序排序后该排列在其中的编号。编号从1开始。

样例

给出排列[1, 4, 2, 2]，其编号为3。

public class Solution {
    /**
     * @param A
     *            an integer array
     * @return a long integer
     */
    long fac(int numerator) {
            
        long now = 1;
        for (int i = 1; i <= numerator; i++) {
            now *= (long) i;
        }
        return now;
    }
    long generateNum(HashMap<Integer, Integer> hash) {
        long denominator = 1;
        int sum = 0;
        for (int val : hash.values()) {
            if(val == 0 )    
                continue;
            denominator *= fac(val);
            sum += val;
        }
        if(sum==0) {
            return sum;
        }
        return fac(sum) / denominator;
    }

    public long permutationIndexII(int[] A) {
        HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
        
        for (int i = 0; i < A.length; i++) {
            if (hash.containsKey(A[i]))
                hash.put(A[i], hash.get(A[i]) + 1);
            else {
                hash.put(A[i], 1);
            }
        }
        long ans = 0;
        for (int i = 0; i < A.length; i++) {
            HashMap<Integer, Integer> flag = new HashMap<Integer, Integer>();
            
            for (int j = i + 1; j < A.length; j++) {
                if (A[j] < A[i] && !flag.containsKey(A[j])) {
                        flag.put(A[j], 1);
                
                    hash.put(A[j], hash.get(A[j])-1);
                    ans += generateNum(hash);
                    hash.put(A[j], hash.get(A[j])+1);
                    
                }
            
            }
                hash.put(A[i], hash.get(A[i])-1);
        }
        
        return ans+1;

    }
}