Make Array Non-decreasing or Non-increasing

Make Array Non-decreasing or Non-increasing - Problem

You are given a 0-indexed integer array nums. Your goal is to transform this array into either a non-decreasing (ascending) or non-increasing (descending) sequence using the minimum number of operations.

In each operation, you can:

Choose any index i where 0 <= i < nums.length
Set nums[i] to nums[i] + 1 or nums[i] - 1

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

Example: For array [3, 2, 4, 5, 1], you could make it non-decreasing [1, 2, 3, 4, 5] or non-increasing [5, 4, 3, 2, 1]. The challenge is finding which transformation requires fewer operations.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: To make non-decreasing: [1,2,3,4,5] costs 7 operations. To make non-increasing: [5,4,3,2,1] costs 4 operations. Choose the minimum: 4.

example_2.py — Already Sorted

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

› Output: 0

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

example_3.py — Single Element

$ Input: [5]

› Output: 0

💡 Note: Single element array is both non-decreasing and non-increasing by definition.

Constraints

1 ≤ nums.length ≤ 10³
1 ≤ nums[i] ≤ 10⁴
Each operation changes a number by exactly 1
Must choose either non-decreasing OR non-increasing (not mixed)

Visualization

Tap to expand

Understanding the Visualization

Analyze Original

Look at current array values and determine range

Try Both Directions

Calculate cost for non-decreasing and non-increasing

Use Dynamic Programming

Build optimal solutions using memoization

Choose Minimum

Select the direction requiring fewer operations

Key Takeaway

🎯 Key Insight: The problem has optimal substructure - the best way to transform a suffix depends on the chosen value for current position. Dynamic programming with memoization efficiently explores both non-decreasing and non-increasing possibilities.

Asked in

G Google 35 ⊞ Microsoft 28 a Amazon 22 f Meta 18

This problem requires finding the minimum operations to make an array either non-decreasing or non-increasing. The optimal approach uses dynamic programming with memoization to explore both directions efficiently. Key insight: the optimal target sequence has a specific structure that can be found using DP with state (position, last_value, direction). Time complexity is O(n × R²) where R is the range of values.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n * R²)	O(n * R)	Use DP with hash table to store optimal solutions for subproblems
Brute Force (Try All Possible Targets)	O(R^n)	O(n)	Try all possible target values for each position in both directions

Dynamic Programming with Memoization — Algorithm Steps

Build hash table of all possible target values from array range
Use DP with state (position, direction, last_value)
Memoize solutions to avoid redundant calculations
Try both non-decreasing and non-increasing directions
Return minimum operations from both directions

Visualization

Tap to expand

Step-by-Step Walkthrough

State Definition

Define DP state as (position, last_value, direction)

Build Cache

Store computed results to avoid recalculation

Optimal Substructure

Use previous solutions to build current solution

Return Answer

Combine results from both directions

Code -

solution.c — C

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

#define MAX_MEMO 10000

typedef struct {
    int pos, lastVal;
    char increasing;
    int value;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memoSize = 0;

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int findMemo(int pos, int lastVal, char increasing) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].pos == pos && memo[i].lastVal == lastVal && memo[i].increasing == increasing) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(int pos, int lastVal, char increasing, int value) {
    if (memoSize < MAX_MEMO) {
        memo[memoSize].pos = pos;
        memo[memoSize].lastVal = lastVal;
        memo[memoSize].increasing = increasing;
        memo[memoSize].value = value;
        memoSize++;
    }
}

int dp(int* nums, int len, int pos, int lastVal, char increasing, int minVal, int maxVal) {
    if (pos == len) return 0;
    
    int cached = findMemo(pos, lastVal, increasing);
    if (cached != -1) return cached;
    
    int minOps = INT_MAX;
    
    if (increasing) {
        for (int val = lastVal; val <= maxVal; val++) {
            int ops = abs_val(nums[pos] - val) + dp(nums, len, pos + 1, val, increasing, minVal, maxVal);
            if (ops < minOps) minOps = ops;
        }
    } else {
        for (int val = minVal; val <= lastVal; val++) {
            int ops = abs_val(nums[pos] - val) + dp(nums, len, pos + 1, val, increasing, minVal, maxVal);
            if (ops < minOps) minOps = ops;
        }
    }
    
    addMemo(pos, lastVal, increasing, minOps);
    return minOps;
}

int minOperations(int* nums, int len) {
    if (len == 0) return 0;
    
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 1; i < len; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    memoSize = 0;
    int incOps = dp(nums, len, 0, minVal, 1, minVal, maxVal);
    
    memoSize = 0;
    int decOps = dp(nums, len, 0, maxVal, 0, minVal, maxVal);
    
    return incOps < decOps ? incOps : decOps;
}

int main() {
    int nums[1000];
    int len = 0;
    char c;
    int num = 0;
    int inNumber = 0;
    int negative = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c == '-') {
            negative = 1;
        } else if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = 1;
        } else if (inNumber) {
            nums[len++] = negative ? -num : num;
            num = 0;
            inNumber = 0;
            negative = 0;
        }
    }
    if (inNumber) {
        nums[len++] = negative ? -num : num;
    }
    
    printf("%d\n", minOperations(nums, len));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * R²)

n positions, R possible values, R transitions per state

✓ Linear Growth

Space Complexity

O(n * R)

Memoization table storing states

⚡ Linearithmic Space

37.2K Views

Medium Frequency

~25 min Avg. Time

1.6K 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler