Java 如何从该程序的运行时间中节省0.1秒？

我在InterviewStreet做一个实践项目，我有一个解决方案，运行时间为5.15xx秒，而java解决方案允许的最长时间为5秒。我能用这里的东西做些什么，让它在5秒钟内完成吗？还有一个256 MB的限制，所以我可以说这是最节省时间和内存的解决方案

编辑： N和K的可能值为N）{ 返回biginger.ZERO； } 如果（r>n/2）{ r=n-r； } BigInteger结果=BigInteger.ONE； 对于（int i=0；i=3）{ r[x]=（（p.nCr（N[x]-3，K[x]）。乘（p.nCr（N[x]+K[x]，N[x]-1））。除（BigInteger.valueOf（（N[x]+K[x]））。模（m））。intValue（）； }否则{ r[x]=0； } x++； } x=0； while（x

---

}

不完全确定该算法试图实现什么，但根据您对文章的标记，我猜测一些具有二项式系数的东西

您需要检查我的建议是否修改了结果，但看起来您可以合并两个while循环：

原件：

while (x < T) {
    N[x] = input.nextInt();
    K[x] = input.nextInt();
    x++;
}

x = 0;
while (x < T) {
if (N[x] >= 3) { 
        r[x] = ((p.nCr(N[x] - 3, K[x]).multiply(p.nCr(N[x] + K[x], N[x] - 1))).divide(BigInteger.valueOf((N[x] + K[x]))).mod(m)).intValue();
    } else {
        r[x] = 0;
    }
    x++;
}

while（x=3）{
r[x]=（（p.nCr（N[x]-3，K[x]）。乘（p.nCr（N[x]+K[x]，N[x]-1））。除（BigInteger.valueOf（（N[x]+K[x]））。模（m））。intValue（）；
}否则{
r[x]=0；
}
x++；
}

新的：

x=0；
while（x=3）{
r[x]=（（p.nCr（N[x]-3，K[x]）。乘（p.nCr（N[x]+K[x]，N[x]-1））。除（BigInteger.valueOf（（N[x]+K[x]））。模（m））。intValue（）；
}否则{
r[x]=0；
}
x++；
}

尝试使用profilerm运行，例如jvisualvm，并使用

-Dcom.sun.management.jmxremote

---

附加到进程并启动配置文件。

您试图解决的问题是什么？是否可以使用Long而不是BigInteger？在速度更快的计算机上运行。提示，而不是解决方案：在转到

biginger

之前，尽可能多地使用

long

s进行数学运算。网站会在5秒后终止该程序，因此即使它永远运行，它也会打印5.1秒左右的内容。i、 e.我怀疑您需要将其速度提高到.1秒以上。此外，

N

和

K

数组被索引为多次。也许每个循环将

N[x]

和

K[x]

值设置为局部变量一次并替换

r[x]=

语句中的用法可以节省几毫秒。

import java.math.BigInteger;
import java.util.Scanner;

public class Solution {

public BigInteger nCr(int n, int r) {
    if (r > n ) {
        return BigInteger.ZERO;
    }

    if (r > n / 2) {
        r = n - r;
    }
    BigInteger result = BigInteger.ONE;

    for (int i = 0; i < r; i++) {
        result = result.multiply(BigInteger.valueOf(n - i));
        result = result.divide(BigInteger.valueOf(i + 1));
    }
    return result;
}

public static void main(String[] args) {
    Scanner input = new Scanner( System.in );
    BigInteger m = BigInteger.valueOf(1000003);
    Solution p = new Solution();
    short T = input.nextShort(); // Number of trials
    BigInteger intermediate = BigInteger.ONE;
    int[] r = new int[T];
    int[] N = new int[T];
    int[] K = new int[T];

    short x = 0;

    while (x < T) {
    N[x] = input.nextInt();
    K[x] = input.nextInt();
    x++;
    }

    x = 0;
    while (x < T) {
    if (N[x] >= 3) { 
            r[x] = ((p.nCr(N[x] - 3, K[x]).multiply(p.nCr(N[x] + K[x], N[x] - 1))).divide(BigInteger.valueOf((N[x] + K[x]))).mod(m)).intValue();
        } else {
            r[x] = 0;
    }
    x++;
    }

    x = 0;
    while (x < T) {
    System.out.println(r[x]);
    x++;
    }
}

while (x < T) {
    N[x] = input.nextInt();
    K[x] = input.nextInt();
    x++;
}

x = 0;
while (x < T) {
if (N[x] >= 3) { 
        r[x] = ((p.nCr(N[x] - 3, K[x]).multiply(p.nCr(N[x] + K[x], N[x] - 1))).divide(BigInteger.valueOf((N[x] + K[x]))).mod(m)).intValue();
    } else {
        r[x] = 0;
    }
    x++;
}

x = 0;
while (x < T) {

//this has been moved from your first while loop
N[x] = input.nextInt();
K[x] = input.nextInt();

if (N[x] >= 3) { 
        r[x] = ((p.nCr(N[x] - 3, K[x]).multiply(p.nCr(N[x] + K[x], N[x] - 1))).divide(BigInteger.valueOf((N[x] + K[x]))).mod(m)).intValue();
    } else {
        r[x] = 0;
    }
    x++;
}