Minimize operations to make all array elements -1 by changing maximums of K-size subarray to -1

Given an array arr[] consisting of N integers and an integer K, the task is to find the minimum of operations required to make all the array elements -1 such that in each operation, choose a subarray of size K and change all the maximum element in the subarray to -1.

Examples:

Input: arr[] = {18, 11, 18, 11, 18}, K = 3 
Output: 3
Explanation:
Following are the operations performed:

1. Choosing the sub array from index 0 to 2 and by applying the operation, modifies the array to {-1, 11, -1, 11, 18}.
2. Choosing the sub array form index 1 to 3 and by applying the operation, modifies the array to {-1, -1, -1, -1, 18}.
3. Choosing the sub array form index 2 to 4 and by applying the operation, modifies the array to {-1, -1, -1, -1, -1}.

After the above operations all the array elements become -1. Therefore, the minimum number of operations required is 3.

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

Approach: The given problem can be solved by sorting the array arr[] with indices and then counting the number of operations by choosing the array elements from the end where the difference between the indices is less than K. Follow the below steps to solve the problem:

• Initialize a vector of pairs, say vp[] that stores the array elements with their indices.
• Initialize a variable, say minCnt as 0 that stores the count of the minimum number of operations.
• Traverse the array arr[] and push the arr[i] along with its index i in the vector vp.
• Sort the vector of pairs vp[] with respect to the first value.
• Traverse the vector vp[] until it is not empty and perform the following steps:
  • Increment the value of minCnt by 1.
  • Pop all the elements from the vector vp[] from the back having the same value (first element of each pair) and having differences between indices less than K.
• After completing the above steps, print the value of minCnt as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find minimum the number
// of operations required to make all
// the array elements to -1
int minOperations(int arr[], int N, int K)
{

    // Stores the array elements with
    // their corresponding indices
    vector<pair<int, int> > vp;
    for (int i = 0; i < N; i++) {

        // Push the array element
        // and it's index
        vp.push_back({ arr[i], i });
    }

    // Sort the elements according
    // to it's first value
    sort(vp.begin(), vp.end());

    // Stores the minimum number of
    // operations required
    int minCnt = 0;

    // Traverse until vp is not empty
    while (!vp.empty()) {
        int val, ind;

        // Stores the first value of vp
        val = vp.back().first;

        // Stores the second value of vp
        ind = vp.back().second;

        // Update the minCnt
        minCnt++;

        // Pop the back element from the
        // vp until the first value is
        // same as val and difference
        // between indices is less than K
        while (!vp.empty()
               && vp.back().first == val
               && ind - vp.back().second + 1 <= K)
            vp.pop_back();
    }

    // Return the minCnt
    return minCnt;
}

// Driver Code
int main()
{
    int arr[] = { 18, 11, 18, 11, 18 };
    int K = 3;
    int N = sizeof(arr) / sizeof(arr[0]);

    cout << minOperations(arr, N, K);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG{
    static class pair
    {
        int first, second;
        public pair(int first, int second)
        {
            this.first = first;
            this.second = second;
        }
    }

// Function to find minimum the number
// of operations required to make all
// the array elements to -1
static int minOperations(int arr[], int N, int K)
{

    // Stores the array elements with
    // their corresponding indices
    Vector<pair> vp = new Vector<pair>();
    for (int i = 0; i < N; i++) {

        // Push the array element
        // and it's index
        vp.add(new pair( arr[i], i ));
    }

    // Sort the elements according
    // to it's first value
    Collections.sort(vp,(a,b)->a.first-b.first);

    // Stores the minimum number of
    // operations required
    int minCnt = 0;

    // Traverse until vp is not empty
    while (!vp.isEmpty()) {
        int val, ind;

        // Stores the first value of vp
        val = vp.get(vp.size()-1).first;

        // Stores the second value of vp
        ind = vp.get(vp.size()-1).second;

        // Update the minCnt
        minCnt++;

        // Pop the back element from the
        // vp until the first value is
        // same as val and difference
        // between indices is less than K
        while (!vp.isEmpty()
               && vp.get(vp.size()-1).first == val
               && ind - vp.get(vp.size()-1).second + 1 <= K)
            vp.remove(vp.size()-1);
    }

    // Return the minCnt
    return minCnt;
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 18, 11, 18, 11, 18 };
    int K = 3;
    int N = arr.length;

    System.out.print(minOperations(arr, N, K));

}
}

// This code is contributed by shikhasingrajput

Python3

# Python 3 program for the above approach

# Function to find minimum the number
# of operations required to make all
# the array elements to -1
def minOperations(arr, N, K):

    # Stores the array elements with
    # their corresponding indices
    vp = []
    for i in range(N):

        # Push the array element
        # and it's index
        vp.append([arr[i], i])

    # Sort the elements according
    # to it's first value
    vp.sort()

    # Stores the minimum number of
    # operations required
    minCnt = 0

    # Traverse until vp is not empty
    while (len(vp) != 0):

        # Stores the first value of vp
        val = vp[-1][0]

        # Stores the second value of vp
        ind = vp[-1][1]

        # Update the minCnt
        minCnt += 1

        # Pop the back element from the
        # vp until the first value is
        # same as val and difference
        # between indices is less than K
        while (len(vp) != 0
               and vp[-1][0] == val
               and ind - vp[-1][1] + 1 <= K):
            vp.pop()

    # Return the minCnt
    return minCnt

# Driver Code
if __name__ == "__main__":

    arr = [18, 11, 18, 11, 18]
    K = 3
    N = len(arr)

    print(minOperations(arr, N, K))

    # This code is contributed by mukesh07.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

public class GFG{
    class pair : IComparable<pair>
    {
        public int first,second;
        public pair(int first, int second)
        {
            this.first = first;
            this.second = second;
        }

        public int CompareTo(pair p)
        {
            return this.first - p.first;
        }
    }

// Function to find minimum the number
// of operations required to make all
// the array elements to -1
static int minOperations(int []arr, int N, int K)
{

    // Stores the array elements with
    // their corresponding indices
    List<pair> vp = new List<pair>();
    for (int i = 0; i < N; i++) {

        // Push the array element
        // and it's index
        vp.Add(new pair( arr[i], i ));
    }

    // Sort the elements according
    // to it's first value
    vp.Sort();

    // Stores the minimum number of
    // operations required
    int minCnt = 0;

    // Traverse until vp is not empty
    while (vp.Count!=0) {
        int val, ind;

        // Stores the first value of vp
        val = vp[vp.Count-1].first;

        // Stores the second value of vp
        ind = vp[vp.Count-1].second;

        // Update the minCnt
        minCnt++;

        // Pop the back element from the
        // vp until the first value is
        // same as val and difference
        // between indices is less than K
        while (vp.Count!=0
               && vp[vp.Count-1].first == val
               && ind - vp[vp.Count-1].second + 1 <= K)
            vp.RemoveAt(vp.Count-1);
    }

    // Return the minCnt
    return minCnt;
}

// Driver Code
public static void Main(String[] args)
{
    int []arr = { 18, 11, 18, 11, 18 };
    int K = 3;
    int N = arr.Length;

    Console.Write(minOperations(arr, N, K));

}
}

// This code is contributed by shikhasingrajput

Javascript

<script>
       // JavaScript Program to implement
       // the above approach

       // Function to find minimum the number
       // of operations required to make all
       // the array elements to -1
       function minOperations(arr, N, K)
       {

           // Stores the array elements with
           // their corresponding indices
           let vp = [];
           for (let i = 0; i < N; i++)
           {

               // Push the array element
               // and it's index
               vp.push({ "first": arr[i], "second": i });
           }

           // Sort the elements according
           // to it's first value
           vp.sort(function (a, b) { return a.first - b.first; });

           // Stores the minimum number of
           // operations required
           let minCnt = 0;

           // Traverse until vp is not empty
           while (vp.length > 0) {
               let val, ind;

               // Stores the first value of vp
               val = vp[vp.length - 1].first;

               // Stores the second value of vp
               ind = vp[vp.length - 1].second;

               // Update the minCnt
               minCnt++;

               // Pop the back element from the
               // vp until the first value is
               // same as val and difference
               // between indices is less than K
               while (vp.length > 0
                   && (vp[vp.length - 1].first == val)
                   && (ind - vp[vp.length - 1].second + 1 <= K)) {
                   vp.pop();
               }
           }

           // Return the minCnt
           return minCnt;
       }

       // Driver Code
       let arr = [18, 11, 18, 11, 18];
       let K = 3;
       let N = arr.length;

       document.write(minOperations(arr, N, K));

    // This code is contributed by Potta Lokesh
   </script>

Output:

3

Time Complexity: O(N log N)
Auxiliary Space: O(N)