Max Value of Equation

Max Value of Equation - Problem

You are given an array points containing the coordinates of points on a 2D plane, sorted by the x-values, where points[i] = [xi, yi] such that xi < xj for all 1 <= i < j <= points.length. You are also given an integer k.

Return the maximum value of the equation yi + yj + |xi - xj| where |xi - xj| <= k and 1 <= i < j <= points.length.

It is guaranteed that there exists at least one pair of points that satisfy the constraint |xi - xj| <= k.

Input & Output

Example 1 — Basic Case

$ Input: points = [[1,3],[2,0],[5,10],[6,-10]], k = 1

› Output: 4

💡 Note: The first two points satisfy |1 - 2| <= 1. The equation value is 3 + 0 + |1 - 2| = 4.

Example 2 — Multiple Valid Pairs

$ Input: points = [[0,0],[3,0],[9,2]], k = 3

› Output: 3

💡 Note: Points [0,0] and [3,0] satisfy |0 - 3| <= 3. The equation value is 0 + 0 + |0 - 3| = 3.

Example 3 — Larger Distance

$ Input: points = [[-17,-15],[-10,3],[2,15]], k = 12

› Output: 30

💡 Note: Points [-10,3] and [2,15] satisfy |(-10) - 2| <= 12. The equation value is 3 + 15 + |(-10) - 2| = 30.

Constraints

2 ≤ points.length ≤ 10⁵
points[i].length == 2
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸
0 ≤ k ≤ 2 × 10⁸
points[i][0] < points[j][0] for all 1 ≤ i < j ≤ points.length

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 15

The key insight is to transform the equation yi + yj + |xi - xj| into (yi - xi) + (yj + xj) since points are sorted by x-coordinate. This allows us to use a monotonic deque to efficiently maintain the maximum (yi - xi) value for all valid previous points within distance k. Best approach uses sliding window with deque for O(n) time and O(n) space complexity.

Common Approaches

✓ Brute Force

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

For each pair of points (i,j) where i < j, check if |xi - xj| <= k and calculate the equation value. Since points are sorted by x-coordinate, |xi - xj| = xj - xi.

Sliding Window with Monotonic Deque

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

Transform the equation yi + yj + (xj - xi) to (yi - xi) + (yj + xj). Use a monotonic deque to efficiently find the maximum (yi - xi) for all valid previous points as we process each point j.

Brute Force — Algorithm Steps

Iterate through all pairs (i,j) where i < j
Check if xj - xi <= k
Calculate yi + yj + (xj - xi) and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Points sorted by x-coordinate and distance limit k

Check Pairs

For each pair (i,j), verify xj - xi <= k

Calculate

Compute yi + yj + |xi - xj| and track maximum

Code -

solution.c — C

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

int solution(int points[][2], int n, int k) {
    int maxValue = INT_MIN;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int xi = points[i][0], yi = points[i][1];
            int xj = points[j][0], yj = points[j][1];
            
            if (xj - xi <= k) {
                int value = yi + yj + (xj - xi);
                if (value > maxValue) {
                    maxValue = value;
                }
            } else {
                break;
            }
        }
    }
    
    return maxValue;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse points array (simplified parsing)
    int points[1000][2];
    int n = 0;
    char *ptr = line + 1; // Skip first '['
    
    while (*ptr && n < 1000) {
        if (*ptr == '[') {
            ptr++;
            points[n][0] = atoi(ptr);
            while (*ptr != ',') ptr++;
            ptr++;
            points[n][1] = atoi(ptr);
            while (*ptr != ']') ptr++;
            ptr++;
            n++;
        }
        ptr++;
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(points, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all pairs of points

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track maximum value

⚡ Linearithmic Space

31.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler