Minimize the Maximum Adjacent Element Difference

Minimize the Maximum Adjacent Element Difference - Problem

You're given an array of integers nums where some values are missing and represented by -1. Your task is to strategically replace each missing element with one of two positive integers x or y that you choose.

The goal is to minimize the maximum absolute difference between any two adjacent elements in the final array. You must choose exactly one pair (x, y) and use only these two values for all replacements.

Example: Given [1, -1, -1, 4], you might choose x=2, y=3 and create [1, 2, 3, 4] with max adjacent difference of 1.

Return the minimum possible maximum adjacent difference after optimal replacements.

Input & Output

example_1.py — Basic Case

$ Input: [1, -1, -1, 4]

› Output: 1

💡 Note: We can choose x=2, y=3 and create [1,2,3,4]. Adjacent differences are |2-1|=1, |3-2|=1, |4-3|=1. Maximum is 1.

example_2.py — All Missing

$ Input: [-1, -1, -1]

› Output: 0

💡 Note: We can choose x=1, y=1 and create [1,1,1]. All adjacent differences are 0, so maximum is 0.

example_3.py — No Missing

$ Input: [1, 3, 5]

› Output: 2

💡 Note: No missing elements, so we just calculate maximum adjacent difference: max(|3-1|, |5-3|) = max(2, 2) = 2.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹ when nums[i] ≠ -1
At least one element is -1
You must use exactly two distinct positive integers for replacements

Asked in

This problem requires binary search on the answer combined with constraint satisfaction. The key insight is to search for the minimum achievable maximum difference, then for each candidate, build constraints on missing positions based on adjacent elements. Use a greedy assignment strategy with only two values (x, y) to check feasibility. Time complexity is O(log(max_val) × n × V) where V is the number of candidate values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Pairs)	O(V² × 2^k × n)	O(1)	Try all possible (x, y) pairs and test all assignment combinations
Binary Search on Answer	O(log(max_val) × n × V)	O(n)	Binary search on maximum difference, check feasibility with greedy assignment

Brute Force (Try All Pairs) — Algorithm Steps

Identify all missing positions (-1) in the array
Generate reasonable range of values for x and y based on existing elements
For each (x, y) pair, try all 2^k combinations where k is number of missing elements
For each combination, calculate maximum adjacent difference
Return the minimum maximum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Missing

Find all positions with -1

Generate Pairs

Try all reasonable (x,y) value pairs

Test Assignments

For each pair, try all possible assignments to missing positions

Calculate Max Diff

Find maximum adjacent difference for each configuration

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int minimizeMaxDifference(int* nums, int n) {
    int missingPositions[1000], missingCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] == -1) {
            missingPositions[missingCount++] = i;
        }
    }
    
    if (missingCount == 0) {
        int maxDiff = 0;
        for (int i = 1; i < n; i++) {
            maxDiff = max(maxDiff, abs_diff(nums[i], nums[i-1]));
        }
        return maxDiff;
    }
    
    int existing[1000], existingCount = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] != -1) {
            existing[existingCount++] = nums[i];
        }
    }
    
    if (existingCount == 0) return 0;
    
    int minVal = existing[0], maxVal = existing[0];
    for (int i = 0; i < existingCount; i++) {
        minVal = min(minVal, existing[i]);
        maxVal = max(maxVal, existing[i]);
    }
    
    int minMaxDiff = INT_MAX;
    
    for (int x = 1; x <= maxVal + 10; x++) {
        for (int y = x; y <= maxVal + 10; y++) {
            int combinations = 1 << missingCount;
            for (int mask = 0; mask < combinations; mask++) {
                int tempNums[1000];
                memcpy(tempNums, nums, n * sizeof(int));
                
                for (int i = 0; i < missingCount; i++) {
                    int pos = missingPositions[i];
                    if (mask & (1 << i)) {
                        tempNums[pos] = x;
                    } else {
                        tempNums[pos] = y;
                    }
                }
                
                int maxDiff = 0;
                for (int i = 1; i < n; i++) {
                    maxDiff = max(maxDiff, abs_diff(tempNums[i], tempNums[i-1]));
                }
                
                minMaxDiff = min(minMaxDiff, maxDiff);
            }
        }
    }
    
    return minMaxDiff;
}

int main() {
    int nums[1000], n = 0;
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " \n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", minimizeMaxDifference(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V² × 2^k × n)

V is value range, k is missing elements count, n is array length

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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