Skip to content
Related Articles

Related Articles

Improve Article

Maximum product of sum of two contiguous subarrays of an array

  • Last Updated : 02 Jun, 2021

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)
 
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
Output: 
270
 
Time Complexity: O(n)
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



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
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
Count of contiguous subarrays possible for every index by including the element at that index
08, May 20
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
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 sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
03, Sep 21
Find an element which divides the array in two subarrays with equal product
28, Jun 18
Smallest index that splits an array into two subarrays with equal product
13, May 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
Maximum XOR value of maximum and second maximum element among all possible subarrays
08, Jan 20
Minimum product of maximum and minimum element over all possible subarrays
20, Aug 21
Count of subarrays whose product is equal to difference of two different numbers
22, Apr 20
Count the number of ways to divide an array into three contiguous parts having equal sum
18, May 17
Find the smallest contiguous sum pair in an Array
11, Jun 20
Find the largest contiguous pair sum in given Array
25, Jun 20
Count ways to split array into two equal sum subarrays by replacing each array element to 0 once
13, Nov 20
Count ways to split array into two equal sum subarrays by changing sign of any one array element
03, Dec 20
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