Question

例如，我们有

{2,2,-1}, 
when k = 0, return -1.
when k = 3, return 3.

这甚至很棘手，因为我们有负数和一个额外的变量k。 k可以是任何值，负数，不做任何假设。

我无法引用https://en.wikipedia.org/wiki/Maximum_subarray_problem和https://www.youtube.com/watch?v=yCQN096CwWM来解决此问题。

任何人都可以帮助我吗？更好地使用Java或JavaScript。

这是最大的经典算法o（n）（无变量k）：

public int maxSubArray(int[] nums) {

        int max = nums[0];
        int tsum = nums[0];
        for(int i=1;i<nums.length;i++){
            tsum = Math.max(tsum+nums[i],nums[i]);
            max = Math.max(max,tsum);
        }

        return max;
    }

Answer 1

这是一个o（nlogn）解决方案 https://www.quora.com/Given-an-array-of-integers-A-and-an-integer-k-find-a-subarray-that-contains-the-largest-sum-subject-to-a-constraint-that-the-sum-is-less-than-k

private int maxSumSubArray(int[] a , int k){

    int max = Integer.MIN_VALUE;
    int sumj = 0;
    TreeSet<Integer> ts = new TreeSet();
    ts.add(0);

    for(int i=0;i<a.length;i++){
        sumj += a[i];
        Integer gap = ts.ceiling(sumj - k);
        if(gap != null) max = Math.max(max, sumj - gap);
        ts.add(sumj);
    }
    return max;
}

Answer 2

这是一个在O（n²）中运行的朴素算法。

std::array<int, 3> input = {2, 2, -1};
int k = -1;
int sum = 0, largestSum = *std::min_element(input.begin(), input.end()) -1;
int i = 0, j = 0;
int start = 0, end = 0;

while (largestSum != k && i != input.size()) {
    sum += input[j];

    if (sum <= k && sum > largestSum) {
        largestSum = sum;
        start = i;
        end = j;
    }

    ++j;
    if (j == input.size()) {
        ++i;
        j = i;
        sum = 0;
    }
}

那是C ++，但用Java或Javascript编写应该不难。它基本上尝试了所有可能的总和（有n*(n+1)/2）并且如果找到k则停止。

必须将

largestSum初始化为足够低的值。由于输入的最小元素可以等于k，因此我减去1 start和end是最终子阵列的第一个和最后一个索引。

当然，如果你对输入有任何限制，它可以得到改善。

Live example

Answer 3

我受到问题中提到的经典解决方案的影响。这个问题可以通过o（n ^ 2）解决方案简单地解决：

private int maxSumSubArray(int[] a , int k){

    int max = Integer.MIN_VALUE;
    for(int i=0;i<a.length;i++){
        int tsum = 0;
        for(int j=i;j<a.length;j++){
            tsum += a[j];
            if(tsum <= k) max=Math.max(max,tsum);
        }
    }

    return max;
}

Answer 4

这里是python O（n ^ 2）中的一个：

override class var supportsSecureCoding: Bool {
    return true
}

Answer 5

想知道为什么没有人为此讨论基于滑动窗口的解决方案（O(n)）。

用第一个元素初始化窗口。跟踪窗口的开始索引。
遍历数组，将当前元素添加到窗口。
如果 sum 变为 > k，则从开始减小窗口直到 sum 变为 <= k。
检查 sum > maxSumSoFar，设置 maxSumSoFar = sum。

注意 -> 上面算法中的'sum'是当前窗口中元素的总和。

int findMaxSubarraySum(long long arr[], int N, long long K)
{
    long long currSum = arr[0];
    long long maxSum = LLONG_MIN;
    int startIndex = 0;
    if(currSum <= X) maxSum = currSum;
    for(int i=1; i<N; i++){
        currSum += arr[i];
        while(currSum > K && startIndex <= i){
            currSum -= arr[startIndex];
            startIndex++;
        }
        if(currSum <= K) maxSum = max(maxSum, currSum);
    }
    return (int)maxSum;
}

Answer 6

可以使用简单的滑动窗口解决。首先继续添加数组元素的总和，如果总和超过 k 通过从开始减去元素来减少它。 仅当数组具有非负数时才有效。

int curr_sum = arr[0], max_sum = 0, start = 0;

// To find max_sum less than sum
for (int i = 1; i < n; i++) {

    // Update max_sum if it becomes
    // greater than curr_sum
    if (curr_sum <= sum)
       max_sum = max(max_sum, curr_sum);

    // If curr_sum becomes greater than
    // sum subtract starting elements of array
    while (curr_sum + arr[i] > sum && start < i) {
        curr_sum -= arr[start];
        start++;
    }
     
    // Add elements to curr_sum
    curr_sum += arr[i];
}

// Adding an extra check for last subarray
if (curr_sum <= sum)
    max_sum = max(max_sum, curr_sum);

return max_sum;

连续子阵列的最大总和不大于k

6 个答案: