Maximum Difference Between Increasing Elements

Maximum Difference Between Increasing Elements - Problem

Array Easy

Given a 0-indexed integer array nums of size n, find the maximum difference between nums[i] and nums[j] (i.e., nums[j] - nums[i]), such that 0 <= i < j < n and nums[i] < nums[j].

Return the maximum difference. If no such i and j exists, return -1.

Input & Output

Example 1 — Basic Case

$ Input: nums = [7,1,5,4,6]

› Output: 5

💡 Note: The maximum difference is 6 - 1 = 5, where i = 1 and j = 4 (nums[1] = 1, nums[4] = 6)

Example 2 — No Valid Pair

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

› Output: -1

💡 Note: No valid pair exists since the array is in decreasing order, so no i < j with nums[i] < nums[j]

Example 3 — Small Difference

$ Input: nums = [1,5,2,10]

› Output: 9

💡 Note: Maximum difference is 10 - 1 = 9, where i = 0 and j = 3

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to track the minimum element seen so far while iterating through the array. For each element, calculate the difference with the minimum and update the maximum difference. Best approach uses single pass optimization with Time: O(n), Space: O(1).

Common Approaches

✓ Greedy

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

Brute Force

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

For each element at index i, check all elements at indices j > i to find the maximum difference where nums[i] < nums[j].

Single Pass Optimization

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

In a single pass, keep track of the minimum element encountered so far. For each element, calculate the difference with the minimum and update the maximum difference.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int start, end;
    char substring[1001];
} Interval;

int compare_intervals(const void* a, const void* b) {
    Interval* ia = (Interval*)a;
    Interval* ib = (Interval*)b;
    int len_a = strlen(ia->substring);
    int len_b = strlen(ib->substring);
    if (len_a != len_b) return len_a - len_b;
    return ia->start - ib->start;
}

int solution_impl(char* s, char result[][1001]) {
    int n = strlen(s);
    int first[26], last[26];
    
    for (int i = 0; i < 26; i++) {
        first[i] = -1;
        last[i] = -1;
    }
    
    for (int i = 0; i < n; i++) {
        int c = s[i] - 'a';
        if (first[c] == -1) first[c] = i;
        last[c] = i;
    }
    
    Interval intervals[1000];
    int intervalCount = 0;
    
    for (int i = 0; i < n; i++) {
        bool charsSeen[26] = {false};
        int maxEnd = i - 1;
        
        for (int j = i; j < n; j++) {
            charsSeen[s[j] - 'a'] = true;
            
            for (int k = 0; k < 26; k++) {
                if (charsSeen[k] && last[k] > maxEnd) {
                    maxEnd = last[k];
                }
            }
            
            if (j == maxEnd) {
                bool valid = true;
                for (int k = i; k <= j; k++) {
                    if (first[s[k] - 'a'] < i) {
                        valid = false;
                        break;
                    }
                }
                
                if (valid) {
                    intervals[intervalCount].start = i;
                    intervals[intervalCount].end = j;
                    strncpy(intervals[intervalCount].substring, s + i, j - i + 1);
                    intervals[intervalCount].substring[j - i + 1] = '\0';
                    intervalCount++;
                    break;
                }
            }
        }
    }
    
    // Remove duplicates
    int uniqueCount = 0;
    for (int i = 0; i < intervalCount; i++) {
        bool duplicate = false;
        for (int j = 0; j < uniqueCount; j++) {
            if (intervals[i].start == intervals[j].start && intervals[i].end == intervals[j].end) {
                duplicate = true;
                break;
            }
        }
        if (!duplicate) {
            intervals[uniqueCount++] = intervals[i];
        }
    }
    
    qsort(intervals, uniqueCount, sizeof(Interval), compare_intervals);
    
    int resultCount = 0;
    int lastEnd = -1;
    
    for (int i = 0; i < uniqueCount; i++) {
        if (intervals[i].start > lastEnd) {
            strcpy(result[resultCount], intervals[i].substring);
            resultCount++;
            lastEnd = intervals[i].end;
        }
    }
    
    return resultCount;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char result[100][1001];
    int count = solution_impl(s, result);
    
    for (int i = 0; i < count; i++) {
        printf("%s\n", result[i]);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~15 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