Make Array Strictly Increasing - Practice Coding Problems

Make Array Strictly Increasing - Problem

Transform Array into Strictly Increasing Sequence

You're given two integer arrays: arr1 (the array to modify) and arr2 (your toolkit of replacement values). Your goal is to make arr1 strictly increasing using the minimum number of operations.

In each operation, you can:
• Choose any index i in arr1
• Choose any index j in arr2
• Replace arr1[i] with arr2[j]

Challenge: Find the minimum operations needed, or return -1 if it's impossible to create a strictly increasing sequence.

Example: If arr1 = [1,5,3,6,7] and arr2 = [1,3,2,4], you need 1 operation (replace 5 with 2) to get [1,2,3,6,7].

Input & Output

example_1.py — Basic Replacement

$ Input: arr1 = [1,5,3,6,7], arr2 = [1,3,2,4]

› Output: 1

💡 Note: Replace arr1[1] = 5 with arr2[2] = 2. The array becomes [1,2,3,6,7] which is strictly increasing. Only 1 operation needed.

example_2.py — Multiple Replacements

$ Input: arr1 = [1,5,3,6,7], arr2 = [4,3,1]

› Output: 2

💡 Note: Replace arr1[1] = 5 with arr2[1] = 3 and arr1[2] = 3 with arr2[0] = 4. The array becomes [1,3,4,6,7]. Total 2 operations.

example_3.py — Impossible Case

$ Input: arr1 = [1,5,3,6,7], arr2 = [1,6,3,3]

› Output: -1

💡 Note: Cannot make arr1 strictly increasing. After position with value 6, we need values > 6, but arr2 only has values ≤ 6.

Constraints

1 ≤ arr1.length, arr2.length ≤ 2000
0 ≤ arr1[i], arr2[i] ≤ 10⁹
Array elements can be equal, but result must be strictly increasing

Visualization

Tap to expand

Understanding the Visualization

Assess Current Staircase

Look at arr1 = [1,5,3,6,7]. Steps 5→3 violate strictly increasing rule.

Check Toolkit

Available replacement steps: arr2 = [1,3,2,4]. Sort for efficient selection.

DP State Management

Track minimum operations to reach each position with different ending heights.

Binary Search Optimization

For each position, quickly find the smallest valid replacement step.

Optimal Path

Replace step 5 with step 2, creating [1,2,3,6,7] with just 1 operation.

Key Takeaway

🎯 Key Insight: The combination of DP state management and binary search optimization transforms an exponential brute force solution into an efficient O(n × m × log m) algorithm by tracking minimal operation counts for each possible ending value.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses Dynamic Programming with Binary Search to efficiently find the minimum operations. We maintain DP states tracking possible ending values and their minimum operations, using binary search on sorted arr2 to quickly find optimal replacements. Time complexity: O(n × m × log m).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Binary Search (Optimal)	O(n × m × log m)	O(n × m)	Use DP to track states and binary search to find optimal replacement values
Recursive Brute Force	O(2^n × m)	O(n)	Try all possible combinations of keeping vs replacing each element

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Sort arr2 to enable binary search for optimal replacements
Use DP map where key = ending value, value = minimum operations
For each position, create new DP state by keeping current element
Use binary search to find smallest valid replacement from arr2
Update DP states with minimum operations for each ending value
Return minimum operations from final DP state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with dp[-1] = 0 (can begin with any value > -1)

Process each element

For each arr1[i], update DP states by keeping or replacing

Keep current element

If arr1[i] > prev_val, update dp[arr1[i]]

Binary search replacement

Find smallest arr2[j] > prev_val using binary search

Update DP states

Maintain minimum operations for each possible ending value

Return result

Return minimum operations from final DP state

Code -

solution.c — C

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

#define MAX_SIZE 2000

typedef struct {
    int val;
    int ops;
} DPEntry;

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int binarySearchRight(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int makeArrayIncreasing(int* arr1, int arr1Size, int* arr2, int arr2Size) {
    // Remove duplicates and sort arr2
    qsort(arr2, arr2Size, sizeof(int), compare);
    int uniqueSize = 1;
    for (int i = 1; i < arr2Size; i++) {
        if (arr2[i] != arr2[uniqueSize - 1]) {
            arr2[uniqueSize++] = arr2[i];
        }
    }
    arr2Size = uniqueSize;
    
    // DP arrays
    DPEntry dp[MAX_SIZE];
    DPEntry newDp[MAX_SIZE];
    int dpSize = 1;
    dp[0].val = -1;
    dp[0].ops = 0;
    
    for (int i = 0; i < arr1Size; i++) {
        int newDpSize = 0;
        
        for (int j = 0; j < dpSize; j++) {
            int prevVal = dp[j].val;
            int ops = dp[j].ops;
            
            // Option 1: Keep current number
            if (arr1[i] > prevVal) {
                int found = -1;
                for (int k = 0; k < newDpSize; k++) {
                    if (newDp[k].val == arr1[i]) {
                        found = k;
                        break;
                    }
                }
                if (found == -1) {
                    newDp[newDpSize].val = arr1[i];
                    newDp[newDpSize].ops = ops;
                    newDpSize++;
                } else {
                    if (ops < newDp[found].ops) {
                        newDp[found].ops = ops;
                    }
                }
            }
            
            // Option 2: Replace with smallest valid number from arr2
            int idx = binarySearchRight(arr2, arr2Size, prevVal);
            if (idx < arr2Size) {
                int newVal = arr2[idx];
                int found = -1;
                for (int k = 0; k < newDpSize; k++) {
                    if (newDp[k].val == newVal) {
                        found = k;
                        break;
                    }
                }
                if (found == -1) {
                    newDp[newDpSize].val = newVal;
                    newDp[newDpSize].ops = ops + 1;
                    newDpSize++;
                } else {
                    if (ops + 1 < newDp[found].ops) {
                        newDp[found].ops = ops + 1;
                    }
                }
            }
        }
        
        // Copy newDp to dp
        memcpy(dp, newDp, sizeof(DPEntry) * newDpSize);
        dpSize = newDpSize;
        
        if (dpSize == 0) {
            return -1;
        }
    }
    
    if (dpSize == 0) return -1;
    
    int result = INT_MAX;
    for (int i = 0; i < dpSize; i++) {
        if (dp[i].ops < result) {
            result = dp[i].ops;
        }
    }
    return result;
}

int main() {
    int arr1[MAX_SIZE], arr2[MAX_SIZE];
    int arr1Size = 0, arr2Size = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            arr1[arr1Size++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            arr2[arr2Size++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%d\n", makeArrayIncreasing(arr1, arr1Size, arr2, arr2Size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × log m)

n positions × m possible states × log m for binary search on sorted arr2

⚡ Linearithmic

Space Complexity

O(n × m)

DP map can have at most n × m states (position × ending value combinations)

⚡ Linearithmic Space

29.4K Views

Medium-High Frequency

~25 min Avg. Time

1.2K 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

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler