最长子阵列

Question

谁能为以下问题提出一个简单的解决方案。

最长子数组：求子数组中元素之和小于等于“k”的最长连续子数组的长度。

输入是：array 和 k。

例子：

Array = {1,2,3}, k = 3

输出：

2

解释：

子数组：{1},{2},{3},{1,2},{2,3},{1,2,3}

{1,2} => 最大长度 = 2; 1+2 = 3 (

Answer 1

一种 O(n) 方法。高水平：

有 2 个指针 start 和 end，start 是子数组的开始，end 是结束（独占）。一个 int sum 来保持子数组的总和。一个 int len 保留子数组 len。

将两者都设置为位置 0。

1. 继续移动end 指针：

   while (end < arr.length && sum + arr[end] <= k) {
       sum += arr[end];
       end ++;
   }
   if ((end - start) > len ) {
     len = (end-start);
   }
   

   哪个会找到以sum < k 开头且以start 开头的最长子数组

2. 移动start

   sum -= arr[start];
   start++;
   

3. 回到1，直到end传递数组的最后一个元素

最后你会找到最大长度（存储在len）

将一些边缘情况的处理留给您（例如，如果数组中有一个元素的值为 > k. 等）

Answer 2

最简单和天真的答案是遍历你的数组并找到从当前索引开始的最长子数组。

int[] a = { 1,2,3,1,1,2,3,1,3 };
int k = 4;

int best_i = 0; // from index
int best_j = 0; // to index, so best length = j - i + 1
int best_sum = 0;

for (int i = 0; i < a.length; i++) { // starting index from beginning to end 
    int sum = 0;
    for (int j = i; j < a.length; j++) { // ending index from current to end
        sum += a[j];
        if (sum > k) break;
        if (j - i > best_j - best_i) { // best length found
            best_i = i;
            best_j = j;
            best_sum = sum;
        }
    }
}

System.out.println("best length = " + (best_j - best_i + 1) + " (indexes " + best_i + ".." + best_j + "), sum = " + best_sum);
// best length = 3 (indexes 3..5), sum = 4

Answer 3

一种有效的方法是使用动态规划，以减少求和操作的次数。例如，如果你求和 (1 + 2) = 3，你不想再求和 (1 + 2 + 3) = 6，你只想求和 (3 + 3) = 6（前 3 已经是计算并保存到哈希图中）。在此解决方案中，hashmap 表示从索引i 到索引j 的总和，格式为<i, <j, sum>>。因此，您将从索引i 开始的所有总和存储在内部哈希图中。请注意，您也可以使用 2D 数组而不是嵌套的 hashmap 结构，但是对于非常大的数据，您可能会在初始化该数组时遇到内存不足的异常。

    static int maxLength(int[] a, int k) {
        Map<Integer, Map<Integer, Long>> map = new HashMap<Integer, Map<Integer, Long>>();

        int maxLength = 0;
        for(int i = 0; i < a.length - 1; i++) {
            Map<Integer, Long> map2 = new HashMap<Integer, Long>();
            map2.put(i, (long)a[i]);
            map.put(i, map2);
            if(a[i] == k) {
                maxLength = 1;
            }
        }

        for(int l = 2; l <= a.length; l++) {
            long sum = 0;
            for(int i = 0; i <= a.length - l; i++) {
                int j = i + l - 1;
                Map<Integer, Long> map2 = map.get(i);
                sum = map2.get(j - 1) + a[j];
                map2.put(j, sum);

                if(sum <= k) {
                    if(l > maxLength) {
                        maxLength = l;
                    }
                }
            }
        }

        return maxLength;
    }

Answer 4

Python 实现

时间复杂度O(n)

不需要额外的空间

def longest_sub_array_sum(input_array: list, k: int) -> int:
    longest_size = 0
    
    if input_array:
        i = 0
        j = 1
        longest_size = 0 if input_array[i] != k else 1
        current_sum = input_array[i]
        
        while j < len(input_array):
            if current_sum <= k:
                if j - i > longest_size:
                    longest_size = j - i
                current_sum += input_array[j]
                j += 1

            elif current_sum > k:
                current_sum -= input_array[i]
                i += 1
                
    return longest_size

Answer 5

这里我只使用 for 循环，但我怀疑这个解决方案的复杂性，是 O(n) 还是 O(n2)。看起来像一个 for 循环，但我不认为一些操作比蛮力或两个 for 循环少。

函数 maxLength(a, k) {

var maxLen = 0;
var currMaxLen = 0;
var currSum = 0;
var currIndex = 0;

for(index = 0; index < a.length; index++){
    currSum = currSum + a[index];

    if(currSum <= k){
        currMaxLen++;
    } else{
        //reset
        index = currIndex;
        currIndex++;
        maxLen = Math.max(maxLen, currMaxLen);
        currSum = 0;
        currMaxLen = 0;
    }
}
maxLen = Math.max(maxLen, currMaxLen);
return maxLen;

}