Make Array Non-decreasing or Non-increasing

Make Array Non-decreasing or Non-increasing - Problem

You are given a 0-indexed integer array nums. In one operation, you can:

• Choose an index i in the range 0 <= i < nums.length

• Set nums[i] to nums[i] + 1 or nums[i] - 1

Return the minimum number of operations to make nums non-decreasing or non-increasing.

Input & Output

Example 1 — Mixed Array

$ Input: nums = [3,1,4,2]

› Output: 4

💡 Note: Transform to non-decreasing [1,1,3,3]: |3-1| + |1-1| + |4-3| + |2-3| = 2 + 0 + 1 + 1 = 4 operations

Example 2 — Already Sorted

$ Input: nums = [1,2,3,4]

› Output: 0

💡 Note: Array is already non-decreasing, so no operations needed

Example 3 — Reverse Order

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

› Output: 0

💡 Note: Array is already non-increasing, so no operations needed

Constraints

1 ≤ nums.length ≤ 300
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that optimal target values must come from the original array values. The best approach uses Dynamic Programming to try both non-decreasing and non-increasing transformations. Time: O(n³), Space: O(n²)

Common Approaches

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Brute Force - Try All Sequences

⏱️ Time: O(R^n) Space: O(n)

For each position, try all possible values within a reasonable range. Calculate the cost to transform the array to each sequence and return the minimum.

Dynamic Programming with Sorted Values

⏱️ Time: O(n³) Space: O(n²)

The key insight is that optimal target values must come from the original array. We try both non-decreasing and non-increasing transformations using DP.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char combined[2001];
int m1;

typedef struct {
    int i, j;
    int used1, used2;
    int result;
} MemoEntry;

MemoEntry memo[10000];
int memoCount = 0;

int findMemo(int i, int j, int used1, int used2) {
    for (int k = 0; k < memoCount; k++) {
        if (memo[k].i == i && memo[k].j == j && memo[k].used1 == used1 && memo[k].used2 == used2) {
            return memo[k].result;
        }
    }
    return -1000001; // Not found
}

void addMemo(int i, int j, int used1, int used2, int result) {
    if (memoCount < 10000) {
        memo[memoCount].i = i;
        memo[memoCount].j = j;
        memo[memoCount].used1 = used1;
        memo[memoCount].used2 = used2;
        memo[memoCount].result = result;
        memoCount++;
    }
}

int dp(int i, int j, int used1, int used2) {
    if (i > j) {
        return (used1 && used2) ? 0 : -1000000;
    }
    
    int memoResult = findMemo(i, j, used1, used2);
    if (memoResult != -1000001) {
        return memoResult;
    }
    
    int fromWord1I = (i < m1) ? 1 : 0;
    int fromWord1J = (j < m1) ? 1 : 0;
    
    int result;
    if (i == j) {
        int newUsed1 = used1 || fromWord1I;
        int newUsed2 = used2 || (1 - fromWord1I);
        result = (newUsed1 && newUsed2) ? 1 : -1000000;
    } else if (combined[i] == combined[j]) {
        int newUsed1 = used1 || fromWord1I || fromWord1J;
        int newUsed2 = used2 || (1 - fromWord1I) || (1 - fromWord1J);
        int subResult = dp(i + 1, j - 1, newUsed1, newUsed2);
        result = (subResult != -1000000) ? subResult + 2 : -1000000;
    } else {
        int left = dp(i + 1, j, used1, used2);
        int right = dp(i, j - 1, used1, used2);
        result = (left > right) ? left : right;
    }
    
    addMemo(i, j, used1, used2, result);
    return result;
}

int solution(char* word1, char* word2) {
    strcpy(combined, word1);
    strcat(combined, word2);
    m1 = strlen(word1);
    memoCount = 0;
    
    int result = dp(0, strlen(combined) - 1, 0, 0);
    return result == -1000000 ? 0 : result;
}

int main() {
    char word1[1001], word2[1001];
    fgets(word1, sizeof(word1), stdin);
    word1[strcspn(word1, "\n")] = 0;
    fgets(word2, sizeof(word2), stdin);
    word2[strcspn(word2, "\n")] = 0;
    printf("%d\n", solution(word1, word2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

15.4K Views

Medium Frequency

~35 min Avg. Time

680 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