Java 时间复杂度改进

我一直在Codility.com上尝试编码挑战 这是我试过的问题之一：

给出了一个由N个整数组成的非空零索引数组。A. 一对整数（P，Q），使得0≤ P 例如，阵列应确保：

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

包含以下示例切片：

切片（1,2），其平均值为（2+2）/2=2；切片（3，4），其 平均值为（5+1）/2=3；切片（1,4），其平均值为（2+2+5 + 1) / 4 = 2.5. 目标是找到平均值最小的切片的起始位置

编写一个函数：

类解决方案{public int Solution（int[]A）；}

给定一个由N个整数组成的非空零索引数组， 返回具有最小平均值的切片的起始位置。 如果存在多个具有最小平均值的切片，则应 返回该切片的最小起始位置

例如，给定一个数组，使得：

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

A[0] = 4
A[1] = 2
A[2] = 2
A[3] = 5
A[4] = 1
A[5] = 5
A[6] = 8

如上所述，函数应返回1

我已经提交了我的答案，得到了60%。我的解决方案是正确的，我通过了所有测试用例。我得到60%的分数是因为时间的复杂性。对于大型测试用例，我的解决方案运行时间太长

这是我的Java解决方案：

class Solution {
    public int solution(int[] A) {
        int size = A.length;

        if (size == 2) {
            return 0;
        }

        int sizeLessOne = size - 1;
        int start       = 0;
        double min      = 0;
        boolean isFirst = true;

        for (int i = 0; i < sizeLessOne; i++) {
            int val1  = A[i];
            for (int j = i + 1; j < size; j++) {
                int val2   = A[j];
                double avg = ((double) val1 + val2) / (j - i + 1);
                if (isFirst || avg < min) {
                    min   = avg;
                    start = i;
                    if (isFirst) {
                        isFirst = false;
                    }
                }
                val1 += val2;
            }
        }

        return start;
    }
}

public class SolutionRunner {
    public static void main(String[] args) {
        Solution s = new Solution();
        int[] A    = {4,2,2,5,1,5,8};
        System.out.println(s.solution(A));
    }
}

类解决方案{
公共int解决方案（int[]A）{
int size=A.length；
如果（大小==2）{
返回0；
}
int sizeLessOne=大小-1；
int start=0；
双最小值=0；
布尔值isFirst=true；
对于（int i=0；i

根据我的代码，由于嵌套for循环，最坏情况下的时间复杂度是O（N^2）。O（N）上的预期最坏情况。我不知道如何才能做到这一点

提前感谢。

您可以在

O（n）

中执行此操作，因为始终存在大小为2或3的最佳子阵列

假设您有一个大小为

n>3

的最佳子数组

S

。

---

S

可以分成两个子数组：

S'

大小

2

和

S'

大小n-2>=2<因为

S

是最优的，所以code>Avg'>=Avg和

Avg'>=Avg

。但是

Avg（S）>=min（Avg（S'），Avg（S'））

，因此

Avg（S）=Avg（S'）=Avg（S'））

。所以

S'

也是最优的。

我不确定O（N）是否可能。您可以尝试分段树。这将为您提供O（NlogN）解决方案。嗨，我在理解这一点时遇到了一些困难。可以分享一个例子吗？假设你发现了一个最小的4号切片。让我们将这个片S定义为[a，b，c，d]，avg（S）=（a+b+c+d）/4。你知道avg（S）是最小值，所以：avg（S）对于你的代码来说，这意味着你只需要检查大小为2和3的切片。这是O（n）。我的例子并不是一个真正的例子，而是一个更实际的方法：您可以尝试构建一个大小为4的最佳切片，而不是从大小为2的最佳切片开始。