Skip to content
Related Articles

Related Articles

Maximum product of sum of two contiguous subarrays of an array

View Discussion
Improve Article
Save Article
  • Last Updated : 23 Nov, 2021
View Discussion
Improve Article
Save Article

Given an array arr[] of N positive integers, the task is to split the array into two contiguous subarrays such that the product of the sum of two contiguous subarrays is maximum. 

Examples: 

Input: arr[] = {4, 10, 1, 7, 2, 9} 
Output: 270 
All possible partitions and their product of sum are: 
{4} and {10, 1, 7, 2, 9} -> product of sum = 116 
{4, 10} and {1, 7, 2, 9} -> product of sum = 266 
{4, 10, 1} and {7, 2, 9} -> product of sum = 270 
{4, 10, 1, 7} and {2, 9} -> product of sum = 242 
{4, 10, 1, 7, 2} and {9} -> product of sum = 216

Input: arr[] = {4, 10, 11, 10, 4} 
Output: 350 

Naive approach: A simple approach is to consider all the possible partitions for the subarrays one by one and calculate the maximum product of the sum of the subarrays.
Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// product of sum for any partition
int maxProdSum(int arr[], int n)
{
    int leftArraySum = 0, maxProduct = 0;
 
    // Traversing the array
    for (int i = 0; i < n; i++) {
 
        // Compute left array sum
        leftArraySum += arr[i];
 
        // Compute right array sum
        int rightArraySum = 0;
        for (int j = i + 1; j < n; j++) {
            rightArraySum += arr[j];
        }
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for the maximum product
        // of sum of left and right subarray
        if (k > maxProduct) {
            maxProduct = k;
        }
    }
 
    // Printing the maximum product
    return maxProduct;
}
 
// Driver code
int main()
{
    int arr[] = { 4, 10, 1, 7, 2, 9 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << maxProdSum(arr, n);
 
    return 0;
}

Java



// Java implementation of the approach
class GFG
{
 
// Function to return the maximum
// product of sum for any partition
static int maxProdSum(int arr[], int n)
{
    int leftArraySum = 0, maxProduct = 0;
 
    // Traversing the array
    for (int i = 0; i < n; i++)
    {
 
        // Compute left array sum
        leftArraySum += arr[i];
 
        // Compute right array sum
        int rightArraySum = 0;
        for (int j = i + 1; j < n; j++)
        {
            rightArraySum += arr[j];
        }
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for the maximum product
        // of sum of left and right subarray
        if (k > maxProduct)
        {
            maxProduct = k;
        }
    }
 
    // Printing the maximum product
    return maxProduct;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 4, 10, 1, 7, 2, 9 };
    int n = arr.length;
 
    System.out.print(maxProdSum(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
 
# Function to return the maximum
# product of sum for any partition
def maxProdSum(arr, n):
    leftArraySum = 0;
    maxProduct = 0;
 
    # Traversing the array
    for i in range(n):
 
        # Compute left array sum
        leftArraySum += arr[i];
 
        # Compute right array sum
        rightArraySum = 0;
        for j in range(i + 1, n):
            rightArraySum += arr[j];
         
        # Multiplying left and right subarray sum
        k = leftArraySum * rightArraySum;
 
        # Checking for the maximum product
        # of sum of left and right subarray
        if (k > maxProduct):
            maxProduct = k;
         
    # Printing the maximum product
    return maxProduct;
 
# Driver code
if __name__ == '__main__':
    arr = [ 4, 10, 1, 7, 2, 9 ];
    n = len(arr);
 
    print(maxProdSum(arr, n));
 
# This code is contributed by Rajput-Ji
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the maximum
// product of sum for any partition
static int maxProdSum(int []arr, int n)
{
    int leftArraySum = 0, maxProduct = 0;
 
    // Traversing the array
    for (int i = 0; i < n; i++)
    {
 
        // Compute left array sum
        leftArraySum += arr[i];
 
        // Compute right array sum
        int rightArraySum = 0;
        for (int j = i + 1; j < n; j++)
        {
            rightArraySum += arr[j];
        }
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for the maximum product
        // of sum of left and right subarray
        if (k > maxProduct)
        {
            maxProduct = k;
        }
    }
 
    // Printing the maximum product
    return maxProduct;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 4, 10, 1, 7, 2, 9 };
    int n = arr.Length;
 
    Console.Write(maxProdSum(arr, n));
}
}
 
// This code is contributed by PrinciRaj1992
Javascript



<script>
// Javascript implementation of the approach
 
// Function to return the maximum
// product of sum for any partition
function maxProdSum(arr, n) {
    let leftArraySum = 0, maxProduct = 0;
 
    // Traversing the array
    for (let i = 0; i < n; i++) {
 
        // Compute left array sum
        leftArraySum += arr[i];
 
        // Compute right array sum
        let rightArraySum = 0;
        for (let j = i + 1; j < n; j++) {
            rightArraySum += arr[j];
        }
 
        // Multiplying left and right subarray sum
        let k = leftArraySum * rightArraySum;
 
        // Checking for the maximum product
        // of sum of left and right subarray
        if (k > maxProduct) {
            maxProduct = k;
        }
    }
 
    // Printing the maximum product
    return maxProduct;
}
 
// Driver code
 
let arr = [4, 10, 1, 7, 2, 9];
let n = arr.length;
 
document.write(maxProdSum(arr, n));
</script>
Output: 
270
 
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient approach: A better approach is to use the concept prefix array sum which helps in calculating the sum of both the contiguous subarrays.  
  • The prefix sum of the elements can be calculated.
  • The left array sum is the value at ith position.
  • The right array sum is the value at the last position – ith position.
  • Now calculate k, the product of some of these left and right subarrays.
  • Find and print the maximum of the product of these arrays.
Below is the implementation of the above approach: 
CPP



// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum
// product of sum for any partition
int maxProdSum(int arr[], int n)
{
    int prefixArraySum[n], maxProduct = 0;
 
    // Initialise prefixArraySum[0]
    // with arr[0] element
    prefixArraySum[0] = arr[0];
 
    // Traverse array elements
    // to compute prefix array sum
    for (int i = 1; i < n; i++) {
        prefixArraySum[i] = prefixArraySum[i - 1]
                            + arr[i];
    }
 
    for (int i = 0; i < n - 1; i++) {
        // Compute left and right array sum
        int leftArraySum = prefixArraySum[i];
        int rightArraySum = prefixArraySum[n - 1]
                            - prefixArraySum[i];
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for maximum product of
        // the sum of left and right subarray
        if (k > maxProduct) {
            maxProduct = k;
        }
    }
 
    // Printing the maximum value
    return maxProduct;
}
 
// Driver code
int main()
{
    int arr[] = { 4, 10, 1, 7, 2, 9 };
    int n = sizeof(arr) / sizeof(int);
 
    cout << maxProdSum(arr, n);
 
    return 0;
}
Java



// Java implementation of the approach
class GFG
{
 
// Function to return the maximum
// product of sum for any partition
static int maxProdSum(int arr[], int n)
{
    int []prefixArraySum = new int[n];
    int maxProduct = 0;
 
    // Initialise prefixArraySum[0]
    // with arr[0] element
    prefixArraySum[0] = arr[0];
 
    // Traverse array elements
    // to compute prefix array sum
    for (int i = 1; i < n; i++)
    {
        prefixArraySum[i] = prefixArraySum[i - 1]
                            + arr[i];
    }
 
    for (int i = 0; i < n - 1; i++)
    {
        // Compute left and right array sum
        int leftArraySum = prefixArraySum[i];
        int rightArraySum = prefixArraySum[n - 1]
                            - prefixArraySum[i];
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for maximum product of
        // the sum of left and right subarray
        if (k > maxProduct)
        {
            maxProduct = k;
        }
    }
 
    // Printing the maximum value
    return maxProduct;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 4, 10, 1, 7, 2, 9 };
    int n = arr.length;
 
    System.out.print(maxProdSum(arr, n));
}
}
 
// This code is contributed by PrinciRaj1992
Python3



# Python implementation of the approach
 
# Function to return the maximum
# product of sum for any partition
def maxProdSum(arr, n):
     
    prefixArraySum = [0] * n
    maxProduct = 0
     
    # Initialise prefixArraySum[0]
    # with arr[0] element
    prefixArraySum[0] = arr[0]
     
    # Traverse array elements
    # to compute prefix array sum
    for i in range(1, n):
        prefixArraySum[i] = prefixArraySum[i - 1] + arr[i]
     
    for i in range(n - 1):
         
        # Compute left and right array sum
        leftArraySum = prefixArraySum[i]
        rightArraySum = prefixArraySum[n - 1] - \
                        prefixArraySum[i]
         
        # Multiplying left and right subarray sum
        k = leftArraySum * rightArraySum
         
        # Checking for maximum product of
        # the sum of left and right subarray
        if (k > maxProduct):
            maxProduct = k
     
    # Printing the maximum value
    return maxProduct
 
# Driver code
arr = [4, 10, 1, 7, 2, 9]
n = len(arr)
print(maxProdSum(arr, n))
 
# This code is contributed by SHUBHAMSINGH10
C#



// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the maximum
// product of sum for any partition
static int maxProdSum(int []arr, int n)
{
    int []prefixArraySum = new int[n];
    int maxProduct = 0;
 
    // Initialise prefixArraySum[0]
    // with arr[0] element
    prefixArraySum[0] = arr[0];
 
    // Traverse array elements
    // to compute prefix array sum
    for (int i = 1; i < n; i++)
    {
        prefixArraySum[i] = prefixArraySum[i - 1]
                            + arr[i];
    }
 
    for (int i = 0; i < n - 1; i++)
    {
        // Compute left and right array sum
        int leftArraySum = prefixArraySum[i];
        int rightArraySum = prefixArraySum[n - 1]
                            - prefixArraySum[i];
 
        // Multiplying left and right subarray sum
        int k = leftArraySum * rightArraySum;
 
        // Checking for maximum product of
        // the sum of left and right subarray
        if (k > maxProduct)
        {
            maxProduct = k;
        }
    }
 
    // Printing the maximum value
    return maxProduct;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 4, 10, 1, 7, 2, 9 };
    int n = arr.Length;
 
    Console.Write(maxProdSum(arr, n));
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
// Javascript implementation of the approach
 
// Function to return the maximum
// product of sum for any partition
function maxProdSum(arr, n)
{
    let prefixArraySum = [], maxProduct = 0;
 
    // Initialise prefixArraySum[0]
    // with arr[0] element
    prefixArraySum[0] = arr[0];
 
    // Traverse array elements
    // to compute prefix array sum
    for (let i = 1; i < n; i++) {
        prefixArraySum[i] = prefixArraySum[i - 1]
                            + arr[i];
    }
 
    for (let i = 0; i < n - 1; i++) {
        // Compute left and right array sum
        let leftArraySum = prefixArraySum[i];
        let rightArraySum = prefixArraySum[n - 1]
                            - prefixArraySum[i];
 
        // Multiplying left and right subarray sum
        let k = leftArraySum * rightArraySum;
 
        // Checking for maximum product of
        // the sum of left and right subarray
        if (k > maxProduct) {
            maxProduct = k;
        }
    }
 
    // Printing the maximum value
    return maxProduct;
}
 
// Driver code
let arr = [ 4, 10, 1, 7, 2, 9 ];
let n = arr.length;
 
document.write(maxProdSum(arr, n));
 
// This code is contributed by Samim Hossain Mondal.
</script>
Output: 
270
 
Time Complexity: O(n)
Auxiliary Space: O(n)

My Personal Notes
arrow_drop_up
Previous
Smallest number greater than n that can be represented as a sum of distinct power of k
Next

Count of possible arrays from prefix-sum and suffix-sum arrays
Recommended Articles
Page :
Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Sep 20
C++ Program for Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Dec 21
Java Program for Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Dec 21
Python3 Program for Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Dec 21
Javascript Program for Queries to find maximum sum contiguous subarrays of given length in a rotating array
15, Dec 21
Count of ways to split an Array into three contiguous Subarrays having increasing Sum
15, Aug 20
Difference between maximum and minimum average of all K-length contiguous subarrays
12, Jul 21
Partitioning into two contiguous element subarrays with equal sums
30, May 18
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Maximize cost to empty an array by removing contiguous subarrays of equal elements
12, Sep 20
Maximum absolute difference between sum of two contiguous sub-arrays
14, Jun 16
Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays
27, Sep 21
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
18, Feb 19
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
03, Sep 21
Smallest index that splits an array into two subarrays with equal product
13, May 21
Find an element which divides the array in two subarrays with equal product
28, Jun 18
Maximum XOR value of maximum and second maximum element among all possible subarrays
08, Jan 20
Maximum length of longest increasing contiguous subarray after deleting exactly one element from array
27, Oct 21
Maximum no. of contiguous Prime Numbers in an array
05, Nov 18
Maximum number of contiguous array elements with same number of set bits
13, Nov 18
Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0
13, Dec 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Chauhanvishesh99
@Chauhanvishesh99
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!