Video Stitching - Practice Coding Problems

Video Stitching - Problem

Video Stitching Challenge: You're working as a video editor for a sports broadcasting company. You have multiple video clips from a sporting event that lasted time seconds, and these clips can overlap and have varying lengths. Each clip is represented as [start_i, end_i] indicating when it begins and ends.

Your task is to find the minimum number of clips needed to create a complete coverage of the entire event from [0, time]. You can cut clips into smaller segments (e.g., clip [0, 7] can become [0, 1] + [1, 3] + [3, 7]).

Goal: Return the minimum clips needed to cover [0, time], or -1 if impossible.

Input & Output

example_1.py — Basic Coverage

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

› Output: 3

💡 Note: We can use clips [0,2], [1,9], and [8,10] to cover the entire interval [0,10]. The clip [1,9] covers most of the middle portion efficiently.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: There's a gap between [1,2] that cannot be covered by any available clips, making it impossible to cover [0,5] completely.

example_3.py — Single Clip Solution

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

› Output: 2

💡 Note: We need both clips: [0,1] covers the first part and [1,2] covers the second part to achieve complete coverage of [0,2].

Visualization

Tap to expand

Understanding the Visualization

Survey Available Planks

Sort all planks by their starting position to understand your options

Choose Optimal Plank

At each gap, select the plank that extends furthest while covering the current position

Place and Advance

Place the chosen plank and move to the new furthest point

Complete Bridge

Repeat until the entire river span [0, time] is covered

Key Takeaway

🎯 Key Insight: The greedy approach works because extending coverage as far as possible at each step minimizes the total number of clips needed.

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subset and coverage tracking

⚡ Linearithmic Space

Constraints

1 ≤ clips.length ≤ 100
0 ≤ start_i ≤ end_i ≤ 100
1 ≤ time ≤ 100
Each clip can be used at most once

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses a greedy algorithm with O(n log n) time complexity. Sort clips by start time, then greedily select clips that extend coverage the furthest at each step. This minimizes the total number of clips needed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × n)	O(n)	Try all possible combinations of clips to find minimum coverage
Greedy Approach (Optimal)	O(n log n)	O(1)	Sort clips and greedily select the one that extends coverage the furthest

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of clips using bit manipulation
For each subset, check if it covers [0, time] completely
Track the minimum size among valid subsets
Return the minimum count or -1 if no valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsets

Create all 2^n possible combinations using bit manipulation

Check Coverage

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

Track Minimum

Keep track of the smallest valid combination found

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* ia = *(int**)a;
    int* ib = *(int**)b;
    return ia[0] - ib[0];
}

int coversInterval(int** clips, int clipSize, int mask, int time) {
    int** intervals = malloc(clipSize * sizeof(int*));
    int count = 0;
    
    for (int i = 0; i < clipSize; i++) {
        if (mask & (1 << i)) {
            intervals[count++] = clips[i];
        }
    }
    
    qsort(intervals, count, sizeof(int*), compare);
    
    if (count == 0 || intervals[0][0] > 0) {
        free(intervals);
        return 0;
    }
    
    int currentEnd = 0;
    for (int i = 0; i < count; i++) {
        if (intervals[i][0] > currentEnd) {
            free(intervals);
            return 0;
        }
        if (intervals[i][1] > currentEnd) {
            currentEnd = intervals[i][1];
        }
        if (currentEnd >= time) {
            free(intervals);
            return 1;
        }
    }
    
    int result = currentEnd >= time;
    free(intervals);
    return result;
}

int videoStitching(int** clips, int clipSize, int* clipColSize, int time) {
    int minClips = INT_MAX;
    
    for (int mask = 1; mask < (1 << clipSize); mask++) {
        if (coversInterval(clips, clipSize, mask, time)) {
            int bits = __builtin_popcount(mask);
            if (bits < minClips) {
                minClips = bits;
            }
        }
    }
    
    return minClips == INT_MAX ? -1 : minClips;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subset and coverage tracking

⚡ Linearithmic Space

Constraints

1 ≤ clips.length ≤ 100
0 ≤ start_i ≤ end_i ≤ 100
1 ≤ time ≤ 100
Each clip can be used at most once

38.0K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler