Skip to content
Related Articles

Related Articles

Improve Article

Minimum count of increment of K size subarrays required to form a given Array

  • Difficulty Level : Hard
  • Last Updated : 16 Aug, 2021
Geek Week

Given an array arr[] and an integer K, the task is to find the minimum number of operations required to change an array B of size N containing all zeros such that every element of B is greater than or equal to arr. i.e., arr[i] >= B[i]. In any operation, you can choose a subarray of B of size K and increment all the elements of the subarray by 1.

Examples: 

Input: arr[] = {1, 2, 3, 4, 5}, K = 2 
Output:
Explanation: 
At first B[] = {0, 0, 0, 0, 0} operations = 0 
Increment subarray a[1:2] by 1 => B = {1, 1, 0, 0, 0}, operations = 1 
Increment subarray a[2:3] by 1 => B = {1, 2, 1, 0, 0}, operations = 2 
Increment subarray a[3:4] by 2 => B = {1, 2, 3, 2, 0}, operations = 4 
Increment subarray a[4:5] by 5 => B = {1, 2, 3, 7, 5}, operations = 9 
Therefore, count of such operations required is 9. 

Input: arr[] = {2, 3, 1}, K = 3 
Output:
Explanation: 
Incrementing the entire array by 3 

Approach: The idea is to increment the subarray of size K whenever there is a B[i] is less than arr[i] and also increment the count of such operations by 1 at each step. To increment the subarray of size K use the Difference array for Range Query update in O(1).



Below is the implementation of the above approach: 

C++




// C++ implementation to find the
// minimum number of operations
// required to change an array of
// all zeros such that every element
// is greater than the given array
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum
// number of operations required
// to change all the array of zeros
// such that every element is greater
// than the given array
int find_minimum_operations(int n, int b[],
                            int k)
{
     
    // Declaring the difference
    // array of size N
    int d[n + 1] = {0};
 
    // Number of operations
    int operations = 0, need;
 
    for(int i = 0; i < n; i++)
    {
         
        // First update the D[i] value
        // with the previous value
        if (i > 0)
        {
            d[i] += d[i - 1];
        }
         
        // The index i has to be incremented
        if (b[i] > d[i])
        {
             
            // We have to perform
            // (b[i]-d[i]) operations more
            operations += b[i] - d[i];
 
            need = b[i] - d[i];
 
            // Increment the range
            // i to i + k by need
            d[i] += need;
 
            // Check if i + k is valid index
            if(i + k <= n)
            {
                d[i + k]-= need;
            }
        }
    }
    cout << operations << endl;
}
 
// Driver Code
int main()
{
    int n = 5;
    int b[] = { 1, 2, 3, 4, 5 };
    int k = 2;
     
    // Function Call
    find_minimum_operations(n, b, k);
     
    return 0;
}
 
// This code is contributed by shubhamsingh10

Java




// Java implementation to find the
// minimum number of operations
// required to change an array of
// all zeros such that every element
// is greater than the given array
class GFG{
 
// Function to find the minimum
// number of operations required
// to change all the array of zeros
// such that every element is greater
// than the given array
static void find_minimum_operations(int n, int b[],
                                    int k)
{
     
    // Declaring the difference
    // array of size N
    int d[] = new int[n + 1];
 
    // Number of operations
    int i, operations = 0, need;
 
    for(i = 0; i < n; i++)
    {
         
        // First update the D[i] value
        // with the previous value
        if (i > 0)
        {
            d[i] += d[i - 1];
        }
         
        // The index i has to be incremented
        if (b[i] > d[i])
        {
             
            // We have to perform
            // (b[i]-d[i]) operations more
            operations += b[i] - d[i];
 
            need = b[i] - d[i];
 
            // Increment the range
            // i to i + k by need
            d[i] += need;
 
            // Check if i + k is valid index
            if(i + k <= n)
            {
                d[i + k]-= need;
            }
        }
    }
    System.out.println(operations);
}
 
// Driver Code
public static void main (String []args)
{
    int n = 5;
    int b[] = { 1, 2, 3, 4, 5 };
    int k = 2;
     
    // Function Call
    find_minimum_operations(n, b, k);
}
}
 
// This code is contributed by chitranayal

Python3




# Python3 implementation to find the
# minimum number of operations required
# to change an array of all zeros
# such that every element is greater than
# the given array
 
# Function to find the minimum
# number of operations required
# to change all the array of zeros
# such that every element is greater
# than the given array
def find_minimum_operations(n, b, k):
 
    # Declaring the difference
    # array of size N
    d =[0 for i in range(n + 1)]
 
    # Number of operations
    operations = 0
 
    for i in range(n):
 
        # First update the D[i] value with
        # the previous value
        d[i]+= d[i-1]
 
        # The index i has to be incremented
        if b[i]>d[i]:
 
            # We have to perform
            # (b[i]-d[i]) operations more
            operations+=(b[i]-d[i])
 
            need =(b[i]-d[i])
 
            # Increment the range
            # i to i + k by need
            d[i]+= need
 
            # Check if i + k is valid index
            if i + k<= n:
                d[i + k]-= need
 
    return operations
 
# Driver Code
if __name__ == "__main__":
    n = 5
    b =[1, 2, 3, 4, 5]
    k = 2
     
    # Function Call
    print(find_minimum_operations(n, b, k))

C#




// C# implementation to find the
// minimum number of operations
// required to change an array of
// all zeros such that every element
// is greater than the given array
using System;
class GFG{
  
// Function to find the minimum
// number of operations required
// to change all the array of zeros
// such that every element is greater
// than the given array
static void find_minimum_operations(int n, int[] b,
                                    int k)
{
      
    // Declaring the difference
    // array of size N
    int[] d = new int[n + 1];
  
    // Number of operations
    int i, operations = 0, need;
  
    for(i = 0; i < n; i++)
    {
          
        // First update the D[i] value
        // with the previous value
        if (i > 0)
        {
            d[i] += d[i - 1];
        }
          
        // The index i has to be incremented
        if (b[i] > d[i])
        {
              
            // We have to perform
            // (b[i]-d[i]) operations more
            operations += b[i] - d[i];
  
            need = b[i] - d[i];
  
            // Increment the range
            // i to i + k by need
            d[i] += need;
  
            // Check if i + k is valid index
            if(i + k <= n)
            {
                d[i + k]-= need;
            }
        }
    }
    Console.Write(operations);
}
  
// Driver Code
public static void Main (string []args)
{
    int n = 5;
    int[] b = { 1, 2, 3, 4, 5 };
    int k = 2;
      
    // Function Call
    find_minimum_operations(n, b, k);
}
}
  
// This code is contributed by rock_cool

Javascript




<script>
 
// Javascript implementation to find the
// minimum number of operations
// required to change an array of
// all zeros such that every element
// is greater than the given array
 
// Function to find the minimum
// number of operations required
// to change all the array of zeros
// such that every element is greater
// than the given array
function find_minimum_operations(n, b, k)
{
 
    // Declaring the difference
    // array of size N
    let d = new Array(n + 1);
    d.fill(0);
 
    // Number of operations
    let i, operations = 0, need;
 
    for(i = 0; i < n; i++)
    {
 
        // First update the D[i] value
        // with the previous value
        if (i > 0)
        {
            d[i] += d[i - 1];
        }
 
        // The index i has to be incremented
        if (b[i] > d[i])
        {
 
            // We have to perform
            // (b[i]-d[i]) operations more
            operations += b[i] - d[i];
 
            need = b[i] - d[i];
 
            // Increment the range
            // i to i + k by need
            d[i] += need;
 
            // Check if i + k is valid index
            if (i + k <= n)
            {
                d[i + k]-= need;
            }
        }
    }
    document.write(operations);
}
 
// Driver code
let n = 5;
let b = [ 1, 2, 3, 4, 5 ];
let k = 2;
   
// Function Call
find_minimum_operations(n, b, k);
 
// This code is contributed by divyesh072019
 
</script>
Output: 
9

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :