【LeetCode刷题（中等程度）】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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/video-stitching
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：视频片段，用或者不用。用就加1，并且用过的片段会影响到以后视频片段的使用。动态规划。

比较难想到的是怎么定义这个状态：
如果我们用f[i]来表示：复原区间[0,i)所使用的最少的片段数。

那么初始状态：f[0] = 0表示复原区间[0,0)所使用的片段数为0。

那么什么时候才更新呢？
考虑区间是否使用区间[a,b)如果有：a < i <=b，那么b可以作为更新区间[0,i)的右端点，而前半部分则可以用f[a]对应的最优方法进行覆盖，因此我们可以用f[a] + 1 来更新 f[i]。状态转移方程如下：
f[i] = min(f[i],f[a] + 1)

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/video-stitching/solution/shi-pin-pin-jie-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

代码实现：

class Solution {
public:
    int videoStitching(vector<vector<int>>& clips, int T) {
        vector<int>f(T + 1,INT_MAX - 1);
        f[0] = 0;

        for(int i = 1;i <= T;++i)
        {
            for(const auto& clip : clips)
            {
                if(clip[0] < i && i<= clip[1])
                {
                    f[i] = min(f[i],f[clip[0]] + 1);
                }
            }
        }
        return f[T] == INT_MAX - 1 ? -1 : f[T];
    }
};

贪心算法：此题可以参考55. 跳跃游戏，首先将各个区间按左端点进行排序，我们选取合并区间的原则是：
该区间左端点小于已经合并区间的右端点，并且该区间的右端点是所有满足前一个条件的里面的最大的，因为要使合并的区间数最少，那么应该尽量使每个区间的跨度大。

class Solution {
public:
    struct 
        {
            bool operator()(const vector<int> &a,const vector<int> &b) const
            {   
                return a[0] < b[0];
            }   
        } customLess;
    int videoStitching(vector<vector<int>>& clips, int T) {
        int n = clips.size();
        if(n == 0)
            return 0;
        sort(clips.begin(),clips.end(),customLess);
        int res = 0,left = 0,right = 0;//left到right为已经加入进来的区间 res为选择的最优区间数
        int i = 0;
        while(i < n && right < T)//依次遍历每个区间
        {
            int nr = right,flag = 0;//nr表示下一可合并区间的右端点 flag表示是否存在下一个合并区间
            //待合并区间的左端点要大于等于已合并区间的右端点
            while(i < n && clips[i][0] <= right)//找到一个最右端点最大的 可合并的区间
            {
                nr = max(nr,clips[i][1]);//寻找最大的右端点
                ++i;
                flag = 1;//表示找到一个
            }

            if(!flag)//表示已经没有可以寻找的区间了
                break;
            right = nr;
            res++;
        }
        return right < T? -1:res;//看我们最后选取的最右端点是否满足要求
    }
};