Merge Triplets to Form Target Triplet - Practice Coding Problems

Merge Triplets to Form Target Triplet - Problem

Array Greedy Medium

Imagine you're a data scientist working with coordinate systems! You have a collection of triplets (arrays of three integers) and want to create a specific target triplet through strategic merging operations.

Given a 2D array triplets where each triplets[i] = [a_i, b_i, c_i] represents the i-th triplet, and a target array target = [x, y, z], your goal is to determine if you can obtain the target triplet.

The Merging Rule: You can select any two different triplets and merge them by taking the maximum of each corresponding position:

If triplets[i] = [2, 5, 3] and triplets[j] = [1, 7, 5]
After merging: triplets[j] = [max(2,1), max(5,7), max(3,5)] = [2, 7, 5]

You can perform this operation any number of times with any valid pair of triplets. Return true if you can create the target triplet, false otherwise.

Input & Output

example_1.py — Basic Success Case

$ Input: triplets = [[2,5,3],[1,7,5],[3,9,8]], target = [3,7,5]

› Output: true

💡 Note: We can merge [2,5,3] and [1,7,5] to get [max(2,1), max(5,7), max(3,5)] = [2,7,5]. Then merge with [3,9,8] but since [3,9,8] has 9 > 7, we can't use it. However, we don't need it - we can achieve the target by using only good triplets through strategic merging.

example_2.py — Impossible Case

$ Input: triplets = [[3,4,5],[4,5,6]], target = [3,2,5]

› Output: false

💡 Note: The target needs 2 in position 1, but all available triplets have values ≥ 4 in position 1. Since merging takes the maximum, we can never achieve a value of 2 in any position if all source values are greater.

example_3.py — Single Triplet Match

$ Input: triplets = [[2,5,3],[2,3,4],[1,2,5],[5,2,3]], target = [5,5,5]

› Output: true

💡 Note: We can merge multiple triplets: start with [2,5,3], merge with [5,2,3] to get [5,5,3], then merge with [1,2,5] to get [5,5,5]. Each good triplet contributes the maximum value needed for different positions.

Constraints

1 ≤ triplets.length ≤ 10⁵
triplets[i].length == target.length == 3
1 ≤ a_i, b_i, c_i, x, y, z ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Identify Good Recipes

Filter out recipes with any spice too strong (> target)

Check Coverage

Ensure we can achieve exact target strength for each spice

Validate Solution

Return true if all target spice levels are achievable

Key Takeaway

🎯 Key Insight: Filter out triplets that exceed target values, then verify each target component can be achieved exactly by the remaining 'good' triplets.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy filtering approach that runs in O(n) time. Key insight: since merging takes the maximum of each position, any triplet exceeding the target in any component is useless. We filter out 'bad' triplets and check if the remaining 'good' triplets can collectively provide each target component through exact matches.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n * n!)	O(n)	Simulate all possible merge operations until target is found or all combinations exhausted
Greedy Filtering (Optimal)	O(n)	O(1)	Filter out 'bad' triplets, then check if remaining 'good' triplets can cover all target components

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of triplets
For each subset, perform merge operations in all possible orders
Check if any final result equals the target triplet
Return true if target found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with all triplets

Begin with the original set of triplets

Try all merge pairs

For each pair of triplets, create a merged version

Recursively explore

Continue merging until target is found or all combinations exhausted

Code -

solution.c — C

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

#define MAX_TRIPLETS 1000
#define MAX_DEPTH 1000

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

bool equal_triplet(int* a, int* b) {
    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
}

void merge_triplets(int* t1, int* t2, int* result) {
    result[0] = max(t1[0], t2[0]);
    result[1] = max(t1[1], t2[1]);
    result[2] = max(t1[2], t2[2]);
}

bool canFormTarget(int triplets[][3], int size, int* target, int depth) {
    if (depth > MAX_DEPTH) return false;
    
    for (int i = 0; i < size; i++) {
        if (equal_triplet(triplets[i], target)) {
            return true;
        }
    }
    
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            int newTriplets[MAX_TRIPLETS][3];
            int newSize = 0;
            
            // Copy all except i and j
            for (int k = 0; k < size; k++) {
                if (k != i && k != j) {
                    newTriplets[newSize][0] = triplets[k][0];
                    newTriplets[newSize][1] = triplets[k][1];
                    newTriplets[newSize][2] = triplets[k][2];
                    newSize++;
                }
            }
            
            // Add merged triplet
            merge_triplets(triplets[i], triplets[j], newTriplets[newSize]);
            newSize++;
            
            if (canFormTarget(newTriplets, newSize, target, depth + 1)) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    int triplets[][3] = {{2,5,3},{1,7,5},{3,9,8}};
    int target[] = {3,7,5};
    int size = 3;
    
    printf("%s\n", canFormTarget(triplets, size, target, 0) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n!)

2^n subsets times n! possible merge orders for each subset

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and storing intermediate results

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler