通过将数组元素替换为其平方来实现最大子数组总和

给定一个由N 个整数组成的数组a[] ，任务是找到通过用其平方替换单个数组元素可以获得的最大子数组和。

例子：

Input: a[] = {1, -5, 8, 12, -8} 
Output: 152 
Explanation: 
Replacing 12 by 144, the subarray {8, 144} generates the maximum possible subarray sum in the array.
Input: a[] = {-1, -2, -3} 
Output: 9 
Explanation:

朴素方法：解决问题的最简单方法是用其平方替换每个元素，并使用 Kadane 算法找到每个元素的最大子数组和。最后，打印获得的最大可能子数组和。
时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：上述方法可以使用动态规划进行优化。请按照以下步骤解决问题：

• 初始化记忆表 dp[][] 其中：
• dp[i][0]：存储包含^第i^个元素且不对任何数组元素进行平方的情况下可以获得的最大子数组和。
• dp[i][1]：存储可以包含^第i^个元素并对数组元素之一进行平方的最大子数组和
• 因此，递推关系为：

dp[i][0] = max(dp[i-1][0] + a[i], a[i]), that is, either extend the previous subarray ending at i – 1^th index or start a new subarray from i^th index.
dp[i][1] = max(a[i]², dp[i-1][0] + a[i]², dp[i-1][1] + a[i]), that is, either start new subarray from i^th index or extend previous subarray by adding a[i]² to dp[i – 1][0] or add a[i] to dp[i – 1][1]
 

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
#include  
using namespace std; 
 
// Function to find the maximum subarray
// sum possible
int getMaxSum(int a[], int n)
{
    int dp[n][2];
 
    // Stores sum without squaring
    dp[0][0] = a[0];
 
    // Stores sum squaring
    dp[0][1] = a[0] * a[0];
 
    // Stores the maximum subarray sum
    int max_sum = max(dp[0][0], dp[0][1]);
    for(int i = 1; i < n; i++)
    {
         
        // Either extend the subarray
        // or start a new subarray
        dp[i][0] = max(a[i],
                      dp[i - 1][0] + a[i]);
 
        // Either extend previous squared
        // subarray or start a new subarray
        // by squaring the current element
        dp[i][1] = max(dp[i - 1][1] + a[i],
                               a[i] * a[i]);
 
        dp[i][1] = max(dp[i][1],
                       dp[i - 1][0] +
                       a[i] * a[i]);
 
        // Update maximum subarray sum
        max_sum = max(max_sum, dp[i][1]);
        max_sum = max(max_sum, dp[i][0]);
    }
     
    // Return answer
    return max_sum;
}
     
// Driver Code
int32_t main()
{
    int n = 5;
    int a[] = { 1, -5, 8, 12, -8 };
 
    // Function call
    cout << getMaxSum(a, n) << endl;
 
    return 0;
}
 
// This code is contributed by rutvik_56

Java

// Java Program to implement
// the above approach
import java.io.*;
 
class GFG {
 
    // Function to find the maximum subarray
    // sum possible
    public static int getMaxSum(int a[], int n)
    {
        int dp[][] = new int[n][2];
 
        // Stores sum without squaring
        dp[0][0] = a[0];
 
        // Stores sum squaring
        dp[0][1] = a[0] * a[0];
 
        // Stores the maximum subarray sum
        int max_sum = Math.max(dp[0][0], dp[0][1]);
        for (int i = 1; i < n; i++) {
 
            // Either extend the subarray
            // or start a new subarray
            dp[i][0] = Math.max(a[i],
                                dp[i - 1][0] + a[i]);
 
            // Either extend previous squared
            // subarray or start a new subarray
            // by squaring the current element
            dp[i][1] = Math.max(dp[i - 1][1] + a[i],
                                a[i] * a[i]);
 
            dp[i][1]
                = Math.max(dp[i][1],
                        dp[i - 1][0] + a[i] * a[i]);
 
            // Update maximum subarray sum
            max_sum = Math.max(max_sum, dp[i][1]);
            max_sum = Math.max(max_sum, dp[i][0]);
        }
 
        // Return answer
        return max_sum;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int n = 5;
        int a[] = { 1, -5, 8, 12, -8 };
 
        // Function call
        System.out.println(getMaxSum(a, n));
    }
}

Python3

# Python3 program to implement
# the above approach
 
# Function to find the maximum subarray
# sum possible
def getMaxSum(a, n):
 
    dp = [[0 for x in range(2)]
            for y in range(n)]
 
    # Stores sum without squaring
    dp[0][0] = a[0]
 
    # Stores sum squaring
    dp[0][1] = a[0] * a[0]
 
    # Stores the maximum subarray sum
    max_sum = max(dp[0][0], dp[0][1])
 
    for i in range(1, n):
 
        # Either extend the subarray
        # or start a new subarray
        dp[i][0] = max(a[i],
                    dp[i - 1][0] + a[i])
 
        # Either extend previous squared
        # subarray or start a new subarray
        # by squaring the current element
        dp[i][1] = max(dp[i - 1][1] + a[i],
                        a[i] * a[i])
 
        dp[i][1] = max(dp[i][1],
                    dp[i - 1][0] +
                        a[i] * a[i])
 
        # Update maximum subarray sum
        max_sum = max(max_sum, dp[i][1])
        max_sum = max(max_sum, dp[i][0])
 
    # Return answer
    return max_sum
 
# Driver Code
n = 5
a = [ 1, -5, 8, 12, -8 ]
 
# Function call
print(getMaxSum(a, n))
 
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to find the maximum subarray
// sum possible
public static int getMaxSum(int []a, int n)
{
    int [,]dp = new int[n, 2];
 
    // Stores sum without squaring
    dp[0, 0] = a[0];
 
    // Stores sum squaring
    dp[0, 1] = a[0] * a[0];
 
    // Stores the maximum subarray sum
    int max_sum = Math.Max(dp[0, 0], dp[0, 1]);
    for(int i = 1; i < n; i++)
    {
         
        // Either extend the subarray
        // or start a new subarray
        dp[i, 0] = Math.Max(a[i],
                        dp[i - 1, 0] + a[i]);
 
        // Either extend previous squared
        // subarray or start a new subarray
        // by squaring the current element
        dp[i, 1] = Math.Max(dp[i - 1, 1] + a[i],
                            a[i] * a[i]);
 
        dp[i, 1] = Math.Max(dp[i, 1],
                            dp[i - 1, 0] +
                            a[i] * a[i]);
 
        // Update maximum subarray sum
        max_sum = Math.Max(max_sum, dp[i, 1]);
        max_sum = Math.Max(max_sum, dp[i, 0]);
    }
 
    // Return answer
    return max_sum;
}
 
// Driver Code
public static void Main(String[] args)
{
    int n = 5;
    int []a = { 1, -5, 8, 12, -8 };
 
    // Function call
    Console.WriteLine(getMaxSum(a, n));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// JavaScript program for the above approach
 
  // Function to find the maximum subarray
    // sum possible
    function getMaxSum(a, n)
    {
        let dp = new Array(n);
        // Loop to create 2D array using 1D array
        for (var i = 0; i < dp.length; i++) {
            dp[i] = new Array(2);
        }
   
        // Stores sum without squaring
        dp[0][0] = a[0];
   
        // Stores sum squaring
        dp[0][1] = a[0] * a[0];
   
        // Stores the maximum subarray sum
        let max_sum = Math.max(dp[0][0], dp[0][1]);
        for (let i = 1; i < n; i++) {
   
            // Either extend the subarray
            // or start a new subarray
            dp[i][0] = Math.max(a[i],
                                dp[i - 1][0] + a[i]);
   
            // Either extend previous squared
            // subarray or start a new subarray
            // by squaring the current element
            dp[i][1] = Math.max(dp[i - 1][1] + a[i],
                                a[i] * a[i]);
   
            dp[i][1]
                = Math.max(dp[i][1],
                        dp[i - 1][0] + a[i] * a[i]);
   
            // Update maximum subarray sum
            max_sum = Math.max(max_sum, dp[i][1]);
            max_sum = Math.max(max_sum, dp[i][0]);
        }
   
        // Return answer
        return max_sum;
    }
     
// Driver Code
 
        let n = 5;
        let a = [ 1, -5, 8, 12, -8 ];
   
        // Function call
        document.write(getMaxSum(a, n));
      

输出：

152

时间复杂度： O(N)
辅助空间： O(N)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。