面試：如何找出字符串的字典序全排列的第N種

1.題目

如何找出字符串的字典序全排列的第N種？（字符串全排列的變種）

2.思路

主要想通過這題，介紹一下康托展開式。基於康托展開式可以解決這個問題。

一般的解法：①求出所有全排列 ②按照字典序排個序 ③取第N個

3.康托展開與逆展開

康托展開是一個全排列到一個自然數的雙射，常用於構建哈希表時的空間壓縮。 康托展開的實質是計算當前排列在所有由小到大全排列中的順序，因此是可逆的。（引用）

3.1公式
X=a[n]*(n-1)!+a[n-1]*(n-2)!+…+a[i]*(i-1)!+…+a[1]*0!

其中,a[i]為整數,並且0<=a[i]<i,1<=i<=n。

a[i]的意義參見舉例中的解釋部分

3.2舉例
例如，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!

偽代碼實現

① Cantor(A, n) 求一個字符數組的康托值

Cantor(A, n)
for i←0 to n-1
    result ← result + Less(A[i]) * F[i]
return result

定義：

• A：待求康托值的字符數組
• n：字符數組長度，如公式中的n
• F：階乘的結果集，如公式中(n-1)!、i!、2!、1!、0!
• Less：函數，求比自己小的數的個數，如公式中的a[i]的意義

②Less(n, set) 求比自己小的數的個數，公式中a[i]

Less(n, set)
for(m : set )
    if m < n
        count ← count+1
add(set, n)
return n - count -1

定義：

• n：待求比自己小的數
• set：存放已經出現過的數
• count：比3小的數有1,2，如果1,2在set中出現了，count就計數這個。
• 返回值：-1的目的是為了得到a[i]

3.3用途

顯然，n位（0~n-1）全排列后，其康托展開唯一且最大約為n!，因此可以由更小的空間來儲存這些排列。由公式可將X逆推出對應的全排列。

3.4康托展開的逆運算
既然康托展開是一個雙射，那么一定可以通過康托展開值求出原排列，即可以求出n的全排列中第x大排列。

如n=5,x=96時：

1. 首先用96-1得到95，說明x之前有95個排列.(將此數本身減去！)
2. 用95去除4! 得到3余23，說明有3個數比第1位小，所以第一位是4.
3. 用23去除3! 得到3余5，說明有3個數比第2位小，所以是4，但是4已出現過，因此是5.
4. 用5去除2!得到2余1，類似地，這一位是3.
5. 用1去除1!得到1余0，這一位是2.
6. 最后一位只能是1.
7. 所以這個數是45321.

偽代碼實現

①ResolveCantor(A, X, n)：給第X種，求該全排列n的字符串

ResolveCantor(A, X, n)
for i←0 to n-1
    a ← X div F[i]
    b ← X mod F[i]
    A[i] ← Solve(a, visit)
    X ← b
return A

定義：

• A：存儲字符串的結果
• X：字典序全排列的X種（0,1,2,3,...），這個值是康托值
• n：字符數組長度，如康托公式中的n
• F：階乘的結果集，如公式中(n-1)!、i!、2!、1!、0!
• Solve：函數，求某個輸出字符

②Solve(a, visit)：求某個輸出字符

Solve(a, visit)
while a is visited
    a← a+1
    see a is visited or not
return a +1

定義：

• a：康托公式中的a[i]
• visit：boolean數組，visit[a]表示a是否已經出現過了。
• 返回值：+1 為了構建出輸出字符

如果用這個算法去求字符串的全排列，時間復雜度是O(n³)，優於遞歸算法的O(n!)。

3.5 Java代碼實現

為了實現簡單一些，實現部分采用的是int數組。

import java.util.HashSet;
import java.util.Set;

public class Cantor {

    public static final int LEN = 3;
    private static int[] f = new int[LEN];
    private static Set<Integer> set = new HashSet<Integer>();
    private static boolean[] visit = new boolean[LEN];

    static {
        int re = 1;
        for (int i = 1; i < LEN; i++) {
            re *= i;
            f[LEN - 1 - i] = re;
        }
        f[LEN - 1] = 1;
        for (int i = 0; i < LEN; i++) {
            visit[i] = false;
        }
        System.out.println("F[0]: " + f[0]);
    }

    public static void main(String[] args) {
        int[] a = { 2, 1, 3 };
        int n = a.length;
        int x = cantor(a, n);
        String str = "";
        for (int i = 0; i < n; i++) {
            str += "" + a[i];
        }
        System.out.println("src String: " + str);
        System.out.println("cantor value: " + x);
        int[] b = new int[LEN];
        resolveCantor(b, x, n);
        str = "";
        for (int i = 0; i < n; i++) {
            str += "" + b[i];
        }
        System.out.println("resolve cantor str: " + str);
    }

    static int cantor(int[] a, int n) {
        int result = 0;
        for (int i = 0; i < n; i++) {
            result += less(a[i]) * f[i];
        }
        return result;
    }

    private static int less(int n) {
        int count = 0;
        for (Integer m : set) {
            if (m < n)
                count++;
        }
        set.add(n);
        return n - count - 1;
    }

    static int[] resolveCantor(int[] arr, int x, int n) {
        int a, b;
        for (int i = 0; i < n; i++) {
            a = x / f[i];
            b = x % f[i];
            arr[i] = solve(a);
            System.out.println("a: " + a + " b: " + b + " arr[i]: " + arr[i]);
            x = b;
        }
        return arr;
    }

    private static int solve(int a) {
        boolean flag = true;
        while (flag) {
            if (visit[a] == false) {
                visit[a] = true;
                flag = false;
            } else {
                a++;
            }
        }
        return a + 1;
    }
}