Related Articles

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

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

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 ``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

 ``
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