Minimize the Maximum Adjacent Element Difference

Minimize the Maximum Adjacent Element Difference - Problem

You are given an array of integers nums. Some values in nums are missing and are denoted by -1.

You must choose a pair of positive integers (x, y) exactly once and replace each missing element with either x or y.

You need to minimize the maximum absolute difference between adjacent elements of nums after replacements.

Return the minimum possible difference.

Input & Output

Example 1 — Basic Case with Two Missing

$ Input: nums = [1,-1,3,-1]

› Output: 1

💡 Note: Replace first -1 with 2 and second -1 with 2: [1,2,3,2]. Adjacent differences: |2-1|=1, |3-2|=1, |2-3|=1. Maximum difference is 1.

Example 2 — All Missing Elements

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

› Output: 0

💡 Note: Replace all with same value: [1,1,1]. All adjacent differences are 0, so maximum difference is 0.

Example 3 — No Missing Elements

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

› Output: 1

💡 Note: No replacements needed. Adjacent differences: |2-1|=1, |3-2|=1. Maximum difference is 1.

Constraints

2 ≤ nums.length ≤ 10⁵
nums[i] == -1 or 1 ≤ nums[i] ≤ 10⁹
At least one element is -1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 M Microsoft 6

The key insight is that we can analyze segments of consecutive -1s independently and use constraint propagation from neighboring fixed elements. The optimal approach uses binary search on the answer combined with feasibility checking, achieving O(n log(max_val)) time complexity. For each candidate maximum difference, we determine valid ranges for missing elements and check if two values x,y can satisfy all constraints.

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(n log(max_val)) Space: O(n)

Binary search on the possible range of maximum differences. For each candidate maximum difference, check if it's possible to choose values x and y such that all adjacent differences are within this limit. This reduces the problem to a feasibility check.

Brute Force

⏱️ Time: O(∞) Space: O(1)

For each possible pair of positive integers (x,y), try all possible ways to replace -1s with x or y, then calculate the maximum adjacent difference. This approach is extremely inefficient as it explores an infinite search space.

Optimized Approach

⏱️ Time: O(n) Space: O(1)

Analyze the array by segments separated by existing elements. For each segment of consecutive -1s, determine the optimal values based on boundary constraints. This avoids the need for binary search by directly computing the best possible values.

Binary Search on Answer — Algorithm Steps

Binary search on answer range [0, max_possible_diff]
For each candidate diff, check if achievable
Use constraint propagation to find valid x,y ranges
Verify if any valid (x,y) pair exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Range

Binary search on maximum difference [0, 2×10⁹]

Feasibility

For each mid value, check if achievable with some (x,y)

Constraints

Calculate valid ranges for each missing position

Validation

Check if two values can satisfy all constraints

Code -

solution.c — C

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

static int constraints[1000][2];
static int candidates[10000];
static int assignment[1000];

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

int backtrack(int* nums, int n, int* missing, int missingCount, 
             int constraintCount, int maxDiff, int x, int y, int idx) {
    if (idx == missingCount) {
        for (int i = 0; i < missingCount; i++) {
            int pos = missing[i];
            int val = assignment[i];
            
            if (pos > 0) {
                if (nums[pos-1] != -1) {
                    if (abs_val(val - nums[pos-1]) > maxDiff) return 0;
                } else {
                    int prevIdx = -1;
                    for (int j = 0; j < missingCount; j++) {
                        if (missing[j] == pos-1) {
                            prevIdx = j;
                            break;
                        }
                    }
                    if (prevIdx != -1 && abs_val(val - assignment[prevIdx]) > maxDiff) {
                        return 0;
                    }
                }
            }
            
            if (pos < n-1) {
                if (nums[pos+1] != -1) {
                    if (abs_val(val - nums[pos+1]) > maxDiff) return 0;
                } else {
                    int nextIdx = -1;
                    for (int j = 0; j < missingCount; j++) {
                        if (missing[j] == pos+1) {
                            nextIdx = j;
                            break;
                        }
                    }
                    if (nextIdx != -1 && abs_val(val - assignment[nextIdx]) > maxDiff) {
                        return 0;
                    }
                }
            }
        }
        return 1;
    }
    
    int minVal = constraints[idx][0], maxVal = constraints[idx][1];
    
    if (minVal <= x && x <= maxVal) {
        assignment[idx] = x;
        if (backtrack(nums, n, missing, missingCount, constraintCount, maxDiff, x, y, idx + 1)) {
            return 1;
        }
    }
    
    if (minVal <= y && y <= maxVal) {
        assignment[idx] = y;
        if (backtrack(nums, n, missing, missingCount, constraintCount, maxDiff, x, y, idx + 1)) {
            return 1;
        }
    }
    
    return 0;
}

int canAchieve(int* nums, int n, int* missing, int missingCount, int maxDiff) {
    int constraintCount = 0;
    
    for (int i = 0; i < missingCount; i++) {
        int pos = missing[i];
        int minVal = 1, maxVal = 1000000000;
        
        if (pos > 0 && nums[pos-1] != -1) {
            int left = nums[pos-1];
            if (left - maxDiff > minVal) minVal = left - maxDiff;
            if (left + maxDiff < maxVal) maxVal = left + maxDiff;
        }
        
        if (pos < n-1 && nums[pos+1] != -1) {
            int right = nums[pos+1];
            if (right - maxDiff > minVal) minVal = right - maxDiff;
            if (right + maxDiff < maxVal) maxVal = right + maxDiff;
        }
        
        if (minVal > maxVal) return 0;
        constraints[constraintCount][0] = minVal;
        constraints[constraintCount][1] = maxVal;
        constraintCount++;
    }
    
    int candidateCount = 0;
    candidates[candidateCount++] = 1;
    
    for (int i = 0; i < constraintCount; i++) {
        candidates[candidateCount++] = constraints[i][0];
        candidates[candidateCount++] = constraints[i][1];
        candidates[candidateCount++] = (constraints[i][0] + constraints[i][1]) / 2;
    }
    
    for (int i = 0; i < candidateCount; i++) {
        for (int j = 0; j < candidateCount; j++) {
            int x = candidates[i], y = candidates[j];
            if (x <= 0 || y <= 0 || abs_val(x - y) > maxDiff) continue;
            
            int valid = 1;
            for (int k = 0; k < constraintCount; k++) {
                int minVal = constraints[k][0], maxVal = constraints[k][1];
                int canUseX = minVal <= x && x <= maxVal;
                int canUseY = minVal <= y && y <= maxVal;
                
                if (!canUseX && !canUseY) {
                    valid = 0;
                    break;
                }
            }
            
            if (!valid) continue;
            
            if (backtrack(nums, n, missing, missingCount, constraintCount, maxDiff, x, y, 0)) {
                return 1;
            }
        }
    }
    
    return 0;
}

int solution(int* nums, int n) {
    if (n <= 1) return 0;
    
    int missing[1000];
    int missingCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] == -1) {
            missing[missingCount++] = i;
        }
    }
    
    if (missingCount == 0) {
        int maxDiff = 0;
        for (int i = 1; i < n; i++) {
            int diff = abs_val(nums[i] - nums[i-1]);
            if (diff > maxDiff) maxDiff = diff;
        }
        return maxDiff;
    }
    
    int left = 0, right = 2000000000;
    int result = right;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieve(nums, n, missing, missingCount, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100000];
    int n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int negative = 0;
        if (*p == '-') {
            negative = 1;
            p++;
        }
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        
        if (negative) num = -num;
        nums[n++] = num;
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_val))

Binary search log(max_val) times, each check takes O(n)

✓ Linear Growth

Space Complexity

O(n)

Store constraints and ranges for missing elements

✓ Linear Space

23.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler