Minimum count of increment of K size subarrays required to form a given Array
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: 9
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: 3
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 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 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# 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
<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>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Minimum cost required to convert all Subarrays of size K to a single element Prerequisite: Sliding Window MedianGiven an array arr[] consisting of N integers and an integer K, the task is to find the minimum cost required to make each element of every subarray of length K equal. Cost of replacing any array element by another element is the absolute difference between the two
11 min read
Divide an array into k subarrays with minimum cost II Given an array of integers arr[] of length n and two positive integers kk and len. The cost of an array is the value of its first element. For example, the cost of [2,3,4] is 2 and the cost of [4,1,2] is 4. You have to divide arr[] into k disjoint contiguous subarrays such that the difference betwee
11 min read
Minimum common element in all subarrays of size K Given an array arr[] consisting of N distinct integers and a positive integer K, the task is to find the minimum element that occurs in all subarrays of size K. If no such element exists, then print "-1". Examples: Input: arr[] = {1, 2, 3, 4, 5}, K = 4Output: 2Explanation:The subarrays of size 4 are
7 min read
Count of subarrays of size K with average at least M Given an array arr[] consisting of N integers and two positive integers K and M, the task is to find the number of subarrays of size K whose average is at least M. Examples: Input: arr[] = {2, 3, 3, 4, 4, 4, 5, 6, 6}, K = 3, M = 4Output: 4Explanation:Below are the subarrays of size K(= 3) whose aver
7 min read
Find an array of size N having exactly K subarrays with sum S Given three integers N, K and S, the task is to choose an array of size N such that there exists exactly K sub-arrays with sum S.Note: There can be many solution arrays to this problem.Examples: Input: N = 4, K = 2, S = 3 Output: 1 2 3 4 Explanation: One of the possible array is [ 1, 2, 3, 4 ] There
4 min read