題目描述

牛牛的作業薄上有一個長度為 n 的排列 A，這個排列包含了從1到n的n個數，但是因為一些原因，其中有一些位置（不超過 10 個）看不清了，但是牛牛記得這個數列順序對的數量是 k，順序對是指滿足 i < j 且 A[i] < A[j] 的對數，請幫助牛牛計算出，符合這個要求的合法排列的數目。

輸入描述:

每個輸入包含一個測試用例。每個測試用例的第一行包含兩個整數 n 和 k（1 <= n <= 100, 0 <= k <= 1000000000），接下來的 1 行，包含 n 個數字表示排列 A，其中等於0的項表示看不清的位置（不超過 10 個）。

輸出描述:

輸出一行表示合法的排列數目。

示例1

輸入

5 5
4 0 0 2 0

輸出

2

思路

首先，求出已有數列的順序對。 然後，將模糊的數字統計出來，並求出這些數字的全排列。 最後，迴圈遍歷模糊數列的排序，把模糊數列放在原數列上，求每個模糊數字在整個數列中產生的順序對。 關鍵：如何求全排列（需要遞迴的求出所有排列）

AC程式碼

import java.util.*;

/**
 * @Auther: ~
 * @Date: 2018/8/30 11:24
 * @Description: 數列還原 別人的思路 數列全排列的演算法看不懂就記住好了
 */
public class Main {
    public
 
 static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] ints = new int[n];
        //flag標記哪些數字已經存在
        boolean[] bl = new boolean[n + 1];
        for (int i = 0; i < n; i++) {
            ints[i] = scanner.nextInt();
            if
 
 (ints[i] != 0) {
                bl[ints[i]] = true;
            }
        }

        //統計排列中不存在的數字
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= n; i++) {
            if (bl[i] == false) {
                list.add(i);
            }
        }

        //perm用來存模糊數字的全排列
        List<ArrayList<Integer>> perm = new ArrayList<ArrayList<Integer>>();
        //計算perm
        calperm(perm, list, 0);

        //統計已有排列的順序對
        int cv = 0;
        for (int i = 0; i < n - 1; i++) {
            if (ints[i] != 0) {
                for (int j = i + 1; j < n; j++) {
                    if (ints[j] != 0 && ints[j] > ints[i]) {
                        cv++;
                    }
                }
            }
        }

        int res = 0;
        //計算每個模糊數字排列的順序對，如果與k相等，則結果res+1
        for (ArrayList<Integer> item : perm) {
            int val = cv;
            int[] temp = Arrays.copyOf(ints, n);
            val += calvalue(item, temp);
            if (val == k) {
                res++;
            }
        }
        System.out.println(res);
    }

    //計算排列的順序對
    static int calvalue(ArrayList<Integer> item, int[] temp) {
        int j=0;
        int val=0;
        for (int i=0;i<temp.length;i++){
            if(temp[i]==0){
                temp[i]= item.get(j++);
                for (int k=0;k<i;k++){
                    if(temp[k]<temp[i]){
                        val++;
                    }
                }
                for (int k=i+1;k<temp.length;k++){
                    if(temp[k]>temp[i]){
                        val++;
                    }
                }
            }
        }
        return val;
    }

    //計算全排列 記住好了
    public static void calperm(List<ArrayList<Integer>> perm, ArrayList<Integer> list, int n) {
        if (n == list.size()) {
            perm.add(new ArrayList<Integer>(list));
        } else {
            for (int i = n; i < list.size(); i++) {
                Collections.swap(list, i, n);
                calperm(perm, list, n + 1);
                Collections.swap(list, i, n);
            }
        }
    }
}