Question

这些天我自己在学习java。此功能用于计算组合。但是，我发现此函数中的数字n和k的限制非常小。每次如果我输入一个大的n或k，例如100，它就会给我

Exception in thread "main" java.lang.ArithmeticException: / by zero
at Combination.combination(Combination.java:29)
at Combination.main(Combination.java:47)

或者给我一个负数......

有没有办法让它适用于像10000这样的大数字？

谢谢！

import java.util.HashMap; import java.util.Map;

public class Combination {

private Map<Long,Long> factorialMap = new HashMap<Long,Long>();

public Long getFactorial(int number) {
    Long val = factorialMap.get(number);
    if(val != null) {
        return val;
    } else {
        val = getFactorialRecursive(number);
        factorialMap.put((long) number, val);
        return val;
    }
}

public Long getFactorialRecursive(int number) {
    if(number == 1 || number == 0) {
        return 1L;
    } else {
        return number * getFactorialRecursive(number-1);
    }
}

public Long combination(int fromVal, int chooseVal) {
    return getFactorial(fromVal)/(getFactorial(chooseVal)*getFactorial(fromVal-chooseVal));
}


public static void main(String[] args) {
    int   n, k;
    Combination comb = new Combination();
    java.util.Scanner console = new java.util.Scanner(System.in);

    while (true)  // will break with k > n or illegal k or n
    {  System.out.print ("Value for n:  ");
       n = console.nextInt();
       if ( n < 0 ) break;
       System.out.print ("Value for k:  ");
       k = console.nextInt();;
       if ( k > n || k < 0 )
          break;
       System.out.print(n +" choose " + k + " = ");
       System.out.println(comb.combination(n,k));
    }
    console.nextLine();    // Set up for "Press ENTER...


} }

Answer 1

您应该使用BigInteger对象：http://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html

特别是，你的问题是21！太长了太长，因此溢出。另一个选择是使用double，但这会失去精度，所以如果你需要整数精度，BigInteger是可行的方法。

使用BigInteger，您需要将整数转换为BigInteger：

BigInteger bi = new BigInteger(intVal+"");

然后使用add，multiply，divide和subtract（以及其他）来操纵您的值（例如）：

bi = bi.add(bi2);

然后你可以使用方法longValue()来获取值（假设它适合长）：

return bi.longValue();

Answer 2

我建议您考虑默认情况下Java不会超过10,000次，而且您不需要首先计算这么大的因子。

e.g。 1000！/ 999！是1000

如果使用循环，可以提前停止。

public static BigInteger combination(int n, int r) {
    if (r * 2 > n) r = n - r;
    BigInteger num = BigInteger.ONE;
    BigInteger nr = BigInteger.valueOf(n - r);
    for (int i = n; i > r; i--) {
        num = num.multiply(BigInteger.valueOf(i));
        while (nr.compareTo(BigInteger.ONE) > 0 && num.mod(nr).equals(BigInteger.ZERO)) {
            num = num.divide(nr);
            nr = nr.subtract(BigInteger.ONE);
        }
    }
    while (nr.compareTo(BigInteger.ONE) > 0) {
        num = num.divide(nr);
        nr = nr.subtract(BigInteger.ONE);
    }
    return num;
}

顺便说一下，当我的意思是使用Long效率较低时，我不会使用long。

为了比较，我使用long包含了相同的代码。

public static long combination2(int n, int r) {
    if (r * 2 > n) r = n - r;
    long num = 1;
    int nr = n - r;
    for (int i = n; i > r; i--) {
        num *= i;
        while (nr > 1 && num % nr == 0) {
            num /= nr--;
        }
    }
    while (nr > 1)
        num /= nr--;
    return num;
}

Java组合函数具有较小的数量限制。如何使用数学Big int？

2 个答案: