最小化使数组元素的总和和乘积非零所需的增量或减量

给定一个由N 个整数组成的数组arr[] ，任务是计算数组上所需的递增或递减操作的最小次数，使得数组arr[]的所有元素的总和和乘积不为零。

例子：

Input: arr[] = {-1, -1, 0, 0}
Output: 2
Explanation: Perform the following operations to update the array as:
Operation 1: Incrementing arr[2] modifies arry to {-1, -1, 1, 0}.
Operation 2: Decrementing arr[3] modifies array to {-1, -1, 1, -1}.
Therefore, the sum and product of the above array is -2 and -1 which is non-zero.

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

方法：根据以下观察可以解决给定的问题：

• 使数组乘积非零所需的最小步骤以及使乘积为非零的所有元素必须为非零。
• 如果总和为负，则使数组的总和非零所需的最小步骤，然后将所有0s元素减1 ，如果总和为正，则将所有零元素增加1 ，如果总和不为零，则，简单地增加或减少数组的任何元素。

请按照以下步骤解决此问题：

1. 遍历给定的数组并计算数组中零的数量。
2. 求给定数组的总和。
3. 如果零的计数大于 0，则结果就是该计数。
4. 否则，如果总和等于 0，则结果为1 。
5. 否则结果将为0 。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the sum of array
int array_sum(int arr[], int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
 
    // Return the sum
    return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
int countOperations(int arr[], int N)
{
    // Stores count of zero elements
    int count_zeros = 0;
 
    // Iterate over the array to
    // count zero elements
    for (int i = 0; i < N; i++) {
        if (arr[i] == 0)
            count_zeros++;
    }
 
    // Sum of elements of the array
    int sum = array_sum(arr, N);
 
    // Print the result
    if (count_zeros)
        return count_zeros;
 
    if (sum == 0)
        return 1;
 
    return 0;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { -1, -1, 0, 0 };
 
    // Size of array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << countOperations(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{
   
// Function to find the
// sum of array
static int array_sum(int arr[],
                     int n)
{
  int sum = 0;
   
  for (int i = 0; i < n; i++)
    sum += arr[i];
 
  // Return the sum
  return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
static int countOperations(int arr[],
                           int N)
{
  // Stores count of zero
  // elements
  int count_zeros = 0;
 
  // Iterate over the array to
  // count zero elements
  for (int i = 0; i < N; i++)
  {
    if (arr[i] == 0)
      count_zeros++;
  }
 
  // Sum of elements of the
  // array
  int sum = array_sum(arr, N);
 
  // Print the result
  if (count_zeros != 0)
    return count_zeros;
 
  if (sum == 0)
    return 1;
 
  return 0;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array arr[]
  int arr[] = {-1, -1, 0, 0};
 
  // Size of array
  int N = arr.length;
 
  // Function Call
  System.out.print(countOperations(arr, N));
}
}
 
// This code is contributed by sanjoy_62

Python3

# Python3 program for the
# above approach
 
# Function to find the
# sum of array
def array_sum(arr, n):
   
    sum = 0
     
    for i in range(n):
        sum += arr[i]
         
    # Return the sum
    return sum
 
# Function that counts the minimum
# operations required to make the
# sum and product of array non-zero
def countOperations(arr, N):
   
    # Stores count of zero
    # elements
    count_zeros = 0
 
    # Iterate over the array to
    # count zero elements
    for i in range(N):
        if (arr[i] == 0):
            count_zeros+=1
 
    # Sum of elements of the
    # array
    sum = array_sum(arr, N)
 
    # Prthe result
    if (count_zeros):
        return count_zeros
 
    if (sum == 0):
        return 1
 
    return 0
 
# Driver Code
if __name__ == '__main__':
   
    # Given array arr[]
    arr = [-1, -1, 0, 0]
 
    # Size of array
    N = len(arr)
 
    # Function Call
    print(countOperations(arr, N))
 
# This code is contributed by Mohit Kumar 29

C#

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find the
// sum of array
static int array_sum(int[] arr,
                     int n)
{
  int sum = 0;
   
  for(int i = 0; i < n; i++)
    sum += arr[i];
 
  // Return the sum
  return sum;
}
 
// Function that counts the minimum
// operations required to make the
// sum and product of array non-zero
static int countOperations(int[] arr,
                           int N)
{
   
  // Stores count of zero
  // elements
  int count_zeros = 0;
 
  // Iterate over the array to
  // count zero elements
  for(int i = 0; i < N; i++)
  {
    if (arr[i] == 0)
      count_zeros++;
  }
 
  // Sum of elements of the
  // array
  int sum = array_sum(arr, N);
 
  // Print the result
  if (count_zeros != 0)
    return count_zeros;
 
  if (sum == 0)
    return 1;
 
  return 0;
}
 
// Driver Code
public static void Main()
{
   
  // Given array arr[]
  int[] arr = { -1, -1, 0, 0 };
 
  // Size of array
  int N = arr.Length;
 
  // Function call
  Console.Write(countOperations(arr, N));
}
}
 
// This code is contributed by code_hunt

Javascript

 
// Javascript program for the above approach
 
    // Function to find the
    // sum of array
    function array_sum(arr , n) {
        var sum = 0;
 
        for (i = 0; i < n; i++)
            sum += arr[i];
 
        // Return the sum
        return sum;
    }
 
    // Function that counts the minimum
    // operations required to make the
    // sum and product of array non-zero
    function countOperations(arr , N) {
        // Stores count of zero
        // elements
        var count_zeros = 0;
 
        // Iterate over the array to
        // count zero elements
        for (i = 0; i < N; i++) {
            if (arr[i] == 0)
                count_zeros++;
        }
 
        // Sum of elements of the
        // array
        var sum = array_sum(arr, N);
 
        // Prvar the result
        if (count_zeros != 0)
            return count_zeros;
 
        if (sum == 0)
            return 1;
 
        return 0;
    }
 
    // Driver Code
     
        // Given array arr
        var arr = [ -1, -1, 0, 0 ];
 
        // Size of array
        var N = arr.length;
 
        // Function Call
        document.write(countOperations(arr, N));
 
// This code contributed by umadevi9616
 

输出：

2

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

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