面试题：数列还原（网易笔试17）

牛牛的作业薄上有一个长度为 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 个）。

输出描述:
输出一行表示合法的排列数目。

输入例子:
5 5
4 0 0 2 0

输出例子:

2

思路：

先统计哪些数没出现，哪些位置缺少数值。

然后考虑计算。

10!=3628800

如果是每种排列还暴力计算（~100*100），这不行，太慢了

考虑预先计算一部分。

总顺序对数=已经填进去的数之间的顺序对数+没有填进去的数之间的顺序对数+已经填进去和没有填进去的数之间的顺序对数

第一部分：预先算一遍就好了

第二部分：只有10*10，暴力计算

第三部分：预先处理，每个数填在空位上，和其他预先填进去的数组成的顺序对数

三部分相加，判断等不等于k就行。

计算量？

10*10+10，也就110

2：
首先，顺序对的个数互不影响。也就是说，对于数组A来说，增加（插入）一个数字，其A的顺序对个数不变，所以新数组A+1的顺序对个数=数组A的顺序对+新插入的数字产生的顺序对.

进而推广到，增加c个数字，新数组A+c的顺序对=数组A的顺序对+数组c的顺序对+每个新插入的数字产生顺序对（共c个数字）。

所以，1）首先计算已经给出的数字共有arrbase个顺序对；

2）然后计算缺失的数字共有canbase个顺序对；

3）最后计算每个缺失的数字产生的顺序对；

对于2,3步骤，可以将缺失的数字（数组）进行全排列。

思路比较简单：
1，找出缺失的数字；
2，缺失数字全排列
3，填充得到全数组
4，获取合题意的方案数

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 
public class Main{
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int RES = 0;
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] A = new int[n];
            boolean[] flag = new boolean[n+1];
            //flag标记哪些数字已经存在
            for(int i=0;i<n;i++){
                A[i] = sc.nextInt();
                if(A[i] != 0){
                    flag[A[i]] = true;
                }
            }
             
            //统计排列中不存在的数字
            ArrayList<Integer> list = new ArrayList<Integer>();
            for(int i=1;i<=n;i++){
                if(flag[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;i++){
                if(A[i]!= 0){
                    for(int j=i+1;j<n;j++){
                        if(A[j] != 0 && A[i] < A[j])
                            cv++;
                    }
                }
            }
             
            //计算每个模糊数字排列的顺序对，如果与k相等，则结果RES加一
            for(ArrayList<Integer> tmp : perm){
                int val = cv;
                int[] tmpA = Arrays.copyOf(A, n);
                val += calvalue(tmp, tmpA);
                if(val == k)
                    RES++;
            }
             
            System.out.println(RES);
        }
    }
     
    //计算排列的顺序对
    public static int calvalue(List<Integer> list, int[] A){
        int val = 0;
        int j = 0;
        for(int i=0;i<A.length;i++){
            if(A[i] == 0){
                A[i] = list.get(j++);
                for(int k = 0;k<i;k++){
                    if(A[k]!=0 && A[k]<A[i])
                        val++;
                }
                for(int k=i+1;k<A.length;k++){
                    if(A[k]!=0 && A[k]>A[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);
            }
        }
    }
}