Maximum sum subarray of size range [L, R] (original) (raw)

Last Updated : 08 Mar, 2024

Given an integer array **arr[] of size **N and two integer **L and **R. The task is to find the maximum sum subarray of size between **L and **R (both inclusive).

**Example:

**Input: arr[] = {1, 2, 2, 1}, L = 1, R = 3
**Output: 5
**Explanation:
Subarray of size 1 are {1}, {2}, {2}, {1} and maximum sum subarray = 2 for subarray {2}.
Subarray of size 2 are {1, 2}, {2, 2}, {2, 1}, and maximum sum subarray = 4 for subarray {2, 2}.
Subarray of size 3 are {1, 2, 2}, {2, 2, 1}, and maximum sum subarray = 5 for subarray {2, 2, 1}.
Hence the maximum possible sum subarray is 5.

**Input: arr[] = {-1, -3, -7, -11}, L = 1, R = 4
**Output: -1

**Approach:

Below is the implementation of the above approach:

C++ `

// C++ program to find Maximum sum // subarray of size between L and R.

#include <bits/stdc++.h> using namespace std;

// function to find Maximum sum subarray // of size between L and R void max_sum_subarray(vector arr, int L, int R) { int n = arr.size(); int pre[n] = { 0 };

// calculating prefix sum
pre[0] = arr[0];
for (int i = 1; i < n; i++) {
    pre[i] = pre[i - 1] + arr[i];
}
multiset<int> s1;

// maintain 0 for initial
// values of i upto R
// Once i = R, then
// we need to erase that 0 from
// our multiset as our first
// index of subarray
// cannot be 0 anymore.
s1.insert(0);
int ans = INT_MIN;

ans = max(ans, pre[L - 1]);

// we maintain flag to
// counter if that initial
// 0 was erased from set or not.
int flag = 0;

for (int i = L; i < n; i++) {

    // erase 0 from multiset once i=b
    if (i - R >= 0) {
        if (flag == 0) {

            auto it = s1.find(0);
            s1.erase(it);
            flag = 1;
        }
    }
    // insert pre[i-L]
    if (i - L >= 0)
        s1.insert(pre[i - L]);

    // find minimum value in multiset.
    ans = max(ans,
              pre[i] - *s1.begin());

    // erase pre[i-R]
    if (i - R >= 0) {
        auto it = s1.find(pre[i - R]);
        s1.erase(it);
    }
}
cout << ans << endl;

}

// Driver code int main() { int L, R; L = 1; R = 3; vector arr = { 1, 2, 2, 1 }; max_sum_subarray(arr, L, R); return 0; }

Java

// Java program to find Maximum sum // subarray of size between L and R. import java.util.*; class GFG { // function to find Maximum sum subarray // of size between L and R static void max_sum_subarray(List arr, int L, int R){

int n = arr.size();
int[] pre = new int[n + 1];

// calculating prefix sum
// here pre[0] = 0
for (int i = 1; i <= n; i++) {
    pre[i] = pre[i - 1]+arr.get(i - 1);
}    

  // treemap for storing prefix sums for 
  // subarray length L to R
TreeMap<Integer, Integer> s1 = new TreeMap<>();

int ans = Integer.MIN_VALUE;

for (int i = L; i <= n; i++) {
    
    // if i > R, erase pre[i - R - 1]
    // note that pre[0] = 0
    if (i > R) { 
        // decrement count of pre[i - R - 1]
        s1.put(pre[i - R - 1], s1.get(pre[i - R - 1])-1); 
        // if count is zero, element is not present
        // in map so remove it
        if (s1.get(pre[i - R - 1]) == 0) 
            s1.remove(pre[i - R - 1]);
    }

    // insert pre[i - L]
    s1.put(pre[i - L], s1.getOrDefault(pre[i - L], 0)+1);

    // find minimum value in treemap.
    ans = Math.max(ans, pre[i] - s1.firstKey());

}
System.out.println(ans);

}

// Driver code public static void main(String[] args){ int L, R; L = 1; R = 3; List arr = Arrays.asList(1, 2, 2, 1); max_sum_subarray(arr, L, R); } }

// This code is contributed by Utkarsh Sharma

C#

// C# program to find Maximum sum // subarray of size between L and R. using System; using System.Collections.Generic; class GFG {

// function to find Maximum sum subarray 
// of size between L and R 
static void max_sum_subarray(List<int> arr, int L, int R) 
{ 
    int n = arr.Count; 
    int[] pre = new int[n];
  
    // calculating prefix sum 
    pre[0] = arr[0]; 
    for (int i = 1; i < n; i++) 
    { 
        pre[i] = pre[i - 1] + arr[i]; 
    } 
    List<int> s1 = new List<int>();
  
    // maintain 0 for initial 
    // values of i upto R 
    // Once i = R, then 
    // we need to erase that 0 from 
    // our multiset as our first 
    // index of subarray 
    // cannot be 0 anymore. 
    s1.Add(0); 
    int ans = Int32.MinValue; 
  
    ans = Math.Max(ans, pre[L - 1]); 
  
    // we maintain flag to 
    // counter if that initial 
    // 0 was erased from set or not. 
    int flag = 0; 
  
    for (int i = L; i < n; i++) 
    { 
  
        // erase 0 from multiset once i=b 
        if (i - R >= 0) 
        { 
            if (flag == 0)
            { 
  
                int it = s1.IndexOf(0); 
                s1.RemoveAt(it); 
                flag = 1; 
            } 
        } 
        // insert pre[i-L] 
        if (i - L >= 0) 
            s1.Add(pre[i - L]); 
  
        // find minimum value in multiset. 
        ans = Math.Max(ans, pre[i] - s1[0]); 
  
        // erase pre[i-R] 
        if (i - R >= 0) 
        { 
            int it = s1.IndexOf(pre[i - R]); 
            s1.RemoveAt(it); 
        } 
    } 
    Console.WriteLine(ans); 
}

// Driver code static void Main() { int L, R; L = 1; R = 3; List arr = new List(){1, 2, 2, 1}; max_sum_subarray(arr, L, R); } }

// This code is contributed by divyesh072019

JavaScript

// Javascript program to find Maximum sum // subarray of size between L and R.

// function to find Maximum sum subarray // of size between L and R function max_sum_subarray(arr,L,R) { let n = arr.length; let pre = new Array(n);

// calculating prefix sum
pre[0] = arr[0];
for (let i = 1; i < n; i++)
{
  pre[i] = pre[i - 1] + arr[i];
}
let s1 = []

// maintain 0 for initial
// values of i upto R
// Once i = R, then
// we need to erase that 0 from
// our multiset as our first
// index of subarray
// cannot be 0 anymore.
s1.push(0);
let ans = Number.MIN_VALUE;

ans = Math.max(ans, pre[L - 1]);

// we maintain flag to
// counter if that initial
// 0 was erased from set or not.
let flag = 0;

for (let i = L; i < n; i++)
{

  // erase 0 from multiset once i=b
  if (i - R >= 0)
  {
    if (flag == 0)
    {
      let it = s1.indexOf(0);
      s1.splice(it,1);
      flag = 1;
    }
  }

  // insert pre[i-L]
  if (i - L >= 0)
    s1.push(pre[i - L]);

  // find minimum value in multiset.
  ans = Math.max(ans, pre[i] - s1[0]);

  // erase pre[i-R]
  if (i - R >= 0)
  {
    let it = s1.indexOf(pre[i - R]);
    s1.splice(it,1);
  }
}
document.write(ans);

}

// Driver code let L, R; L = 1; R = 3; let arr = [1, 2, 2, 1]; max_sum_subarray(arr, L, R);

// This code is contributed by avanitrachhadiya2155

Python3

def max_sum_subarray(arr, L, R): n = len(arr) pre = [0] * n

# calculating prefix sum
pre[0] = arr[0]
for i in range(1, n):
    pre[i] = pre[i - 1] + arr[i]

s1 = set()

# maintain 0 for initial
# values of i up to R
# Once i = R, then
# we need to erase that 0 from
# our set as our first
# index of subarray
# cannot be 0 anymore.
s1.add(0)
ans = float('-inf')

ans = max(ans, pre[L - 1])

# we maintain flag to
# counter if that initial
# 0 was erased from set or not.
flag = 0

for i in range(L, n):

    # erase 0 from set once i=b
    if i - R >= 0:
        if flag == 0:
            s1.remove(0)
            flag = 1

    # insert pre[i-L]
    if i - L >= 0:
        s1.add(pre[i - L])

    # find minimum value in set.
    ans = max(ans, pre[i] - min(s1))

    # erase pre[i-R]
    if i - R >= 0:
        s1.remove(pre[i - R])

print(ans)

Driver code

if name == "main": L, R = 1, 3 arr = [1, 2, 2, 1] max_sum_subarray(arr, L, R)

`

**Time Complexity: O (N * log N)
**Auxiliary Space: O (N)

Similar Reads