# Minimum replacements with any positive integer to make the array K-increasing

• Last Updated : 15 Feb, 2022

Given an array arr[] of N positive integers and an integer K, The task is to replace minimum number of elements with any positive integer to make the array K-increasing. An array is K-increasing if for every index i in range [K, N), arr[i] ≥ arr[i-K]

Examples:

Input: arr[] = {4, 1, 5, 2, 6, 2}, k = 2
Output: 0
Explanation: Here, for every index i where 2 <= i <= 5, arr[i-2] <= arr[i]
Since the given array is already K-increasing, there is no need to perform any operations.

Input: arr[] = {4, 1, 5, 2, 6, 2}, k = 3
Output: 2
Explanation: Indices 3 and 5 are the only ones not satisfying arr[i-3] <= arr[i] for 3 <= i <= 5.
One of the ways we can make the array K-increasing is by changing arr to 4 and arr to 5.
The array will now be [4,1,5,4,6,5].

Approach: This solution is based on finding the longest increasing subsequence. Since the above question requires that arr[i-K] ≤ arr[i]  should hold for every index i, where K ≤ i ≤ N-1, here the importance is given to compare the elements which are K places away from each other.
So the task is to confirm that the sequences formed by the elements K places away are all non decreasing in nature. If they are not then perform the replacements to make them non-decreasing.

• Traverse the array and form sequence(seq[]) by picking elements K places away from each other in the given array.
• Check if all the elements in seq[] is non-decreasing or not.
• If not then find the length of longest non-decreasing subsequence of seq[].
• Replace the remaining elements to minimize the total number of operations.
• Sum of replacement operations for all such sequences is the final answer.

Follow the below illustration for better understanding.

• For example: arr[] = {4, 1, 5, 2, 6, 0, 1} ,K = 2

Indices: 0  1  2  3  4  5  6
values:  4  1  5  2  6  0 1

So the work is to ensure that following sequences

1. arr, arr, arr, arr => {4, 5, 6, 1}
2. arr, arr, arr => {1, 2, 0}

Obey arr[i-k] <= arr[i]
So for first sequence it can be seen that {4, 5, 6} are K increasing and it is the longest non-decreasing subsequence, whereas 1 is not, so one operation is needed for it.
Similarly, for 2nd {1, 2} are longest non-decreasing whereas 0 is not, so one operation is needed for it.

So total 2 minimum operations are required.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement above approach` `#include ` `using` `namespace` `std;`   `// Functions finds the ` `// longest non decreasing subsequence.` `int` `utility(vector<``int``>& arr, ``int``& n)` `{` `    ``vector<``int``> tail;` `    ``int` `len = 1;` `    ``tail.push_back(arr);` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(tail[len - 1] <= arr[i]) {` `            ``len++;` `            ``tail.push_back(arr[i]);` `        ``}` `        ``else` `{` `            ``auto` `it = upper_bound(tail.begin(), ` `                                  ``tail.end(),` `                                  ``arr[i]);` `            ``*it = arr[i];` `        ``}` `    ``}` `    ``return` `len;` `}`   `// Function to find the minimum operations` `// to make array K-increasing` `int` `kIncreasing(vector<``int``>& a, ``int` `K)` `{` `    ``int` `ans = 0;` `    `  `    ``// Size of array` `    ``int` `N = a.size();` `    ``for` `(``int` `i = 0; i < K; i++)` `    ``{` `        ``// Consider all elements K-places away` `        ``// as a sequence` `        ``vector<``int``> v;` `      `  `        ``for` `(``int` `j = i; j < N; j += K)` `        ``{` `            ``v.push_back(a[j]);` `        ``}` `        `  `        ``// Size of each sequence` `        ``int` `k = v.size();` `       `  `        ``// Store least operations` `        ``// for this sequence` `        ``ans += k - utility(v, k); ` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> arr{ 4, 1, 5, 2, 6, 0, 1 };` `    ``int` `K = 2;` `    ``cout << kIncreasing(arr, K);` `    ``return` `0;` `}`

## Python3

 `# Python code for the above approach `   `def` `lowerBound(a, low, high, element):` `    ``while` `(low < high):` `        ``middle ``=` `low ``+` `(high ``-` `low) ``/``/` `2``;` `        ``if` `(element > a[middle]):` `            ``low ``=` `middle ``+` `1``;` `        ``else``:` `            ``high ``=` `middle;` `    ``return` `low;`   `def` `utility(v):` `    ``if` `(``len``(v) ``=``=` `0``): ``# boundary case` `        ``return` `0``;`   `    ``tail ``=` `[``0``] ``*` `len``(v)` `    ``length ``=` `1``; ``# always points empty slot in tail` `    ``tail[``0``] ``=` `v[``0``];`   `    ``for` `i ``in` `range``(``1``, ``len``(v)):`   `        ``if` `(v[i] > tail[length ``-` `1``]):`   `            ``# v[i] extends the largest subsequence` `            ``length ``+``=` `1` `            ``tail[length] ``=` `v[i];` `    `  `        ``else``:`   `            ``# v[i] will extend a subsequence and` `            ``# discard older subsequence`   `            ``# find the largest value just smaller than` `            ``# v[i] in tail`   `            ``# to find that value do binary search for` `            ``# the v[i] in the range from begin to 0 +` `            ``# length` `            ``idx ``=` `lowerBound(v, ``1``, ``len``(v), v[i]);`   `            ``# binarySearch in C# returns negative` `            ``# value if searched element is not found in` `            ``# array`   `            ``# this negative value stores the` `            ``# appropriate place where the element is` `            ``# supposed to be stored` `            ``if` `(idx < ``0``):` `                ``idx ``=` `-``1` `*` `idx ``-` `1``;`   `            ``# replacing the existing subsequence with` `            ``# new end value` `            ``tail[idx] ``=` `v[i];` `    ``return` `length;`       `# Function to find the minimum operations` `# to make array K-increasing` `def` `kIncreasing(a, K):` `    ``ans ``=` `0``;`   `    ``# Size of array` `    ``N ``=` `len``(a)` `    ``for` `i ``in` `range``(K):` `        ``# Consider all elements K-places away` `        ``# as a sequence` `        ``v ``=` `[];`   `        ``for` `j ``in` `range``(i, N, K):` `            ``v.append(a[j]);`   `        ``# Size of each sequence` `        ``k ``=` `len``(v);`   `        ``# Store least operations` `        ``# for this sequence` `        ``ans ``+``=` `k ``-` `utility(v);` `    ``return` `ans;`   `# Driver code` `arr ``=` `[``4``, ``1``, ``5``, ``2``, ``6``, ``0``, ``1``];` `K ``=` `2``;` `print``(kIncreasing(arr, K));`   `# This code is contributed by gfgking`

## C#

 `// C# code for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` `  ``static` `int` `lowerBound(List<``int``> a, ``int` `low, ``int` `high,` `                        ``int` `element)` `  ``{` `    ``while` `(low < high) {` `      ``int` `middle = low + (high - low) / 2;` `      ``if` `(element > a[middle])` `        ``low = middle + 1;` `      ``else` `        ``high = middle;` `    ``}` `    ``return` `low;` `  ``}` `  ``static` `int` `utility(List<``int``> v, ``int` `n)` `  ``{` `    ``if` `(v.Count == 0) ``// boundary case` `      ``return` `0;`   `    ``int``[] tail = ``new` `int``[v.Count];` `    ``int` `length = 1; ``// always points empty slot in tail` `    ``tail = v;`   `    ``for` `(``int` `i = 1; i < v.Count; i++) {`   `      ``if` `(v[i] > tail[length - 1]) {`   `        ``// v[i] extends the largest subsequence` `        ``tail[length++] = v[i];` `      ``}` `      ``else` `{`   `        ``// v[i] will extend a subsequence and` `        ``// discard older subsequence`   `        ``// find the largest value just smaller than` `        ``// v[i] in tail`   `        ``// to find that value do binary search for` `        ``// the v[i] in the range from begin to 0 +` `        ``// length` `        ``var` `idx = lowerBound(v, 1, v.Count, v[i]);`   `        ``// binarySearch in C# returns negative` `        ``// value if searched element is not found in` `        ``// array`   `        ``// this negative value stores the` `        ``// appropriate place where the element is` `        ``// supposed to be stored` `        ``if` `(idx < 0)` `          ``idx = -1 * idx - 1;`   `        ``// replacing the existing subsequence with` `        ``// new end value` `        ``tail[idx] = v[i];` `      ``}` `    ``}` `    ``return` `length;` `  ``}`   `  ``// Function to find the minimum operations` `  ``// to make array K-increasing` `  ``static` `int` `kIncreasing(``int``[] a, ``int` `K)` `  ``{` `    ``int` `ans = 0;`   `    ``// Size of array` `    ``int` `N = a.Length;` `    ``for` `(``int` `i = 0; i < K; i++)` `    ``{` `      `  `      ``// Consider all elements K-places away` `      ``// as a sequence` `      ``List<``int``> v = ``new` `List<``int``>();`   `      ``for` `(``int` `j = i; j < N; j += K) {` `        ``v.Add(a[j]);` `      ``}`   `      ``// Size of each sequence` `      ``int` `k = v.Count;`   `      ``// Store least operations` `      ``// for this sequence` `      ``ans += k - utility(v, k);` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 4, 1, 5, 2, 6, 0, 1 };` `    ``int` `K = 2;` `    ``Console.Write(kIncreasing(arr, K));` `  ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`2`

Time Complexity: O(K * N * logN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :