Skip to content
Related Articles

Related Articles

Largest sum contiguous subarray by adding S exactly at K different positions

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 21 Mar, 2022
View Discussion
Improve Article
Save Article

Given an array arr[] of length N, the task is to find the largest sum contiguous subarray by adding an integer S exactly at K different positions in the array for every K from [0, N].

Examples:

Input: arr[] = {4, 1, 3, 2}, S = 2
Output: 10 12 14 16 18
Explanation:
For k = 0, the sum of the array it self is the maximum subarray sum since no negative element so 10.
For k = 1, S can be added at any 1 position so the maximum subarray sum becomes 12.
For k = 2, S can be added at any 2 positions so the maximum subarray sum becomes 14.
For k = 3, S can be added at any 3 positions so the maximum subarray sum becomes 16.
For k = 4, S can be added at any 4 positions so the maximum subarray sum becomes 18.

Input: arr[] = {-1, -3, 5, 10}, S = 2
Output: 15 17 19 19 19 

 

Approach: The approach is based on the prefix sum technique

Initially the prefix sum of the array is calculated and using that,

  • The maximum subarray sum of each sizes [1, N] is calculated and
  • Then for each value of K, from [0, N], the value of S is added at K different positions and
  • Maximum sum is printed as the output.

Follow these steps to solve the above problem:

  • Initialize the array prefixsum[] to store the prefix sum of the array and the array msum[] to store the maximum of subarray sum of size i.
  • Now iterate through the array and calculate the prefix sum of the array.
  • Using two for loops calculate maximum subarray sum of each size i and store in msum[i].
  • Now for each k from [0, n] add s at k distinct positions to maximize the subarray sum of size i.
  • Print the maximum subarray sum for each k.

Below is the implementation of the above approach:

C++




// C++ program for largest sum
// contiguous subarray by adding S
// exactly at K different positions
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the largest sum
// subarray after adding s at k
// different positions for k from [0, n]
void find_maxsum_subarray(
    int arr[], int n, int s)
{
    int msum[n];
    int prefix_sum[n + 1] = { 0 };
    prefix_sum[0] = 0;
 
    // Find the prefix sum
    for (int i = 0; i < n; i++) {
        if (i == 0)
            prefix_sum[i + 1] = arr[i];
        else
            prefix_sum[i + 1]
                = arr[i]
                  + prefix_sum[i];
    }
 
    // For each subarray of size i
    // find the maximum sum
    for (int i = 0; i < n; i++) {
 
        int mx_sum = INT_MIN;
 
        // Check for every subarray of size i
        for (int j = 0; j < n - i; j++) {
            mx_sum
                = max(mx_sum,
                      prefix_sum[j + i + 1]
                          - prefix_sum[j]);
        }
 
        // Store the maximum sub array sum for
        // each subarray of size i in msum array
        msum[i] = mx_sum;
    }
 
    // For every k check the max sum
    // subarray by adding s
    // at k different positions
    for (int k = 0; k <= n; k++) {
 
        int mx_sum = 0;
 
        // For each maxsum of subarray of size i
        // check by s at k positions
        // find the maximum sum
        // after adding s at k positions
        for (int i = 0; i < n; i++) {
 
            mx_sum
                = max(mx_sum,
                      msum[i]
                          + min(i + 1, k) * s);
        }
 
        // For each k
        // print the maximum subarray sum
        cout << mx_sum << " ";
    }
}
 
// Driver code
int main()
{
    int arr[] = { 4, 1, 3, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int s = 2;
    find_maxsum_subarray(arr, n, s);
}


Java




// Java program for largest sum
// contiguous subarray by adding S
// exactly at K different positions
import java.io.*;
 
class GFG {
 
  // Function to find the largest sum
  // subarray after adding s at k
  // different positions for k from [0, n]
  static void find_maxsum_subarray(
    int []arr, int n, int s)
  {
    int []msum = new int[n];
 
    int []prefix_sum = new int[n + 1];
    for(int i = 0; i < n + 1; i++) {
      prefix_sum[i] = 0;
    }
 
    prefix_sum[0] = 0;
 
    // Find the prefix sum
    for (int i = 0; i < n; i++) {
      if (i == 0)
        prefix_sum[i + 1] = arr[i];
      else
        prefix_sum[i + 1]
        = arr[i]
        + prefix_sum[i];
    }
 
    // For each subarray of size i
    // find the maximum sum
    for (int i = 0; i < n; i++) {
 
      int mx_sum = Integer.MIN_VALUE;
 
      // Check for every subarray of size i
      for (int j = 0; j < n - i; j++) {
        mx_sum
          = Math.max(mx_sum,
                     prefix_sum[j + i + 1]
                     - prefix_sum[j]);
      }
 
      // Store the maximum sub array sum for
      // each subarray of size i in msum array
      msum[i] = mx_sum;
    }
 
    // For every k check the max sum
    // subarray by adding s
    // at k different positions
    for (int k = 0; k <= n; k++) {
 
      int mx_sum = 0;
 
      // For each maxsum of subarray of size i
      // check by s at k positions
      // find the maximum sum
      // after adding s at k positions
      for (int i = 0; i < n; i++) {
 
        mx_sum
          = Math.max(mx_sum,
                     msum[i]
                     + Math.min(i + 1, k) * s);
      }
 
      // For each k
      // print the maximum subarray sum
      System.out.print(mx_sum + " ");
    }
  }
 
  // Driver code
  public static void main (String[] args) {
    int []arr = { 4, 1, 3, 2 };
    int n = arr.length;
    int s = 2;
    find_maxsum_subarray(arr, n, s);
  }
}
 
// This code is contributed by hrithikgarg03188.


Python3




# Python3 program for largest sum
# contiguous subarray by adding S
# exactly at K different positions
 
# Function to find the largest sum
# subarray after adding s at k
# different positions for k from [0, n]
import sys
 
def find_maxsum_subarray(arr, n, s):
    msum = [0]*n
    prefix_sum = [0]*(n+1)
 
    # Find the prefix sum
    for i in range(n):
        if (i == 0):
            prefix_sum[i + 1] = arr[i]
        else:
            prefix_sum[i + 1] = arr[i] + prefix_sum[i]
 
    # For each subarray of size i
    # find the maximum sum
    for i in range(n):
 
        mx_sum = -sys.maxsize-1
 
        # Check for every subarray of size i
        for j in range(n - i):
            mx_sum = max(mx_sum,prefix_sum[j + i + 1]-prefix_sum[j])
 
        # Store the maximum sub array sum for
        # each subarray of size i in msum array
        msum[i] = mx_sum
 
    # For every k check the max sum
    # subarray by adding s
    # at k different positions
    for k in range(n+1):
 
        mx_sum = 0
 
        # For each maxsum of subarray of size i
        # check by s at k positions
        # find the maximum sum
        # after adding s at k positions
        for i in range(n):
            mx_sum = max(mx_sum,msum[i]+ min(i + 1, k) * s)
 
        # For each k
        # print the maximum subarray sum
        print(mx_sum,end=" ")
 
# Driver code
arr = [ 4, 1, 3, 2 ]
n = len(arr)
s = 2
find_maxsum_subarray(arr, n, s)
 
# This code is contributed by shinjanpatra


C#




// C# program for largest sum
// contiguous subarray by adding S
// exactly at K different positions
using System;
class GFG
{
 
  // Function to find the largest sum
  // subarray after adding s at k
  // different positions for k from [0, n]
  static void find_maxsum_subarray(
    int []arr, int n, int s)
  {
    int []msum = new int[n];
 
    int []prefix_sum = new int[n + 1];
    for(int i = 0; i < n + 1; i++) {
      prefix_sum[i] = 0;
    }
 
    prefix_sum[0] = 0;
 
    // Find the prefix sum
    for (int i = 0; i < n; i++) {
      if (i == 0)
        prefix_sum[i + 1] = arr[i];
      else
        prefix_sum[i + 1]
        = arr[i]
        + prefix_sum[i];
    }
 
    // For each subarray of size i
    // find the maximum sum
    for (int i = 0; i < n; i++) {
 
      int mx_sum = Int32.MinValue;
 
      // Check for every subarray of size i
      for (int j = 0; j < n - i; j++) {
        mx_sum
          = Math.Max(mx_sum,
                     prefix_sum[j + i + 1]
                     - prefix_sum[j]);
      }
 
      // Store the maximum sub array sum for
      // each subarray of size i in msum array
      msum[i] = mx_sum;
    }
 
    // For every k check the max sum
    // subarray by adding s
    // at k different positions
    for (int k = 0; k <= n; k++) {
 
      int mx_sum = 0;
 
      // For each maxsum of subarray of size i
      // check by s at k positions
      // find the maximum sum
      // after adding s at k positions
      for (int i = 0; i < n; i++) {
 
        mx_sum
          = Math.Max(mx_sum,
                     msum[i]
                     + Math.Min(i + 1, k) * s);
      }
 
      // For each k
      // print the maximum subarray sum
      Console.Write(mx_sum + " ");
    }
  }
 
  // Driver code
  public static void Main()
  {
    int []arr = { 4, 1, 3, 2 };
    int n = arr.Length;
    int s = 2;
    find_maxsum_subarray(arr, n, s);
  }
}
 
// This code is contributed by Samim Hossain Mondal.


Javascript




<script>
    // JavaScript program for largest sum
    // contiguous subarray by adding S
    // exactly at K different positions
    const INT_MIN = -2147483647 - 1;
 
    // Function to find the largest sum
    // subarray after adding s at k
    // different positions for k from [0, n]
    const find_maxsum_subarray = (arr, n, s) => {
        let msum = new Array(n).fill(0);
        let prefix_sum = new Array(n + 1).fill(0);
        prefix_sum[0] = 0;
 
        // Find the prefix sum
        for (let i = 0; i < n; i++) {
            if (i == 0)
                prefix_sum[i + 1] = arr[i];
            else
                prefix_sum[i + 1]
                    = arr[i]
                    + prefix_sum[i];
        }
 
        // For each subarray of size i
        // find the maximum sum
        for (let i = 0; i < n; i++) {
 
            let mx_sum = INT_MIN;
 
            // Check for every subarray of size i
            for (let j = 0; j < n - i; j++) {
                mx_sum
                    = Math.max(mx_sum,
                        prefix_sum[j + i + 1]
                        - prefix_sum[j]);
            }
 
            // Store the maximum sub array sum for
            // each subarray of size i in msum array
            msum[i] = mx_sum;
        }
 
        // For every k check the max sum
        // subarray by adding s
        // at k different positions
        for (let k = 0; k <= n; k++) {
 
            let mx_sum = 0;
 
            // For each maxsum of subarray of size i
            // check by s at k positions
            // find the maximum sum
            // after adding s at k positions
            for (let i = 0; i < n; i++) {
 
                mx_sum
                    = Math.max(mx_sum,
                        msum[i]
                        + Math.min(i + 1, k) * s);
            }
 
            // For each k
            // print the maximum subarray sum
            document.write(`${mx_sum} `);
        }
    }
 
    // Driver code
 
    let arr = [4, 1, 3, 2];
    let n = arr.length;
    let s = 2;
    find_maxsum_subarray(arr, n, s);
 
// This code is contributed by rakeshsahni
 
</script>


 
 

Output

10 12 14 16 18 

 

Time Complexity: O(N^2) where N is the size of the array.
Auxiliary Space: O(N) 

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!