执行给定操作后的最大可能数组和

给定大小为N的数组arr [] ，任务是在多次应用给定操作后，找到数组元素的最大和。在单个操作中，选择索引1≤i 并将arr [i]和arr [i – 1]都乘以-1 。
例子：

Input: arr[] = {-10, 5, -4} 
Output: 19 
Perform the operation for i = 1 and 
the array becomes {10, -5, -4} 
Perform the operation for i = 2 and 
the array becomes {10, 5, 4} 
10 + 5 + 4 = 19
Input: arr[] = {10, -4, -8, -11, 3} 
Output: 30 

方法：可以使用动态编程解决此问题。由于选择并翻转相同的arr [i]是没有用的，因此我们将考虑按从左到右的顺序对数组的每个元素最多翻转一次。令dp [i] [0]表示直到第i^个索引的最大可能和，而不翻转第i^个索引。 dp [i] [1]表示通过翻转第i^个索引到第i^个索引的最大可能和。因此，dp(n，0)是我们所需的答案。
基本条件：

1. dp [0] [0] = 0
2. dp [0] [1] = INT_MIN

递归关系：

1. dp [i + 1] [0] = max(dp [i] [0] + arr [i]，dp [i] [1] – arr [i])
2. dp [i + 1] [1] = max(dp [i] [0] – arr [i]，dp [i] [1] + arr [i])

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to return the maximum possible
// sum after performing the given operation
int max_sum(int a[], int n)
{
    // Dp vector to store the answer
    vector > dp(n + 1,
                            vector(2, 0));
 
    // Base value
    dp[0][0] = 0, dp[0][1] = -999999;
 
    for (int i = 0; i <= n - 1; i++) {
        dp[i + 1][0] = max(dp[i][0] + a[i],
                           dp[i][1] - a[i]);
        dp[i + 1][1] = max(dp[i][0] - a[i],
                           dp[i][1] + a[i]);
    }
 
    // Return the maximum sum
    return dp[n][0];
}
 
// Driver code
int main()
{
    int a[] = { -10, 5, -4 };
    int n = sizeof(a) / sizeof(a[0]);
 
    cout << max_sum(a, n);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
 
// Function to return the maximum possible
// sum after performing the given operation
static int max_sum(int a[], int n)
{
    // Dp vector to store the answer
    int [][]dp = new int[n + 1][2];
                         
    // Base value
    dp[0][0] = 0; dp[0][1] = -999999;
 
    for (int i = 0; i <= n - 1; i++)
    {
        dp[i + 1][0] = Math.max(dp[i][0] + a[i],
                                dp[i][1] - a[i]);
        dp[i + 1][1] = Math.max(dp[i][0] - a[i],
                                dp[i][1] + a[i]);
    }
 
    // Return the maximum sum
    return dp[n][0];
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { -10, 5, -4 };
    int n = a.length;
 
    System.out.println(max_sum(a, n));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python implementation of the approach
 
# Function to return the maximum possible
# sum after performing the given operation
def max_sum(a, n):
    # Dp vector to store the answer
    dp = [[0 for i in range(2)] for j in range(n+1)]
                         
    # Base value
    dp[0][0] = 0; dp[0][1] = -999999;
 
    for i in range(0, n):
        dp[i + 1][0] = max(dp[i][0] + a[i],
                                dp[i][1] - a[i]);
        dp[i + 1][1] = max(dp[i][0] - a[i],
                                dp[i][1] + a[i]);
 
    # Return the maximum sum
    return dp[n][0];
 
# Driver code
if __name__ == '__main__':
    a = [-10, 5, -4 ];
    n = len(a);
 
    print(max_sum(a, n));
     
# This code is contributed by 29AjayKumar

C#

// C# implementation of the approach
using System;
     
class GFG
{
 
// Function to return the maximum possible
// sum after performing the given operation
static int max_sum(int []a, int n)
{
    // Dp vector to store the answer
    int [,]dp = new int[n + 1, 2];
                         
    // Base value
    dp[0, 0] = 0; dp[0, 1] = -999999;
 
    for (int i = 0; i <= n - 1; i++)
    {
        dp[i + 1, 0] = Math.Max(dp[i, 0] + a[i],
                                dp[i, 1] - a[i]);
        dp[i + 1, 1] = Math.Max(dp[i, 0] - a[i],
                                dp[i, 1] + a[i]);
    }
 
    // Return the maximum sum
    return dp[n, 0];
}
 
// Driver code
public static void Main(String[] args)
{
    int []a = { -10, 5, -4 };
    int n = a.Length;
 
    Console.WriteLine(max_sum(a, n));
}
}
 
// This code is contributed by PrinciRaj1992

输出：

19

时间复杂度： O(N)

辅助空间： O(N)