Make Array Strictly Increasing

Make Array Strictly Increasing - Problem

Given two integer arrays arr1 and arr2, return the minimum number of operations (possibly zero) needed to make arr1 strictly increasing.

In one operation, you can choose two indices 0 <= i < arr1.length and 0 <= j < arr2.length and do the assignment arr1[i] = arr2[j].

If there is no way to make arr1 strictly increasing, return -1.

Input & Output

Example 1 — Basic Replacement

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

› Output: 1

💡 Note: Replace arr1[1] = 5 with arr2[1] = 3, then arr1 = [1,3,3,6,7]. Replace arr1[2] = 3 with arr2[3] = 4, then arr1 = [1,3,4,6,7] which is strictly increasing. Total operations: 1.

Example 2 — No Operations Needed

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

› Output: 0

💡 Note: arr1 is already strictly increasing [1,2,3,4], so no operations are needed.

Example 3 — Impossible Case

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

› Output: -1

💡 Note: There is no way to make arr1 strictly increasing. We cannot find suitable replacements to fix the decreasing subsequence.

Constraints

1 ≤ arr1.length, arr2.length ≤ 2000
0 ≤ arr1[i], arr2[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to use dynamic programming to track the minimum operations needed to reach each position with different possible values. The optimal approach uses memoization with binary search optimization to efficiently find valid transitions. Time: O(n×m×log m), Space: O(n×m).

Common Approaches

✓ 2D Dynamic Programming

⏱️ Time: O(n × V × log V) Space: O(n × V)

Create a DP table where dp[i][j] represents minimum operations to make first i elements strictly increasing with the i-th element having value from a sorted list of all possible values.

DP with Binary Search Optimization

⏱️ Time: O(n × m × log m) Space: O(n + m)

Enhanced DP approach that uses binary search to quickly find valid previous values. Sort arr2 for efficient lookups and use coordinate compression for state space reduction.

Dynamic Programming with Memoization

⏱️ Time: O(n × V × m) Space: O(n × V)

Use memoization to store results of subproblems defined by current position and previous value. This eliminates redundant calculations while exploring all valid possibilities.

Recursive Backtracking

⏱️ Time: O(2^n × m) Space: O(n)

For each position, try keeping the original element or replacing it with each element from arr2. Use recursion to explore all possibilities and return the minimum operations needed.

2D Dynamic Programming — Algorithm Steps

Collect all unique values from arr1 and arr2
Create DP table: dp[position][value_index]
For each position, try keeping or replacing
Use binary search for efficient value lookups

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create table for positions × values

Fill Base

Set base cases for position 0

Build Up

Fill table using transitions

Extract Answer

Find minimum in last row

Code -

solution.c — C

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

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

int solution(int* arr1, int arr1Size, int* arr2, int arr2Size) {
    // Collect all unique values
    int allValues[2000];
    int allCount = 0;
    int used[2001] = {0}; // Assuming values are in range [-1000, 1000]
    
    for (int i = 0; i < arr1Size; i++) {
        if (!used[arr1[i] + 1000]) {
            used[arr1[i] + 1000] = 1;
            allValues[allCount++] = arr1[i];
        }
    }
    
    int arr2Set[2001] = {0};
    for (int i = 0; i < arr2Size; i++) {
        arr2Set[arr2[i] + 1000] = 1;
        if (!used[arr2[i] + 1000]) {
            used[arr2[i] + 1000] = 1;
            allValues[allCount++] = arr2[i];
        }
    }
    
    qsort(allValues, allCount, sizeof(int), compare);
    
    // DP table
    int dp[101][2000];
    for (int i = 0; i <= arr1Size; i++) {
        for (int j = 0; j < allCount; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    
    // Base case
    for (int j = 0; j < allCount; j++) {
        dp[0][j] = 0;
    }
    
    for (int i = 1; i <= arr1Size; i++) {
        int original = arr1[i-1];
        
        for (int j = 0; j < allCount; j++) {
            int currentVal = allValues[j];
            
            for (int k = 0; k < j; k++) {
                if (i == 1) {
                    if (currentVal == original) {
                        dp[i][j] = 0;
                    } else if (arr2Set[currentVal + 1000]) {
                        dp[i][j] = 1;
                    }
                } else {
                    if (dp[i-1][k] != INT_MAX) {
                        if (currentVal == original) {
                            if (dp[i-1][k] < dp[i][j]) dp[i][j] = dp[i-1][k];
                        } else if (arr2Set[currentVal + 1000]) {
                            if (dp[i-1][k] + 1 < dp[i][j]) dp[i][j] = dp[i-1][k] + 1;
                        }
                    }
                }
            }
        }
    }
    
    int result = INT_MAX;
    for (int j = 0; j < allCount; j++) {
        if (dp[arr1Size][j] < result) result = dp[arr1Size][j];
    }
    
    return result == INT_MAX ? -1 : result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse arr1
    int arr1[100], arr1Size = 0;
    char* token = strtok(line, "[],");
    while (token != NULL) {
        arr1[arr1Size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    fgets(line, sizeof(line), stdin);
    
    // Parse arr2
    int arr2[100], arr2Size = 0;
    token = strtok(line, "[],");
    while (token != NULL) {
        arr2[arr2Size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%d\n", solution(arr1, arr1Size, arr2, arr2Size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × V × log V)

n positions × V unique values × log V for binary search

⚡ Linearithmic

Space Complexity

O(n × V)

2D DP table storing n positions × V unique values

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler