如何在 O(n) 时间复杂度中找到总和等于特定数字的连续子数组

Question

我已经解决了同样的问题，但我的代码的时间复杂度是 O(n^2)。 这是我运行两个循环的代码，因此我的时间复杂度变为 O(n^2)。 有什么办法可以更改我的代码以便在 O(n) 时间内解决相同的问题？

import java.util.Arrays;

public class PracticeOne {

public static void checkSum(int[] arr, int N) {
    int sum = 0;

    for(int i = 0; i < arr.length; i++) {
        sum = 0;
        for(int j = i; j < arr.length; j++) {
            sum += arr[j];
            if(sum == N) {
                System.out.println(Arrays.toString(Arrays.copyOfRange(arr, i, j+1)));
            }
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    int[] arr = {5, 4, 1, 2, 3, 4, 1, 4, 5, 5};
    int N = 10;

    checkSum(arr, N);
}

}

Answer 1

您基本上需要 2 个指针索引，开始和结束。 如果总和太高移动开始索引，移动结束索引总和太低。

我没有对其进行太多测试，但这是基本思想：

public static void checkSum(int[] arr, int N) { // O(n)
int sum = 0;
int startPoint = 0;
for(int endPoint = 0; endPoint < arr.length; endPoint++) {
    sum += arr[endPoint];
    while(sum > N) {
        sum -= arr[startPoint++];
    }
    if(sum == N) {
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr, startPoint, endPoint+1)));
    }
}

Answer 2

有什么办法可以更改我的代码以便在 O(n) 时间内解决相同的问题？

是的，但前提是你保证数组中的所有值都是正数或 0。你遍历你的数组，并每次检查总和（在添加下一个元素之后）。 如果您高于 N，则删除最旧的值，直到您再次等于或低于 N。 你重复这个，直到你点击 N 或数组的末尾：

public static void checkSum(int[] arr, int N) {
    if (N == 0) {
        System.out.println("[]");
    }
    int sum = 0;

    LinkedList<Integer> elements = new LinkedList<>();
    for (int value : arr) {
        sum += value;
        elements.addLast(value);
        while (sum > N && !elements.isEmpty()) {
            Integer oldest = elements.pollFirst();
            sum -= oldest;
        }
        if (sum == N) {
            System.out.println(elements);
        }
    }
}

这最多只会访问每个号码两次，因为您只会添加一次，删除一次。

结果：

[5, 4, 1]
[4, 1, 2, 3]
[1, 2, 3, 4]
[2, 3, 4, 1]
[1, 4, 5]
[5, 5]