Video Stitching

Video Stitching - Problem

You are given a series of video clips from a sporting event that lasted time seconds. These video clips can be overlapping with each other and have varying lengths.

Each video clip is described by an array clips where clips[i] = [start_i, end_i] indicates that the ith clip started at start_i and ended at end_i.

We can cut these clips into segments freely. For example, a clip [0, 7] can be cut into segments [0, 1] + [1, 3] + [3, 7].

Return the minimum number of clips needed so that we can cut the clips into segments that cover the entire sporting event [0, time]. If the task is impossible, return -1.

Input & Output

Example 1 — Basic Coverage

$ Input: clips = [[0,2],[1,9],[1,5],[3,8]], time = 5

› Output: 2

💡 Note: We need clip [0,2] to cover [0,2] and clip [1,9] to cover [2,5], so minimum 2 clips are needed

Example 2 — Multiple Clips Needed

$ Input: clips = [[0,1],[1,2]], time = 5

› Output: -1

💡 Note: The clips only cover [0,2] but we need to cover [0,5], making it impossible

Example 3 — Optimal Combination

$ Input: clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,6],[5,7],[6,9]], time = 9

› Output: 3

💡 Note: Use clips [0,4], [2,6], [6,9] to cover [0,9] with minimum 3 clips

Constraints

1 ≤ clips.length ≤ 100
0 ≤ start_i ≤ end_i ≤ 100
1 ≤ time ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 Apple 8 m Microsoft 6

The key insight is to use a greedy approach: always pick the clip that extends the current coverage furthest. Sort clips by start time, then iteratively select clips that maximize coverage extension. Best approach is greedy with Time: O(n log n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ × n) Space: O(n)

Generate all possible subsets of clips and check if they cover [0, time]. Among valid combinations, return the one with minimum clips.

Dynamic Programming - Minimum Clips DP

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

Create DP array where dp[i] represents minimum clips needed to cover interval [0,i]. For each position, try all clips that can cover it.

Greedy - Maximum Coverage Extension

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

Sort clips by start time, then iteratively pick the clip that extends the current coverage the furthest. This ensures minimum clips needed.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n subsets of clips
Check if each subset covers [0, time]
Return minimum size among valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations of clips

Check Coverage

For each subset, verify if it covers [0, time]

Find Minimum

Return the smallest valid subset size

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Clip;

int compareClips(const void* a, const void* b) {
    Clip* clipA = (Clip*)a;
    Clip* clipB = (Clip*)b;
    return clipA->start - clipB->start;
}

int coversInterval(Clip* clips, int numClips, int time) {
    // Sort clips by start time
    qsort(clips, numClips, sizeof(Clip), compareClips);
    
    // Merge overlapping intervals
    Clip merged[1000];
    int mergedCount = 0;
    
    for (int i = 0; i < numClips; i++) {
        int start = clips[i].start;
        int end = clips[i].end;
        if (mergedCount > 0 && start <= merged[mergedCount-1].end) {
            if (end > merged[mergedCount-1].end) {
                merged[mergedCount-1].end = end;
            }
        } else {
            merged[mergedCount].start = start;
            merged[mergedCount].end = end;
            mergedCount++;
        }
    }
    
    // Check if merged intervals cover [0, time]
    return mergedCount == 1 && merged[0].start <= 0 && merged[0].end >= time;
}

int solution(int clips[][2], int clipsSize, int time) {
    int n = clipsSize;
    int minClips = INT_MAX;
    
    // Try all possible subsets
    for (int mask = 1; mask < (1 << n); mask++) {
        Clip selectedClips[100];
        int selectedCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                selectedClips[selectedCount].start = clips[i][0];
                selectedClips[selectedCount].end = clips[i][1];
                selectedCount++;
            }
        }
        
        // Check if this subset covers [0, time]
        if (coversInterval(selectedClips, selectedCount, time)) {
            if (selectedCount < minClips) {
                minClips = selectedCount;
            }
        }
    }
    
    return minClips == INT_MAX ? -1 : minClips;
}

void parseArray(const char* str, int clips[][2], int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        
        // Look for start of inner array
        if (*p == '[') {
            p++; // skip '['
            
            // Parse first number
            while (*p == ' ') p++;
            int start = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p == ' ' || *p == ',') p++;
            
            // Parse second number
            int end = (int)strtol(p, (char**)&p, 10);
            
            // Skip to closing bracket
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            clips[*size][0] = start;
            clips[*size][1] = end;
            (*size)++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
}

int main() {
    int clips[100][2];
    int clipsSize = 0;
    int time;
    
    char line[10000];
    if (fgets(line, sizeof(line), stdin) != NULL) {
        parseArray(line, clips, &clipsSize);
    }
    
    if (scanf("%d", &time) != 1) {
        return 1;
    }
    
    int result = solution(clips, clipsSize, time);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

2^n subsets to check, each taking O(n) time to validate coverage

⚡ Linearithmic

Space Complexity

O(n)

Space for recursion stack and temporary subset storage

✓ Linear Space

32.0K 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler