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

给定一个由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)

  如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live