Minimum Operations to Make the Array K-Increasing

Minimum Operations to Make the Array K-Increasing - Problem

You have an array of positive integers and need to make it K-increasing with minimum operations.

An array is K-increasing if every element is less than or equal to the element that is k positions ahead: arr[i] <= arr[i+k] for all valid indices.

Example: Array [4, 1, 5, 2, 6, 2] with k=2:

arr[0] <= arr[2] → 4 <= 5 ✓
arr[1] <= arr[3] → 1 <= 2 ✓
arr[2] <= arr[4] → 5 <= 6 ✓
arr[3] <= arr[5] → 2 <= 2 ✓

In one operation, you can change any element to any positive integer. Find the minimum operations needed to make the array K-increasing.

Input & Output

example_1.py — Basic K-increasing

$ Input: arr = [5,4,3,2,1], k = 1

› Output: 4

💡 Note: For k=1, array must be non-decreasing. Need to change 4 elements: [5,4,3,2,1] → [1,1,1,1,1] or similar

example_2.py — Multiple subsequences

$ Input: arr = [4,1,5,2,6,2], k = 2

› Output: 1

💡 Note: Subsequence 1: [4,5,6] (positions 0,2,4) - already increasing, 0 changes. Subsequence 2: [1,2,2] (positions 1,3,5) - need 1 change to make [1,2,3]

example_3.py — Already K-increasing

$ Input: arr = [1,2,3,4,5], k = 3

› Output: 0

💡 Note: Array is already 3-increasing: positions (0,3): 1≤4, positions (1,4): 2≤5. No changes needed

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
1 ≤ k ≤ arr.length
Important: All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Group by Rows

Divide people into k groups based on their row pattern

Find Optimal Heights

For each group, find the longest sequence that's already properly ordered

Adjust Heights

Change heights of people who break the viewing rule

Count Changes

Sum up all height adjustments needed

Key Takeaway

🎯 Key Insight: Transform the K-increasing problem into k independent LIS problems, then use binary search for optimal O(n log n) solution

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal approach uses the Longest Increasing Subsequence (LIS) algorithm with binary search. Key insight: split the array into k independent subsequences (every k-th element), find the LIS for each subsequence, and change the remaining elements. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + LIS (Optimal)	O(n log n)	O(n)	Split array into k subsequences and find LIS for each using binary search
Brute Force (Try All Combinations)	O(max(arr)^n)	O(n)	Try all possible value assignments and count minimum changes

Binary Search + LIS (Optimal) — Algorithm Steps

Split the array into k subsequences based on index modulo k
For each subsequence, find the longest increasing subsequence using binary search
The elements not in LIS need to be changed
Sum up the changes needed for all k subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Array

Divide array into k subsequences by index % k

Find LIS

Use binary search to find longest increasing subsequence

Count Changes

Elements not in LIS need to be changed

Sum Operations

Total operations = sum of changes for all subsequences

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findLIS(int* seq, int len) {
    if (len == 0) return 0;
    
    int* tails = malloc(len * sizeof(int));
    int tailsLen = 0;
    
    for (int i = 0; i < len; i++) {
        int num = seq[i];
        int left = 0, right = tailsLen;
        
        while (left < right) {
            int mid = (left + right) / 2;
            if (tails[mid] <= num) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        
        if (left == tailsLen) {
            tails[tailsLen++] = num;
        } else {
            tails[left] = num;
        }
    }
    
    int result = tailsLen;
    free(tails);
    return result;
}

int kIncreasingArray(int* arr, int n, int k) {
    int totalOperations = 0;
    
    for (int start = 0; start < k; start++) {
        int* subsequence = malloc((n/k + 1) * sizeof(int));
        int subLen = 0;
        
        for (int i = start; i < n; i += k) {
            subsequence[subLen++] = arr[i];
        }
        
        int lisLength = findLIS(subsequence, subLen);
        int operationsNeeded = subLen - lisLength;
        totalOperations += operationsNeeded;
        
        free(subsequence);
    }
    
    return totalOperations;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

We process each element once and for each do binary search in O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Space for storing the k subsequences and LIS arrays

⚡ Linearithmic Space

78.4K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + LIS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler