leetcode *1024. 视频拼接（2020.10.24）

【题目】*1024. 视频拼接

你将会获得一系列视频片段，这些片段来自于一项持续时长为 T 秒的体育赛事。这些片段可能有所重叠，也可能长度不一。

视频片段 clips[i] 都用区间进行表示：开始于 clips[i][0] 并于 clips[i][1] 结束。我们甚至可以对这些片段自由地再剪辑，例如片段 [0, 7] 可以剪切成 [0, 1] + [1, 3] + [3, 7] 三部分。

我们需要将这些片段进行再剪辑，并将剪辑后的内容拼接成覆盖整个运动过程的片段（[0, T]）。返回所需片段的最小数目，如果无法完成该任务，则返回 -1 。

示例 1：

输入：clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], T = 10
输出：3
解释：
我们选中 [0,2], [8,10], [1,9] 这三个片段。
然后，按下面的方案重制比赛片段：
将 [1,9] 再剪辑为 [1,2] + [2,8] + [8,9] 。
现在我们手上有 [0,2] + [2,8] + [8,10]，而这些涵盖了整场比赛 [0, 10]。

示例 2：

输入：clips = [[0,1],[1,2]], T = 5
输出：-1
解释：
我们无法只用 [0,1] 和 [1,2] 覆盖 [0,5] 的整个过程。

示例 3：

输入：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,5],[5,7],[6,9]], T = 9
输出：3
解释： 
我们选取片段 [0,4], [4,7] 和 [6,9] 。

示例 4：

输入：clips = [[0,4],[2,8]], T = 5
输出：2
解释：
注意，你可能录制超过比赛结束时间的视频。

提示：
1 <= clips.length <= 100
0 <= clips[i][0] <= clips[i][1] <= 100
0 <= T <= 100

【解题思路1】动态规划

dp数组的含义： dp[i] 表示将区间 [0,i) 覆盖所需的最少子区间的数量
初始化： dp[i] 的初始值设为一个大整数，并将 dp[0]（即空区间）的初始值设为 0。

状态转移方程：
枚举所有的子区间来依次计算出所有的 dp 值。首先枚举 i，然后遍历 clips 的区间。

对于任意一个子区间 [a,b]，若其满足 a < i ≤ b，那么它就可以覆盖区间 [0, i] 的后半部分，而前半部分则可以用 dp[a] 对应的最优方法进行覆盖，dp[i] = min (dp[a]) + 1 (a < i ≤ b)

最终的答案即为 dp[T]。

class Solution {
    public int videoStitching(int[][] clips, int T) {
        int[] dp = new int[T + 1];
        Arrays.fill(dp, Integer.MAX_VALUE - 1);
        dp[0] = 0;
        for (int i = 1; i <= T; i++) {
            for (int[] clip : clips) {
                if (clip[0] < i && i <= clip[1]) {
                    dp[i] = Math.min(dp[i], dp[clip[0]] + 1);
                }
            }
        }
        return dp[T] == Integer.MAX_VALUE - 1 ? -1 : dp[T];
    }
}

【解题思路2】贪心

可以参考「55. 跳跃游戏」，使用贪心解决这道题。

对于所有左端点相同的子区间，其右端点越远越有利。最佳方案中不可能出现两个左端点相同的子区间。

• 预处理所有的子区间，对于每一个位置 i，记录以其为左端点的子区间中最远的右端点，记为 maxn[i]。

• [0, T] 遍历每个位置 i ，记左端点不大于 i 的所有子区间的最远右端点为 last， last 就代表了当前能覆盖到的最远的右端点。每次都用 maxn[i] 来更新 last。如果更新后 last==i，那么说明下一个位置无法被覆盖，无法完成目标。

• 遍历时还需要记录上一个被使用的子区间的结束位置为 pre，每次越过一个被使用的子区间，就说明要启用一个新子区间，这个新子区间的结束位置即为当前的 last。也就是说，每次遇到 i==pre，则说明用完了一个被使用的子区间。这种情况下让答案加 1，并更新 pre = last 。

class Solution {
    public int videoStitching(int[][] clips, int T) {
        int[] maxn = new int[T];
        int last = 0, ans = 0, pre = 0;
        for (int[] clip : clips) {
            if (clip[0] < T) {
                maxn[clip[0]] = Math.max(maxn[clip[0]], clip[1]);
            }
        }
        for (int i = 0; i < T; i++) {
            last = Math.max(last, maxn[i]); // 更新当前能覆盖到的最右边界
            if (i == last) { // 因为clips里不会出现左区间=右区间的情况，所以可以这么判断无法覆盖更远
                return -1;
            }
            if (i == pre) { // 过了上一个clips
                ans++;
                pre = last;
            }
        }
        return ans;
    }
}

class Solution {
public:
    int videoStitching(vector<vector<int>>& clips, int T) {
        vector<int> maxn(T); // 默认初始值为0，如果用int maxn[T]需要自己初始化
        int last = 0, pre = 0, ans = 0;
        for(vector<int>& it : clips) {
            if(it[0] < T) {
                maxn[it[0]] = max(it[1], maxn[it[0]]);
            }
        }

        for(int i = 0; i < T; i++) {
            cout<<maxn[i]<<endl;
            last = max(last, maxn[i]);
            if(i == last)   return -1;
            if(i == pre) {
                ans++;
                pre = last;
            }
        }

        return ans;
    }
};