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

给定一个大小为N的数组arr[] ，任务是在应用任意次数的给定操作后找到数组元素的最大和。在单个操作中，选择索引1 ≤ i < N并将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

Javascript

// javascript implementation of the approach    // Function to return the maximum possible
    // sum after performing the given operation
    function max_sum(a , n) {
        // Dp vector to store the answer
        var dp = Array(n + 1).fill().map(()=>Array(2).fill(0));
 
        // Base value
        dp[0][0] = 0;
        dp[0][1] = -999999;
 
        for (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
     
        var a = [ -10, 5, -4 ];
        var n = a.length;
 
        document.write(max_sum(a, n));
 
// This code is contributed by todaysgaurav

输出：

19

时间复杂度： O(N)

辅助空间： O(N)

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