数组的两个连续子数组之和的最大乘积

给定一个包含N个正整数的数组arr[] ，任务是将数组拆分为两个连续的子数组，使得两个连续子数组之和的乘积最大。

例子：

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 

朴素的方法：一种简单的方法是逐一考虑子数组的所有可能分区，并计算子数组之和的最大乘积。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
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

// 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));

输出：

270

时间复杂度： O(N ² )

辅助空间： O(1)

有效的方法：更好的方法是使用概念前缀数组和，这有助于计算两个连续子数组的总和。

• 可以计算元素的前缀和。
• 左边的数组总和是第 i^个位置的值。
• 右边的数组总和是最后一个位置的值——第 i^个位置。
• 现在计算k ，其中一些左右子数组的乘积。
• 查找并打印这些数组乘积的最大值。

下面是上述方法的实现：

CPP

// C++ implementation of the approach
#include 
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

// 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.

输出：

270

时间复杂度： O(n)

辅助空间： O(n)