LeeCode——#1024 视频拼接

自己琢磨了很久做出来的笨方法，和一些大佬的代码比不了，但自己觉得一些标志的设置还是有一定的参考价值，后面还会贴出一位大佬的作品供观摩。
题目描述：
你将会获得一系列视频片段，这些片段来自于一项持续时长为 T 秒的体育赛事。这些片段可能有所重叠，也可能长度不一。
视频片段 clips[i] 都用区间进行表示：开始于 clips[i][0] 并于 clips[i][1] 结束。我们甚至可以对这些片段自由地再剪辑，例如片段 [0, 7] 可以剪切成 [0, 1] + [1, 3] + [3, 7] 三部分。
我们需要将这些片段进行再剪辑，并将剪辑后的内容拼接成覆盖整个运动过程的片段（[0, T]）。返回所需片段的最小数目，如果无法完成该任务，则返回 -1 。
示例：
输入：clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], T = 10
输出：3

本人解决方案：

class Solution {
    public int videoStitching(int[][] clips, int T) {
        //先对clips进行排序，按第一位优先，第二位其次排序
        videoStitching(clips);
        if(clips[0][0]!=0){
            return -1;
        }
        int result = 0;
        int findex=0;
        //找出第一个不是[0,0]的起始位置
        while(clips[findex][1]==0){
            ++findex;
        }
        result = 1;
        //如果直接满足，返回结果
        if(clips[findex][1]>=T){
            return result;
        }
        //用front以及tail分别记录当前区段的头部以及尾部
        int front=0, tail=clips[findex][1];
        //tag用作标记
        int tag = tail;
        for (int i = findex; i < clips.length; i++) {
            if(clips[i][0]>tag){
                return -1;
            }else if (clips[i][0]>=front && clips[i][1]<=tag){
            }else{
                tag = clips[i][1];
                if(front == clips[i][0]){
                    tail = tag;
                    if(tag >= T){
                        if(result==0) {++result;}
                        return result;}
                }
                if(tag >= T){
                    return ++result;
                }else if(i<clips.length-1){
                    if(clips[i+1][0]>tail && clips[i+1][0]<tag+1){
                        tail = tag;
                        ++result;
                    }
                }
            }
        }
        if(tag<T){
            return -1;
        }else{
            return ++result;
        }
    }
    //以下算法实现双因素冒泡排序
    public static void videoStitching(int[][] clips) {
        int length = clips.length;
        int[] exchange = new int[2];
        boolean flag = true;
        for(int i=0; i<length-1; ++i){
            for (int j=0; j<length-1-i; ++j){
                if(clips[j][0]>clips[j+1][0]){
                    exchange = clips[j];
                    clips[j] = clips[j+1];
                    clips[j+1] = exchange;
                }
                if(clips[j][0]==clips[j+1][0] && clips[j][1]>clips[j+1][1]){
                    exchange = clips[j];
                    clips[j] = clips[j+1];
                    clips[j+1] = exchange;
                }
            }
        }
    }
}

某大佬作品:

class Solution {
    
    //执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
    //内存消耗：35.4 MB, 在所有 Java 提交中击败了100.00%的用户
    public int videoStitching(int[][] clips, int T) {
        if(T==0){
            return 0;
        }
        int l=clips.length;
        int[] a=new int[101];
        //意外情况处理变量
        int max=-1;
        //初始化"map"数组，下标对应最远值
        for(int i=0;i<l;i++){
            if(a[clips[i][0]]<clips[i][1]){
                a[clips[i][0]]=clips[i][1];
                if(max<clips[i][1])
                max=clips[i][1];
            }
        }
        //最大值达不到预期
        if(max<T){
            return -1;
        }
        //初始化，s是区间头，e是区间尾，num统计步数
        int s=0;
        int e=a[s];
        int num=1;
        //第一个就已经满足要求
        if(e>=T){
            return 1;
        }
        while(e<T){
            int end=e;
            //刷新进步，取最大值然后进步
            if(s+1<a.length){
                for(int j=s+1;j<=end;j++){
                    if(a[j]>e){
                        e=a[j];
                        s=j;
                    }
                }
            }
            //没有进步则退出循环
            if(end==e){
                break;
            }
            //有进步，则步数加1
            num++;
        }
        //是否是中途推出
        if(e<T){
            return -1;
        }
        return num;
    }
}

注：算法作者LeeCode ID为 “Wzxc.”，如有侵权，立马删除，感谢！