你將會獲得一系列視訊片段，這些片段來自於一項持續時長為time秒的體育賽事。這些片段可能有所重疊，也可能長度不一。

使用陣列clips 描述所有的視訊片段，其中 clips[i] = [starti, endi] 表示：某個視訊片段開始於starti並於endi結束。

甚至可以對這些片段自由地再剪輯：

例如，片段[0, 7]可以剪下成[0, 1] +[1, 3] + [3, 7]三部分。
我們需要將這些片段進行再剪輯，並將剪輯後的內容拼接成覆蓋整個運動過程的片段（[0, time]）。返回所需片段的最小數目，如果無法完成該任務，則返回-1 。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/video-stitching

排序 + 優先佇列

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

class Solution {
    public int videoStitching(int[][] clips, int time) {
        if (clips == null || clips.length == 0) {
            return -1;
        }
        Arrays.sort(clips, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return Integer.compare(o1[0], o2[0]);
            }
        });

        int ret = 0;
        int curPos = 0;
        PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return Integer.compare(o2[1], o1[1]);
            }
        });

        int idx = 0;

        while (idx < clips.length) {
            while (idx < clips.length && clips[idx][0] <= curPos) {
                queue.offer(clips[idx++]);
            }
            if (queue.isEmpty()) {
                return -1;
            }

            int[] best = queue.poll();

            if (best[1] > curPos) {
                curPos = best[1];
                ret++;
                if (curPos >= time) {
                    return ret;
                }
                queue.clear();
            } else {
                return -1;
            }
        }

        return -1;

    }
}
 

動態規劃

import java.util.Arrays;

class Solution {
    public int videoStitching(int[][] clips, int time) {
        if (clips == null || clips.length == 0) {
            return -1;
        }
        int[] dp = new int[time + 1];
        Arrays.fill(dp, Integer.MAX_VALUE - 1);
        dp[0] = 0;

        for (int i = 1; i <= time; ++i) {
            for (int[] clip : clips) {
                if (clip[0] < i && i <= clip[1]) {
                    dp[i] = Math.min(dp[i], dp[clip[0]] + 1);
                }
            }
        }

        return dp[time] == Integer.MAX_VALUE - 1 ? -1 : dp[time];
    }
}
 

貪心

import java.util.Arrays;

class Solution {
    public int videoStitching(int[][] clips, int time) {
        if (clips == null || clips.length == 0) {
            return -1;
        }
        int[] maxDistance = new int[time];
        for (int[] clip : clips) {
            if (clip[0] < time) {
                maxDistance[clip[0]] = Math.max(maxDistance[clip[0]], clip[1]);
            }
        }

        int ret = 0, pre = 0, last = 0;
        for (int i = 0; i < time; ++i) {
            last = Math.max(last, maxDistance[i]);
            if (last == i) {
                return -1;
            }
            if (i == pre) {
                ret++;
                pre = last;
            }
        }
        return ret;
    }
}