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

Last Updated : 23 Jul, 2025

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# 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)

Analysis of Algorithms

lokeshpotta20

Improve

Article Tags :

Practice Tags :

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

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?