Describe the Painting

Describe the Painting - Problem

There is a long and thin painting that can be represented by a number line. The painting was painted with multiple overlapping segments where each segment was painted with a unique color.

You are given a 2D integer array segments, where segments[i] = [start_i, end_i, color_i] represents the half-closed segment [start_i, end_i) with color_i as the color.

The colors in the overlapping segments of the painting were mixed when it was painted. When two or more colors mix, they form a new color that can be represented as a set of mixed colors.

For example, if colors 2, 4, and 6 are mixed, then the resulting mixed color is {2,4,6}.

For the sake of simplicity, you should only output the sum of the elements in the set rather than the full set.

You want to describe the painting with the minimum number of non-overlapping half-closed segments of these mixed colors. These segments can be represented by the 2D array painting where painting[j] = [left_j, right_j, mix_j] describes a half-closed segment [left_j, right_j) with the mixed color sum of mix_j.

Return the 2D array painting describing the finished painting (excluding any parts that are not painted). You may return the segments in any order.

A half-closed segment [a, b) is the section of the number line between points a and b including point a and not including point b.

Input & Output

Example 1 — Basic Overlapping

$ Input: segments = [[1,4,5],[4,7,7],[1,7,9]]

› Output: [[1,4,14],[4,7,16]]

💡 Note: Segment [1,4) has colors {5,9} with sum 14. Segment [4,7) has colors {7,9} with sum 16.

Example 2 — No Overlap

$ Input: segments = [[1,7,9],[6,10,15],[8,12,5]]

› Output: [[1,6,9],[6,7,24],[7,8,15],[8,10,20],[10,12,5]]

💡 Note: Multiple distinct segments with different color combinations at each interval.

Example 3 — Single Segment

$ Input: segments = [[1,4,5]]

› Output: [[1,4,5]]

💡 Note: Only one segment, so output is identical to input with no mixing.

Constraints

1 ≤ segments.length ≤ 2 × 10⁴
segments[i].length == 3
1 ≤ start_i < end_i ≤ 10⁵
1 ≤ color_i ≤ 10⁹
start_i < end_i

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use an event-based sweep line algorithm to efficiently track color changes. Create start/end events for each segment, sort by position, then sweep through maintaining the active color sum. Best approach is Event-Based Sweep Line with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Check Every Point

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

For each possible coordinate, iterate through all segments to find overlapping colors. This creates segments by checking consecutive points.

Event-Based Sweep Line

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

Create start/end events for each segment, sort by position, then sweep through tracking active colors. This efficiently finds all distinct color combinations.

Brute Force - Check Every Point — Algorithm Steps

Find all unique coordinate points
For each point, check which segments contain it
Group consecutive points with same color mix
Build result segments

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Coordinates

Extract all unique start/end points

Check Intervals

For each consecutive pair, sum overlapping colors

Build Result

Create segments with mixed color sums

Code -

solution.c — C

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

typedef struct {
    int pos;
    int color;
    int type; // 0 = start, 1 = end
} Event;

typedef struct {
    int start;
    int end;
    long long mix;
} Result;

static Event events[20000];
static Result results[10000];
static int active_colors[1000];

int compare_events(const void* a, const void* b) {
    Event* ea = (Event*)a;
    Event* eb = (Event*)b;
    if (ea->pos != eb->pos) return ea->pos - eb->pos;
    return ea->type - eb->type; // start events before end events
}

int parse_segments(char* input, int segments[][3]) {
    int count = 0;
    char* p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p != '[') return 0;
    p++; // skip '['
    
    while (*p) {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\n' || *p == '\r')) p++;
        
        if (*p == ']') break;
        if (*p != '[') break;
        
        p++; // skip '['
        
        // Parse three numbers
        segments[count][0] = strtol(p, &p, 10);
        while (*p && *p != ',') p++;
        if (*p == ',') p++;
        
        segments[count][1] = strtol(p, &p, 10);
        while (*p && *p != ',') p++;
        if (*p == ',') p++;
        
        segments[count][2] = strtol(p, &p, 10);
        
        // Skip to ']'
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        count++;
    }
    
    return count;
}

char* solution(char* input) {
    static char output[100000];
    int segments[1000][3];
    
    int n = parse_segments(input, segments);
    if (n == 0) {
        strcpy(output, "[]");
        return output;
    }
    
    // Create events
    int event_count = 0;
    for (int i = 0; i < n; i++) {
        events[event_count].pos = segments[i][0];
        events[event_count].color = segments[i][2];
        events[event_count].type = 0; // start
        event_count++;
        
        events[event_count].pos = segments[i][1];
        events[event_count].color = segments[i][2];
        events[event_count].type = 1; // end
        event_count++;
    }
    
    // Sort events
    qsort(events, event_count, sizeof(Event), compare_events);
    
    // Process events
    memset(active_colors, 0, sizeof(active_colors));
    int result_count = 0;
    int prev_pos = -1;
    long long current_mix = 0;
    
    for (int i = 0; i < event_count; i++) {
        int pos = events[i].pos;
        
        // If we have a gap and active colors, record the segment
        if (prev_pos != -1 && prev_pos < pos && current_mix > 0) {
            results[result_count].start = prev_pos;
            results[result_count].end = pos;
            results[result_count].mix = current_mix;
            result_count++;
        }
        
        // Process all events at this position
        int j = i;
        while (j < event_count && events[j].pos == pos) {
            if (events[j].type == 0) { // start
                if (active_colors[events[j].color] == 0) {
                    current_mix += events[j].color;
                }
                active_colors[events[j].color]++;
            } else { // end
                active_colors[events[j].color]--;
                if (active_colors[events[j].color] == 0) {
                    current_mix -= events[j].color;
                }
            }
            j++;
        }
        i = j - 1;
        prev_pos = pos;
    }
    
    // Format output
    strcpy(output, "[");
    for (int i = 0; i < result_count; i++) {
        char segment[100];
        if (i > 0) strcat(output, ",");
        sprintf(segment, "[%d,%d,%lld]", results[i].start, results[i].end, results[i].mix);
        strcat(output, segment);
    }
    strcat(output, "]");
    
    return output;
}

int main() {
    static char input[10000];
    
    if (fgets(input, sizeof(input), stdin)) {
        // Remove trailing newline
        input[strcspn(input, "\n")] = 0;
        
        char* result = solution(input);
        printf("%s\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × r)

n segments × r coordinate range, checking each point against all segments

✓ Linear Growth

Space Complexity

O(r)

Store color information for each coordinate point

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

487 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 - Check Every Point — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler