牛牛的作业薄上有一个长度为 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的顺序对+新插入的数字产生的顺序对.
首先,顺序对的个数互不影响。也就是说,对于数组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);
}
}
}
}