1750 救生员（枚举 + 区间合并、线段树）

1. 问题描述：

农夫约翰为他的牛开设了一个游泳池，他认为这将帮助它们放松并产出更多的奶。为了确保安全，他雇佣了 N 头奶牛作为救生员，每头奶牛的工作班次都是一段连续的时间。为了简单起见，游泳池每天的开放时间从时刻 0 到时刻 1000。每个奶牛的工作班次都可以用两个整数来描述，它们分别表示该奶牛工作班次的开始时刻和结束时刻。例如，从时刻 t=4 开始工作并在时刻 t=7 结束工作的救生员，它的工作时间为三个时间单位（请注意，时间"段"两端的端点是时间轴上的"点"）。不幸的是，由于资金紧张问题，约翰不得不解雇一头奶牛。请问通过合理裁员，剩余救生员的工作班次仍然可以覆盖的最大时间有多长？一个时间间隔内如果存在至少一名救生员当值，那么这个时间间隔就认为是被覆盖的。

输入格式

第一行包含整数 N。接下来 N 行，每行描述一个救生员的工作班次，包含两个整数，表示一个救生员的开始工作时刻和结束工作时刻。所有时刻各不相同，不同救生员的工作班次可能有覆盖。

输出格式

输出一个整数，表示解雇掉一头奶牛后，剩余救生员的工作班次仍然可以覆盖的最长时间。

数据范围

1 ≤ N ≤ 100
0 ≤ 开始时刻 ≤ 结束时刻 ≤ 1000

输入样例：

3
5 9
1 4
3 7

输出样例：

7
来源：https://www.acwing.com/problem/content/description/1752/

2. 思路分析：

因为数据规模比较小所以我们可以考虑枚举来解决，我们可以从小到大枚举所有的区间，表示删除掉当前的区间，枚举删除当前的区间之后合并剩余的区间计算剩余的区间能够覆盖的最长时间，除了使用枚举的方法之外，因为涉及到区间的修改与查询的问题所以我们还可以使用线段树来解决，不过线段树解决的话代码比较难写一点。

3. 代码如下：

枚举 + 区间合并：

class Solution:
    def process(self):
        n = int(input())
        p = list()
        for i in range(n):
            x, y = map(int, input().split())
            p.append((x, y))
        # 按照横坐标从小到大进行排序
        p.sort(key=lambda x: x[0])
        res = 0
        # 枚举删除掉哪一个区间
        for i in range(n):
            # 区间的起点和终点
            st = ed = -1
            # _sum计算合并之后的区间和
            _sum = 0
            for j in range(n):
                # 从第一个区间开始枚举并且不能够合并当前的区间所以i != j
                if i != j:
                    if p[j][0] <= ed: ed = max(ed, p[j][1])
                    # 新的区间开始了
                    else:
                        # 计算上一个区间长度
                        _sum += ed - st
                        # 更新当前的起点和终点
                        st = p[j][0]
                        ed = p[j][1]
            # 计算剩余最后一段的区间和
            _sum += ed - st
            # 更新答案
            res = max(res, _sum)
        return res


if __name__ == '__main__':
    print(Solution().process())

线段树（源代码链接）：

#include<bits/stdc++.h>
using namespace std;

#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define x first
#define y second
using pii = pair<int, int>;

int n;
pii q[110];

struct Node{
    int l, r;
    // len维护区间被覆盖的长度(结合cnt进行维护)
    int cnt, len;

    #define ls u<<1
    #define rs u<<1|1
}tr[1010<<2];

void build(int u, int l, int r){
    tr[u]={l, r};
    if(l==r) return;
    int mid=l+r>>1;
    build(ls, l, mid), build(rs, mid+1, r);
}

void pushup(int u){
    if(tr[u].cnt) tr[u].len=tr[u].r-tr[u].l+1;
    else tr[u].len=tr[ls].len+tr[rs].len;
}

void upd(int u, int l, int r, int k){
    if(l<=tr[u].l && tr[u].r<=r) return tr[u].cnt+=k, pushup(u), void();
    int mid=tr[u].l+tr[u].r>>1;
    if(l<=mid) upd(ls, l, r, k);
    if(mid<r) upd(rs, l, r, k);
    pushup(u);
}

int main(){
    cin>>n;
    // 先要将区间转换为[l, r - 1]这样才是正确的, 因为后面涉及到r - l + 1的维护区间长度的操作
    rep(i,1,n) cin>>q[i].x>>q[i].y, q[i].y--;
    build(1, 0, 1000);
    rep(i,1,n) upd(1, q[i].x, q[i].y, 1);

    int res=0;
    rep(i,1,n){
        // 枚举删除掉当前的区间
        upd(1, q[i].x, q[i].y, -1);
        res=max(res, tr[1].len);
        // 维护到原来未删除当前区间的的状态
        upd(1, q[i].x, q[i].y, 1);
    }
    cout<<res<<endl;
    return 0;
}