Java 优化大输入的算术和赋值运算符

Question

我有一段代码在时钟速度方面必须运行得非常快。该算法已经在 O(N) 中。需要2秒，需要1秒。对于大多数 A.length 输入 ~ 100,000 需要 0.3 秒，除非特定的代码行被调用了极端次数。 （对于深奥的编程挑战）

它使用算术级数的计算，即 1,2,..N -> 1,3,4,10,15.. 可以表示为 n*(n+1)/2 我循环这个方程几十万次。 我无权访问输入，也无法显示它。我能得到的唯一信息是运行时间。 特别是等式是：

s+=(n+c)-((n*(n+1))/2);

s 和 c 的取值范围为 0 到 10 亿

n 的范围可以是 0 到 100,000

就时钟速度而言，编写此语句的最有效方法是什么？ 我听说除法比乘法花费更多时间，但除此之外，我无法确定将其写在一行或多行中是否更有效。 除法和乘法与乘法然后除法？ 创建自定义整数类型也会有很大帮助吗？

根据要求进行编辑，输入小写的完整代码（对不起，如果它很难看，我只是一直在剥离它）：

public static void main(String[] args) {

        int A[]={3,4,8,5,1,4,6,8,7,2,2,4};//output 44
        int K=6;
        //long start = System.currentTimeMillis();;
        //for(int i=0;i<100000;i++){
            System.out.println(mezmeriz4r(A,K));
        //}
        //long end = System.currentTimeMillis();;

//      System.out.println((end - start) + " ms");

    }
    public static int mezmeriz4r(int[]A,int K){
        int s=0;
        int ml=s;
        int mxl=s;
        int sz=1;
        int t=s;
        int c=sz;
        int lol=50000;
        int end=A.length;
        for(int i=sz;i<end;i++){
            if(A[i]>A[mxl]){
                mxl=i;
            }else if(A[i]<A[ml]){
                ml=i;
            }
            if(Math.abs(A[ml]-A[mxl])<=K){
                sz++;
                if(sz>=lol)return 1000000000;
                if(sz>1){
                    c+=sz;
                }
            }else{
                if(A[ml]!=A[i]){
                    t=i-ml;
                    s+=(t+c)-((t*(t+1))/(short)2);
                    i=ml;
                    ml++;
                    mxl=ml;
                }else{
                    t=i-mxl;
                    s+=(t+c)-((t*(t+1))/(short)2);
                    i=mxl;
                    mxl++;
                    ml=mxl;
                }
                c=1;
                sz=0;
            }
        }
        if(s>1000000000)return 1000000000;
        return s+c;
    }

---

挑战归来：

检测到的时间复杂度：

O(N)

测试时间结果

示例 示例测试 0.290 秒。好的

单人 单个元素 0.290 秒。好的

双倍 两个元素 0.290 秒。好的

small_functional 小型功能测试 0.280 秒。好的

small_random 小随机序列长度 = ~100 0.300 s。好的

small_random2 小随机序列长度 = ~100 0.300 s。好的

medium_random 混沌中等序列长度 = ~3,000 0.290 s。好的

大范围 大范围测试，长度 = ~100,000 2.200 s。超时错误 运行时间：>2.20 秒，时限：1.02 秒。

大随机 随机大序列长度 = ~100,000 0.310 s。好的

large_answer 大答案测试 0.320 秒。好的

large_extreme 所有最大值 = ~100,000 0.340 秒。好的

Answer 1

借助一点代数，您可以简单地将表达式 (n+c)-((n*(n+1))/2) 到 c-((n*(n-1))/2) 删除一个加法运算。然后您可以将2 的除法替换为1 的右移位，这比除法更快。换个试试

s+=(n+c)-((n*(n+1))/2);

与

s+=c-((n*(n-1))>>1);

Answer 2

我无权验证所有输入。和时间范围。但这肯定会运行 O(N)。并有所改善。运行并让我知道您的反馈。如有必要，我将提供详细信息

public static int solution(int[]A,int K){
    int minIndex=0;
    int maxIndex=0;
    int end=A.length;
    int slize = end;
    int startIndex = 0;
    int diff = 0;
    int minMaxIndexDiff = 0;
    for(int currIndex=1;currIndex<end;currIndex++){
        if(A[currIndex]>A[maxIndex]){
            maxIndex=currIndex;
        }else if(A[currIndex]<A[minIndex]){
            minIndex=currIndex;
        }
        if( (A[maxIndex]-A[minIndex]) >K){
            minMaxIndexDiff= currIndex- startIndex;
            if (minMaxIndexDiff > 1){
                slize+= ((minMaxIndexDiff*(minMaxIndexDiff-1)) >> 1);
                if (diff > 0 ) {
                    slize = slize + (diff * minMaxIndexDiff);
                }
            }

            if (minIndex == currIndex){
                diff = currIndex - (maxIndex + 1);
            }else{
                diff = currIndex - (minIndex + 1);
            }
            if (slize > 1000000000) {
                return 1000000000;
            }
            minIndex = currIndex;
            maxIndex = currIndex;
            startIndex = currIndex;
        }
    }
    if ( (startIndex +1) == end){
        return slize;
    }
    if (slize > 1000000000) {
        return 1000000000;
    }
    minMaxIndexDiff= end- startIndex;
    if (minMaxIndexDiff > 1){
        slize+= ((minMaxIndexDiff*(minMaxIndexDiff-1)) >> 1);
        if (diff > 0 ) {
            slize = slize + (diff * minMaxIndexDiff);
        }
    }

    return slize;
}

Answer 3

去掉 for 循环中的 System.out.println() :) 你会惊讶于你的计算速度会有多快

Answer 4

嵌套分配，i。 e.而不是

t=i-ml;
s+=(t+c)-((t*(t+1))/(short)2);
i=ml;
ml++;
mxl=ml;

类似

s+=((t=i-ml)+c);
s-=((t*(t+1))/(short)2);
i=ml;
mxl=++ml;

有时会出现在 OpenJDK 源代码中。它主要导致将*load字节码指令替换为*dups。根据我的实验，它确实提供了非常少的加速，但它是超hadrcore，我不建议手动编写这样的代码。

Answer 5

我会尝试以下方法并在每次更改后分析代码以检查速度是否有任何提升。

---

替换：

if(Math.abs(A[ml]-A[mxl])<=K)

由

int diff = A[ml]-A[mxl];
if(diff<=K && diff>=-K)

---

替换

/2

通过

>>1

---

替换

ml++;
mxl=ml;

通过

mxl=++ml;

---

也许避免对同一元素的数组访问（java的内部边界检查可能需要一些时间）

所以至少在本地变量中保持A[i]。

Answer 6

我会先创建一个 C 版本，然后看看“直接访问金属”的速度有多快。很有可能，您正在尝试优化已经优化到极限的计算。

Answer 7

我会尝试消除这条线if(Math.abs(A[ml]-A[mxl])<= 通过更快的自计算 abs 版本，它是内联的，而不是方法调用！

演员表（短）没有帮助， 但尝试右移运算符 X >>1 而不是 x / 2

删除 System.out.println() 可以加快 1000 倍。 但要小心，否则你的整个算法可能会被 VM 删除，因为你不使用它。 旧代码：

for(int i=0;i<100000;i++){
            System.out.println(mezmeriz4r(A,K));
}

新代码：

int dummy = 0;
    for(int i=0;i<100000;i++){
          dummy =   mezmeriz4r(A,K);
    }
//Use dummy otherwise optimisation can remove  mezmeriz4r
System.out.print("finished: " + dummy);