最小化连续删除相同类型的元素以清空给定数组

给定一个由N 个正整数组成的数组A[ ] ，这样每个数组元素A _i表示第i^个类型元素的计数，任务是最小化相同类型连续元素的删除次数以清空给定数组.

例子：

Input : A[ ] = {3, 3, 2} 
Output: 0 
Explanation: The array consists of 3, 3, 2 elements of 1^st, 2^nd and 3^rd type respectively. By removing the array elements in the order {2, 1, 2, 3, 1, 3, 1}, a sequence is obtained in which no two consecutive elements are removed which are of the same type. Therefore, the count is 0.

Input: A [ ] = {1, 4, 1} 
Output: 1 
Explanation: The array consists of 1, 4, 1 elements of 1^st, 2^nd and 3^rd type respectively. By removing the array elements in the order { 2, 3, 2, 2, 1, 2}, consecutive deletions of same type elements is reduced to 1. Therefore, the count is 1. 

方法：该问题可以通过Greedy Approach解决。请按照以下步骤解决问题：

• 对给定的数组进行排序。
• 计算数组元素的总和。
• 找出数组中存在的最大元素，即A _N-1。 .
• 如果总和和最大元素之间的差大于最大元素，则打印 0 作为所需答案。
• 否则，打印2* max – sum -1作为所需答案。

下面是上述方法的实现。

C++

// C++ implementation of the above approach
#include 
using namespace std;
  
// Function to count minimum consecutive
// removals of elements of the same type
void minRemovals(int A[], int N)
{
  
    // Sort the array
    sort(A, A + N);
  
    // Stores the maximum element
    // present in the array
    int mx = A[N - 1];
  
    // Stores sum of the array
    int sum = 1;
  
    // Calculate sum of the array
    for (int i = 0; i < N; i++) {
        sum += A[i];
    }
  
    if (sum - mx >= mx) {
        cout << 0 << "\n";
    }
    else {
        cout << 2 * mx - sum << "\n";
    }
}
  
// Driver Code
int main()
{
    int A[] = { 3, 3, 2 };
    int N = sizeof(A) / sizeof(A[0]);
  
    // Function call
    minRemovals(A, N);
    return 0;
}

Java

// Java implementation of the above approach
import java.util.Arrays;
  
class GFG 
{
      
    // Function to count minimum consecutive
    // removals of elements of the same type
    static void minRemovals(int []A, int N)
    {
      
        // Sort the array
        Arrays.sort(A);
      
        // Stores the maximum element
        // present in the array
        int mx = A[N - 1];
      
        // Stores sum of the array
        int sum = 1;
      
        // Calculate sum of the array
        for (int i = 0; i < N; i++)
        {
            sum += A[i];
        }
      
        if (sum - mx >= mx) {
            System.out.println(0);
        }
        else {
            System.out.println(2 * mx - sum);
        }
    }
      
    // Driver Code
    public static void main(String[] args) {
          
        int []A = { 3, 3, 2 };
        int N = A.length;
      
        // Function call
        minRemovals(A, N);
          
    }
}
  
// This code is contributed by AnkThon

Python3

# Python3 implementation of the above approach
  
# Function to count minimum consecutive 
# removals of elements of the same type 
def minRemovals(A, N):
      
    # Sort the array
    A.sort()
  
    # Stores the maximum element 
    # present in the array 
    mx = A[N - 1]
  
    # stores the sum of array
    sum = 1
  
    # Calculate sum of array
    for i in range(0, N):
        sum += A[i]
  
    if ((sum - mx) >= mx):
        print(0, end = "")
    else:
        print(2 * mx - sum, end = "")
  
# Driver Code  
if __name__ == "__main__" :
      
    A = [ 3, 3, 2 ]
    N = len(A)
      
    # Function call 
    minRemovals(A, N) 
  
# This code is contributed by Virusbuddah

C#

// C# implementation of the above approach
using System;
  
class GFG 
{
      
    // Function to count minimum consecutive
    // removals of elements of the same type
    static void minRemovals(int []A, int N)
    {
      
        // Sort the array
        Array.Sort(A);
      
        // Stores the maximum element
        // present in the array
        int mx = A[N - 1];
      
        // Stores sum of the array
        int sum = 1;
      
        // Calculate sum of the array
        for (int i = 0; i < N; i++)
        {
            sum += A[i];
        }
      
        if (sum - mx >= mx) 
        {
            Console.WriteLine(0);
        }
        else
        {
            Console.WriteLine(2 * mx - sum);
        }
    }
      
    // Driver Code
    public static void Main(String[] args) 
    {
        int []A = { 3, 3, 2 };
        int N = A.Length;
      
        // Function call
        minRemovals(A, N);      
    }
}
  
// This code is contributed by shikhasingrajput

Javascript

  
// JavaScript program for above approach
  
    // Function to count minimum consecutive
    // removals of elements of the same type
    function minRemovals(A, N)
    {
       
        // Sort the array
        A.sort();
       
        // Stores the maximum element
        // present in the array
        let mx = A[N - 1];
       
        // Stores sum of the array
        let sum = 1;
       
        // Calculate sum of the array
        for (let i = 0; i < N; i++)
        {
            sum += A[i];
        }
       
        if (sum - mx >= mx) {
             document.write(0);
        }
        else {
             document.write(2 * mx - sum);
        }
    }
  
// Driver Code
  
     let A = [3, 3, 2 ];
        let N = A.length;
       
        // Function call
        minRemovals(A, N);
       
     // This code is contributed by avijitmondal1998.

输出

0

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

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