01_小Q的歌单

题目描述：小Q有X首长度为A的不同的歌和Y首长度为B的不同的歌，现在小Q想用这些歌组成一个总长度正好为K的歌单，每首歌最多只能在歌单中出现一次，在不考虑歌单内歌曲的先后顺序的情况下，请问有多少种组成歌单的方法。 

输入描述：

1.每个输入包含一个测试用例。
2.每个测试用例的第一行包含一个整数，表示歌单的总长度K(1<=K<=1000)。
接下来的一行包含四个正整数，分别表示歌的第一种长度A(A<=10)和数量X(X<=100)以及歌的第二种长度B(B<=10)和数量Y(Y<=100)。保证A不等于B。

输出描述：

输出一个整数,表示组成歌单的方法取模。因为答案可能会很大,输出对1000000007取模的结果。

示例1
输入
5
2 3 3 3
输出
9

解题思路：

1.令a*A+b*B=K（0≤a≤X，0≤b≤Y），获得集合（a,b）。

2.对每种集合都有C（X,a）*C（Y,b）种组合。

3.进行求和，得到组成歌单的方法数量。

难点：求C（n，k），n、k的范围是1~100，数据非常大，计算非常困难

因为C(n,k)=C(n-1,k-1)+C(n-1,k-1)，所以可以用动态规划，求组合数矩阵arr[i][j]表示从i中取j的种数，即C(i,j)，可以想象成最后一个加入的粒子有两种情况，分别计算，求和

	public static int[][] getCombineTable(int num){
		int[][] arrs = new int[num+1][num+1];
		arrs[0][0]=1;
		for(int i=1;i<=num;i++){
			arrs[i][0]=1;
			for(int j=1;j<=num;j++){
				arrs[i][j]=(arrs[i-1][j-1]+arrs[i-1][j])%1000000007;
			}
		}	
		return arrs;
	}

计算求和

	//计算组合数
	public static int countAllCombine(int K,int A,int X,int B,int Y){
		int res = 0;//总个组合数
		int[][] arrs = getCombineTable(Math.max(X, Y));
		for(int i = 0;i<=X;i++){
			if(A*i<=K&&(K-A*i)%B==0&&(K-A*i)/B<=Y){
				int r = (int) (((long)arrs[X][i]*arrs[Y][(K-A*i)/B])%1000000007);
				res = (res+r)%1000000007;
			}
		}
		return res;
	}

这里有一个坑，我们以为取1000000007的模，返回的是int的类型，但是在int类型相乘返回的是一个int类型，此时会溢出，所以可以把二维数组换成int[][]或者乘积提升为long

为了验证方法的正确性，提供方法二进行暴力求解

	//对数器
	public static long countAllCombineByComparator(int K,int A,int X,int B,int Y){
		long res = 0;//总个组合数
		for(int i = 0;i<=X;i++){
			if(A*i<=K&&(K-A*i)%B==0&&(K-A*i)/B<=Y){
				BigInteger a = getCombineCount(X,i);
				BigInteger b = getCombineCount(Y,(K-A*i)/B);
				a = a.multiply(b);
				a = a.add(BigInteger.valueOf(res));
				a= a.remainder(BigInteger.valueOf(1000000007));
				
				res =Long.parseLong(a.toString());
			}
		}
		return res;
	}
	
	//暴力求解C(a,b),表示从a中取b的组合数
	public static BigInteger getCombineCount(int a,int b){
		BigInteger res = BigInteger.valueOf(1);
		BigInteger  aa =  BigInteger.valueOf(1);
		for(int i=a;i>0;i--){
			if(i>b){
				res = res.multiply(BigInteger.valueOf(i));
			}
			if(i<=(a-b)){
				aa = aa.multiply(BigInteger.valueOf(i));
			}
		}
		res = res.divide(aa);
		return res.remainder(BigInteger.valueOf(1000000007));
	}
	

主函数生成随机输入进行测试

	public static void main(String[] args) {	
		//生成二维数组
		for(int i=0;i<10000;i++){
			int K = (int) (Math.random()*999)+1;//[1,1000]
			int A = (int) (Math.random()*9)+1;//[1,10]
			int X = (int) (Math.random()*100);//[0,100]
			int B = (int) (Math.random()*9)+1;//[1,10]
			int Y = (int) (Math.random()*100);//[0,100]
			long a = countAllCombine(K,A,X,B,Y);
			long b = countAllCombineByComparator(K,A,X,B,Y);
			if(a!=b){//对比两种方法的输出结果
				System.out.println("Fuck");
				System.out.println(K);
				System.out.println(A+ " "+X+" "+B+" "+Y);
				System.out.println("a:"+a+"\tb:"+b);
				return;
			}
		}
		System.out.println("Success");
	}

总结：

1.问题核心是计算C(n,k)组合数

传统计算C(n,k)=n!/(k!*(n-k)!)，分析法或数学归纳法可证明C(n,k)=C(n-1,k-1)+C(n-1,k)

2.关键是int、long数值范围，和数据溢出导致不能AC。数据溢出:当最大值加上 1 时，结果反而变成表示范围中最小的值

byte 二进制位数：8，最小值：Byte.MIN_VALUE=-128，最大值：Byte.MAX_VALUE=127

short 二进制位数：16，最小值：Short.MIN_VALUE=-32768，最大值：Short.MAX_VALUE=32767

int 二进制位数：32，最小值：Integer.MIN_VALUE=-2147483648，最大值：Integer.MAX_VALUE=2147483647

long 二进制位数：64，最小值：Long.MIN_VALUE=-9223372036854775808，最大值：Long.MAX_VALUE=9223372036854775807

float 二进制位数：32，最小值：Float.MIN_VALUE=1.4E-45，最大值：Float.MAX_VALUE=3.4028235E38

double 二进制位数：64，最小值：Double.MIN_VALUE=4.9E-324，最大值：Double.MAX_VALUE=1.7976931348623157E308

char 二进制位数：16，最小值：Character.MIN_VALUE=0，最大值：Character.MAX_VALUE=65535

3.考点，Java基本类型转换

（1）向上自动提升

（2）向下强制装换

（3）数据计算结果随大的类型转换，比如int*long自动转换为long

4.BigInteger的使用

https://blog.youkuaiyun.com/qfikh/article/details/52832196

Java中使用的大整数类型，只要内存够，可以自动扩展

5.Math.Random()用法，返回[0,1)半封闭区间随机数