通过交替相邻元素的符号来最大化数组和

给定大小为N的数组arr [] ，任务是通过交替相邻数组元素的符号来找到数组元素的最大可能和。

例子：

Input: arr[] = { -2, 1, 0 } 
Output: 3 
Explanation: 
Alternating the signs of (arr[0], arr[1]) modifies arr[] to {2, -1, 0}. 
Alternating the signs of (arr[1], arr[2]) modifies arr[] to {2, 1, 0}. 
Therefore, the required output = (2 + 1 + 0) = 3, which is the maximum sum possible.

Input: arr[] = { 1, 1, -2, -4, 5 } 
Output: 13 
Explanation: 
Alternating the signs of (arr[2], arr[3]) modifies arr[] to { 1, 1, 2, 4, 5 } 
Therefore, the required output = (1 + 1 + 2 + 4 + 5) = 13, which is the maximum sum possible.

方法：可以使用贪婪技术解决问题。这个想法基于这样一个事实，即在交替相邻元素的符号之后，数组中负元素的最大数量不能大于1 。请按照以下步骤解决问题：

• 初始化变量MaxAltSum ，以通过交替相邻元素的符号来存储数组元素的最大可能和。
• 遍历数组并计算数组中负元素的数量。
• 如果数组中负元素的数量为偶数，则通过交替相邻数组元素的符号而可能获得的最大和等于数组元素的绝对值之和，即MaxAltSum =Σabs(arr [i])
• 否则，通过交替相邻数组元素的符号而从数组中获得的最大可能和等于除数组元素的最小绝对值以外的所有可能数组元素的绝对值之和。即， MaxAltSum =(((Σabs(arr [i]))– 2 * X) ，其中X是数组元素的最小绝对值。
• 最后，打印值MaxAltSum 。

下面是上述方法的实现：

C++

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to find the maximum sum by alternating
// the signs of adjacent elements of the array
int findMaxSumByAlternatingSign(int arr[], int N)
{
    // Stores count of negative
    // elements in the array
    int cntNeg = 0;
 
    // Stores maximum sum by alternating
    // the signs of adjacent elements
    int MaxAltSum = 0;
 
    // Stores smallest absolute
    // value of array elements
    int SmValue = 0;
 
    // Stores sum of absolute
    // value of array elements
    int sum = 0;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // If arr[i] is
        // a negative number
        if (arr[i] < 0) {
 
            // Update cntNeg
            cntNeg += 1;
        }
 
        // Update sum
        sum += abs(arr[i]);
 
        // Update SmValue
        SmValue = min(SmValue,
                    abs(arr[i]));
    }
 
    // Update MaxAltSum
    MaxAltSum = sum;
 
    // If cntNeg is
    // an odd number
    if (cntNeg & 1) {
 
        // Update MaxAltSum
        MaxAltSum -= 2 * SmValue;
    }
    return MaxAltSum;
}
 
// Drivers Code
int main()
{
 
    int arr[] = { 1, 1, -2, -4, 5 };
    int N = sizeof(arr)
            / sizeof(arr[0]);
 
    cout << findMaxSumByAlternatingSign(
        arr, N);
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to find the maximum sum by alternating
// the signs of adjacent elements of the array
static int findMaxSumByAlternatingSign(int arr[],
                                       int N)
{
     
    // Stores count of negative
    // elements in the array
    int cntNeg = 0;
 
    // Stores maximum sum by alternating
    // the signs of adjacent elements
    int MaxAltSum = 0;
 
    // Stores smallest absolute
    // value of array elements
    int SmValue = 0;
 
    // Stores sum of absolute
    // value of array elements
    int sum = 0;
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // If arr[i] is
        // a negative number
        if (arr[i] < 0)
        {
             
            // Update cntNeg
            cntNeg += 1;
        }
         
        // Update sum
        sum += Math.abs(arr[i]);
         
        // Update SmValue
        SmValue = Math.min(SmValue,
                  Math.abs(arr[i]));
    }
 
    // Update MaxAltSum
    MaxAltSum = sum;
     
    // If cntNeg is
    // an odd number
    if (cntNeg % 2 == 1)
    {
         
        // Update MaxAltSum
        MaxAltSum -= 2 * SmValue;
    }
    return MaxAltSum;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 1, -2, -4, 5 };
    int N = arr.length;
     
    System.out.print(findMaxSumByAlternatingSign(
    arr, N));
}
}
 
// This code is contributed by jana_sayantan

Python3

# Python3 program to implement
# the above approach
 
# Function to find the maximum sum by
# alternating the signs of adjacent
# elements of the array
def findMaxSumByAlternatingSign(arr, N):
     
    # Stores count of negative
    # elements in the array
    cntNeg = 0
 
    # Stores maximum sum by alternating
    # the signs of adjacent elements
    MaxAltSum = 0
 
    # Stores smallest absolute
    # value of array elements
    SmValue = 0
 
    # Stores sum of absolute
    # value of array elements
    sum = 0
 
    # Traverse the array
    for i in range(N):
         
        # If arr[i] is
        # a negative number
        if (arr[i] < 0):
             
            # Update cntNeg
            cntNeg += 1
 
        # Update sum
        sum += abs(arr[i])
 
        # Update SmValue
        SmValue = min(SmValue, abs(arr[i]))
 
    # Update MaxAltSum
    MaxAltSum = sum
 
    # If cntNeg is
    # an odd number
    if (cntNeg & 1):
         
        # Update MaxAltSum
        MaxAltSum -= 2 * SmValue
         
    return MaxAltSum
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 1, 1, -2, -4, 5 ]
    N = len(arr)
 
    print(findMaxSumByAlternatingSign(arr, N))
 
# This code is contributed by SURENDRA_GANGWAR

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to find the maximum sum by alternating
// the signs of adjacent elements of the array
static int findMaxSumByAlternatingSign(int []arr,
                                    int N)
{
     
    // Stores count of negative
    // elements in the array
    int cntNeg = 0;
 
    // Stores maximum sum by alternating
    // the signs of adjacent elements
    int MaxAltSum = 0;
 
    // Stores smallest absolute
    // value of array elements
    int SmValue = 0;
 
    // Stores sum of absolute
    // value of array elements
    int sum = 0;
 
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // If arr[i] is
        // a negative number
        if (arr[i] < 0)
        {
             
            // Update cntNeg
            cntNeg += 1;
        }
         
        // Update sum
        sum += Math.Abs(arr[i]);
         
        // Update SmValue
        SmValue = Math.Min(SmValue,
                Math.Abs(arr[i]));
    }
 
    // Update MaxAltSum
    MaxAltSum = sum;
     
    // If cntNeg is
    // an odd number
    if (cntNeg % 2 == 1)
    {
         
        // Update MaxAltSum
        MaxAltSum -= 2 * SmValue;
    }
    return MaxAltSum;
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 1, -2, -4, 5 };
    int N = arr.Length;
     
    Console.Write(findMaxSumByAlternatingSign(
    arr, N));
}
}
 
// This code is contributed by shivanisinghss2110

Javascript

 
// Javascript program to implement
// the above approach
 
// Function to find the maximum sum by alternating
// the signs of adjacent elements of the array
function findMaxSumByAlternatingSign(arr, N)
{
       
    // Stores count of negative
    // elements in the array
    let cntNeg = 0;
   
    // Stores maximum sum by alternating
    // the signs of adjacent elements
    let MaxAltSum = 0;
   
    // Stores smallest absolute
    // value of array elements
    let SmValue = 0;
   
    // Stores sum of absolute
    // value of array elements
    let sum = 0;
   
    // Traverse the array
    for(let i = 0; i < N; i++)
    {
           
        // If arr[i] is
        // a negative number
        if (arr[i] < 0)
        {
               
            // Update cntNeg
            cntNeg += 1;
        }
           
        // Update sum
        sum += Math.abs(arr[i]);
           
        // Update SmValue
        SmValue = Math.min(SmValue,
                  Math.abs(arr[i]));
    }
   
    // Update MaxAltSum
    MaxAltSum = sum;
       
    // If cntNeg is
    // an odd number
    if (cntNeg % 2 == 1)
    {
           
        // Update MaxAltSum
        MaxAltSum -= 2 * SmValue;
    }
    return MaxAltSum;
}
 
    // Driver Code
    let arr = [ 1, 1, -2, -4, 5 ];
    let N = arr.length;
       
    document.write(findMaxSumByAlternatingSign(
    arr, N));
 
// This code is contributed by souravghosh0416.

输出：

13

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