精确地k更改后可获得的最大数组和

给定一个由n个整数和一个整数k组成的数组arr [] 。任务是在精确执行k次给定操作后，最大化数组的总和。在单个操作中，可以将数组的任何元素乘以-1，即可以更改元素的符号。

例子：

Input: arr[] = {-5, 4, 1, 3, 2}, k = 4
Output: 13
Change the sign of -5 once and then change the sign of 1 three times.
Thus it changes to -1 and the sum will be 5 + 4 + (-1) + 3 + 2 = 13.

Input: arr[] = {-1, -1, 1}, k = 1
Output: 1

方法：如果数组中负元素的数量为count ，

1. 如果count≥k，则恰好是k个负数的符号将从最小的符号开始更改。
2. 如果count 则将所有负元素的符号更改为正，对于其余操作，即rem = k – count ，
   • 如果rem％2 = 0，那么将不会对当前数组进行任何更改，因为更改元素的符号两次会给出原始编号。
   • 如果rem％2 = 1，则更改更新数组中最小元素的符号。
3. 最后，打印更新后的数组元素的总和。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
  
// Utility function to return the sum
// of the array elements
int sumArr(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
  
    return sum;
}
  
// Function to return the maximized sum
// of the array after performing
// the given operation exactly k times
int maxSum(int arr[], int n, int k)
{
    // Sort the array elements
    sort(arr, arr + n);
  
    int i = 0;
    // Change signs of the negative elements
    // starting from the smallest
    while (i < n && k > 0 && arr[i] < 0) {
        arr[i] *= -1;
        k--;
        i++;
    }
  
    // If a single operation has to be
    // performed then it must be performed
    // on the smallest positive element
    if (k % 2 == 1) {
  
        // To store the index of the
        // minimum element
        int min = 0;
        for (i = 1; i < n; i++)
  
            // Update the minimum index
            if (arr[min] > arr[i])
                min = i;
  
        // Perform remaining operation
        // on the smallest element
        arr[min] *= -1;
    }
  
    // Return the sum of the updated array
    return sumArr(arr, n);
}
  
// Driver code
int main()
{
    int arr[] = { -5, 4, 1, 3, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;
  
    cout << maxSum(arr, n, k) << endl;
  
    return 0;
}

Java

// Java implementation of the above approach
import java.util.Arrays;
  
class GFG 
{
  
// Utility function to return the sum
// of the array elements
static int sumArr(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
  
    return sum;
}
  
// Function to return the maximized sum
// of the array after performing
// the given operation exactly k times
static int maxSum(int arr[], int n, int k)
{
    // Sort the array elements
    Arrays.sort(arr);
  
    int i = 0;
      
    // Change signs of the negative elements
    // starting from the smallest
    while (i < n && k > 0 && arr[i] < 0)
    {
        arr[i] *= -1;
        k--;
        i++;
    }
  
    // If a single operation has to be
    // performed then it must be performed
    // on the smallest positive element
    if (k % 2 == 1) 
    {
  
        // To store the index of the
        // minimum element
        int min = 0;
        for (i = 1; i < n; i++)
  
            // Update the minimum index
            if (arr[min] > arr[i])
                min = i;
  
        // Perform remaining operation
        // on the smallest element
        arr[min] *= -1;
    }
  
    // Return the sum of the updated array
    return sumArr(arr, n);
}
  
// Driver code
public static void main(String[] args)
{
    int arr[] = { -5, 4, 1, 3, 2 };
    int n = arr.length;
    int k = 4;
  
    System.out.println(maxSum(arr, n, k));
}
}
  
/* This code contributed by PrinciRaj1992 */

Python3

# Python 3 implementation of the approach
  
# Utility function to return the sum
# of the array elements
def sumArr(arr, n):
    sum = 0
    for i in range(n):
        sum += arr[i]
  
    return sum
  
# Function to return the maximized sum
# of the array after performing
# the given operation exactly k times
def maxSum(arr, n, k):
      
    # Sort the array elements
    arr.sort(reverse = False)
  
    i = 0
      
    # Change signs of the negative elements
    # starting from the smallest
    while (i < n and k > 0 and arr[i] < 0):
        arr[i] *= -1
        k -= 1
        i += 1
  
    # If a single operation has to be
    # performed then it must be performed
    # on the smallest positive element
    if (k % 2 == 1):
          
        # To store the index of the
        # minimum element
        min = 0
        for i in range(1, n):
              
            # Update the minimum index
            if (arr[min] > arr[i]):
                min = i
  
        # Perform remaining operation
        # on the smallest element
        arr[min] *= -1
  
    # Return the sum of the updated array
    return sumArr(arr, n)
  
# Driver code
if __name__ == '__main__':
    arr = [-5, 4, 1, 3, 2]
    n = len(arr)
    k = 4
  
    print(maxSum(arr, n, k))
  
# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the above approach
using System; 
using System.Linq; 
  
class GFG 
{ 
  
// Utility function to return the sum 
// of the array elements 
static int sumArr(int [] arr, int n) 
{ 
    int sum = 0; 
    for (int i = 0; i < n; i++) 
        sum += arr[i]; 
  
    return sum; 
} 
  
// Function to return the maximized sum 
// of the array after performing 
// the given operation exactly k times 
static int maxSum(int [] arr, int n, int k) 
{ 
    // Sort the array elements 
    Array.Sort(arr); 
  
    int i = 0; 
      
    // Change signs of the negative elements 
    // starting from the smallest 
    while (i < n && k > 0 && arr[i] < 0) 
    { 
        arr[i] *= -1; 
        k--; 
        i++; 
    } 
  
    // If a single operation has to be 
    // performed then it must be performed 
    // on the smallest positive element 
    if (k % 2 == 1) 
    { 
  
        // To store the index of the 
        // minimum element 
        int min = 0; 
        for (i = 1; i < n; i++) 
  
            // Update the minimum index 
            if (arr[min] > arr[i]) 
                min = i; 
  
        // Perform remaining operation 
        // on the smallest element 
        arr[min] *= -1; 
    } 
  
    // Return the sum of the updated array 
    return sumArr(arr, n); 
} 
  
// Driver code 
static void Main() 
{ 
    int []arr= { -5, 4, 1, 3, 2 }; 
    int n = arr.Length; 
    int k = 4; 
  
    Console.WriteLine(maxSum(arr, n, k)); 
} 
} 
  
// This code is contributed by mohit kumar 29

PHP

 0 &&
                $arr[$i] < 0)
    {
        $arr[$i] *= -1;
        $k--;
        $i++;
    }
  
    // If a single operation has to be
    // performed then it must be performed
    // on the smallest positive element
    if ($k % 2 == 1) 
    {
  
        // To store the index of the
        // minimum element
        $min = 0;
        for ($i = 1; $i < $n; $i++)
  
            // Update the minimum index
            if ($arr[$min] > $arr[$i])
                $min = $i;
  
        // Perform remaining operation
        // on the smallest element
        $arr[$min] *= -1;
    }
  
    // Return the sum of the updated array
    return sumArr($arr, $n);
}
  
// Driver code
$arr = array( -5, 4, 1, 3, 2 );
$n = sizeof($arr);
$k = 4;
  
echo maxSum($arr, $n, $k), "\n";
  
// This code is contributed by ajit.
?>

输出：

13