Maximize Y‑Sum by Picking a Triplet of Distinct X‑Values

Maximize Y‑Sum by Picking a Triplet of Distinct X‑Values - Problem

Array Hash Table Greedy Sorting Heap (Priority Queue) Medium

You are given two integer arrays x and y, each of length n. Think of these as coordinate pairs where (x[i], y[i]) represents a point with an x-coordinate and a corresponding y-value.

Your challenge is to select three distinct indices i, j, and k such that all three corresponding x-values are different:

x[i] ≠ x[j]
x[j] ≠ x[k]
x[k] ≠ x[i]

Your goal is to maximize the sum y[i] + y[j] + y[k] under these constraints.

Example: If x = [1, 2, 1, 3] and y = [10, 5, 8, 12], you could pick indices (1, 3, 0) giving x-values [2, 3, 1] (all distinct) with y-sum = 5 + 12 + 10 = 27.

Return the maximum possible sum, or -1 if no valid triplet exists.

Input & Output

example_1.py — Standard Case

$ Input: x = [1, 2, 1, 3], y = [10, 5, 8, 12]

› Output: 27

💡 Note: We can choose indices (0, 1, 3) giving x-values [1, 2, 3] (all distinct) and y-sum = 10 + 5 + 12 = 27. This is the maximum possible.

example_2.py — Multiple Options

$ Input: x = [1, 1, 2, 2, 3], y = [5, 10, 3, 8, 12]

› Output: 30

💡 Note: Best choice is indices (1, 3, 4) with x-values [1, 2, 3] and y-sum = 10 + 8 + 12 = 30. We pick the highest y-value for each distinct x-value.

example_3.py — Insufficient Distinct Values

$ Input: x = [1, 1, 2, 2], y = [10, 5, 8, 3]

› Output: -1

💡 Note: We only have 2 distinct x-values (1 and 2), but we need 3 distinct x-values to form a valid triplet.

Constraints

3 ≤ n ≤ 10⁵
1 ≤ x[i] ≤ 10⁵
-10⁵ ≤ y[i] ≤ 10⁵
At least 3 distinct x-values must exist for a valid solution

Visualization

Tap to expand

Understanding the Visualization

City Mapping

Group restaurants by city (x-value) and identify the best ones in each city

Smart Selection

From each of 3 different cities, pick the highest-rated restaurant

Maximum Experience

The combination gives the highest total rating experience

Key Takeaway

🎯 Key Insight: Group by x-values (cities) and pick the best y-values (ratings) from exactly 3 different groups to maximize the sum!

Asked in

G Google 85 a Amazon 72 f Meta 58 ⊞ Microsoft 45

The optimal solution uses a hash table to group indices by x-value, keeping only the top y-values for each group. This reduces the problem to finding the best combination across distinct x-groups in O(n) time. The key insight is that we only need to track the highest y-values for each x-value since we want to maximize the sum.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table with Grouping	O(k³ + n log n)	O(n)	Group indices by x-value, then find best triplet from different groups
Optimized Hash Table (Best Solution)	O(n)	O(k)	Track top y-values for each x-value and compute maximum efficiently
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet of indices and verify distinct x-values

Hash Table with Grouping — Algorithm Steps

Create a hash map grouping indices by their x-values
Sort y-values within each group in descending order
Generate all combinations of 3 different x-values
For each combination, take the highest y-value from each group
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by X

Create hash map with x-values as keys

Sort Groups

Sort y-values within each group (descending)

Pick Best

Try all 3-group combinations, take best y from each

Code -

solution.c — C

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

#define MAX_DISTINCT 1000

typedef struct {
    int x_val;
    int y_values[1000];
    int count;
} Group;

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int maximizeSum(int* x, int* y, int n) {
    Group groups[MAX_DISTINCT];
    int num_groups = 0;
    
    // Group by x-value
    for (int i = 0; i < n; i++) {
        int found = -1;
        for (int j = 0; j < num_groups; j++) {
            if (groups[j].x_val == x[i]) {
                found = j;
                break;
            }
        }
        if (found == -1) {
            groups[num_groups].x_val = x[i];
            groups[num_groups].count = 0;
            found = num_groups++;
        }
        groups[found].y_values[groups[found].count++] = y[i];
    }
    
    // Sort each group
    for (int i = 0; i < num_groups; i++) {
        qsort(groups[i].y_values, groups[i].count, sizeof(int), compare);
    }
    
    if (num_groups < 3) {
        return -1;
    }
    
    int maxSum = -1;
    
    // Try all combinations of 3 groups
    for (int i = 0; i < num_groups; i++) {
        for (int j = i + 1; j < num_groups; j++) {
            for (int k = j + 1; k < num_groups; k++) {
                int currentSum = groups[i].y_values[0] + 
                               groups[j].y_values[0] + 
                               groups[k].y_values[0];
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
            }
        }
    }
    
    return maxSum;
}

int main() {
    int x[] = {1, 2, 1, 3};
    int y[] = {10, 5, 8, 12};
    printf("%d\n", maximizeSum(x, y, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k³ + n log n)

k³ for trying combinations of distinct x-values, n log n for sorting within groups

⚡ Linearithmic

Space Complexity

O(n)

Hash map to store groupings by x-value

⚡ Linearithmic Space

68.5K Views

High Frequency

~18 min Avg. Time

1.8K 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

Hash Table with Grouping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler