排列序号

排列序号

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

思路：

这个问题是一个组合数学问题，如果知道 康托展开，那么好理解一点。但是绝大部分人应该都不知道康托展开。对于这道题，有高中数学基础也就够了，为了便于描述，这里给康托展开的描述，我来解释原因。

3 5 7 4 1 2 9 6 8 展开为 98884
X=2*8!+3*7!+4*6!+2*5!+0*4!+0*3!+2*2!+0*1!+0*0!=98884. 解释：
排列的第一位是3，比3小的数有两个，以这样的数开始的排列有8!个，因此第一项为2*8!
排列的第二位是5，比5小的数有1、2、3、4，由于3已经出现，因此共有3个比5小的数，这样的排列有7!个，因此第二项为3*7!
以此类推，直至0*0!
那么3 5 7 4 1 2 9 6 8 为第98885个排列。
我解释下，第一位为3，在其后面比3小的数有2个，说明这两个元素都可以与其交换，构成这个排列之前的排列，而交换后，3后面有8个空位，所以这8个空位所以排列都可以，为全排列8！，这就是康拓展开的原因。所以把所有位的count* 后面元素个数的阶乘累加就是该排列前面的排列。

public class Solution {
    /**
     * @param A an integer array
     * @return a long integer
     */
    public long permutationIndex(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return 0;
        }
        long res = 0;
        long fact = 1;
        for (int i = A.length - 1; i >= 0; i--) {
            int rank = 0;
            for (int j = i + 1; j < A.length; j++) {
                if (A[i] > A[j]) {
                    rank++;
                }
            }
            res += rank * fact;
            fact *= A.length - i;
        }
        return res + 1;
    }
}

排列序号II

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

基本思路

思路和第一种排列差不多，不过由于有重复元素，那么计算到某位时，它后面有重复元素的话，除以重复元素个数的阶乘就可以了(因为有重复元素个数的阶乘这么多种情况视为一种情况)

public class Solution {
    /**
     * @param A an integer array
     * @return a long integer
     */
    public long permutationIndexII(int[] A) {
        // Write your code here
        long res = 0;
        long fact = 1;
        long dup = 1;
        if (A == null || A.length == 0) {
            return 0;
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = A.length - 1; i >= 0; i--) {
            if (!map.containsKey(A[i])){
                map.put(A[i], 1);
            } else {
                map.put(A[i], map.get(A[i]) + 1);
                dup *= map.get(A[i]);
            }
            int rank = 0;
            for (int j = i + 1; j < A.length; j++) {
                if (A[i] > A[j]) {
                    rank++;
                }
            }
            res += rank * fact / dup;
            fact *= A.length - i;

        }
        return res + 1;

    }
}

转载地址：http://blog.csdn.net/u012280578/article/details/72510283