看题解收获很大，区间问题和时间范围等问题常常是相通的，解决这些问题目前想到的就是区间拆分离散化或者端点贪心排序…

一个活动开始时，分配一间教室，一个活动结束时，释放一间教室，这样所需的教室数量上下浮动，而浮动过程中的最大值就是所需教室数量的最小值

没结束就不释放，结束了就把对应的教室释放，不用管释放的是哪一间教室

未来i同学实在是tql

这用到的还是贪心思想吗

这种思考方式像是差分，所以可以尝试用差分的思想写，看完楼主的代码，也可以康康这个。

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;


struct node{
    ll x,c;
    bool operator<(const struct node &T)const{
        if(x==T.x) return c<T.c;
        return x<T.x;
    } 
};
vector<node>q;


int main()
{
    cin.tie(0);std::ios::sync_with_stdio(false);

    ll n;
    cin>>n;
    for(ll i=1;i<=n;i++)
    {
        ll l,r;cin>>l>>r;
        q.push_back({l,1});
        q.push_back({r+1,-1});
    }
    sort(q.begin(),q.end());
    ll cnt=0;ll res=0;
    for(auto i:q)
    {
        cnt+=i.c;
        res=max(res,cnt);
    }
    cout<<res<<endl;
return 0;
}

为什么你们都这么强呀，我感觉我好菜哦，害

牛逼 学习了

问下楼主，结构体内当相等的时候吗，为什么返回 更小的c值

因为端点有交点算是相交的，楼主会将（右端点乘2 +1），（左端点乘2） ， 当右端点==左端点 ， 那么右端点会出现的比左端点更晚。 而我用的是差分，我的是（r+1)的点– ， 当我结构体 的 x是一样的时候，c只有为-1或者为1这两种情况 ， 当c == -1 时 ， 证明我服务的那条区间 的右端的是（x-1）, 所以更小的c会排更前。

明白了，也就是当相等时，意味着前以一个区间的右端点在当前的区间左端点的前面，并不会相交，因此c小的时候应该排在前面，很巧的思路，多谢解答

看到 1 -1 的时候 突然 y总敲了下我的脑壳，它突然就懂了，妙啊妙啊

666，如果能区间端点能重合的话，是不是端点标记的奇数偶数反一下就行了

是的

这个是为什么呢

因为对于同一个数,把它变成奇数比变成偶数大一

主要是在处理端点能不能重合的区别,自己写个样例就好理解了

666，完美解决我的疑问。

大佬有端点重合的代码吗

姐，不要这么强，把我搞自卑了

“普信男”这名字哈哈哈哈哈

真的很强，也把我搞自卑了www

b[idx ++] = l * 2;//标记左端点为偶数。
        b[idx ++] = r * 2 + 1;// 标记右端点为奇数。

其实这个点也比较重要吧，两端都是闭区间。
因此，不同区间左端点和右端点相等时，右端点的模拟值一定要比左端点的模拟值大。

相当于是 “最大区间厚度” 等价于了本题的 “最少分组数目”，既然要求所有活动不重合，那么我们就找到交集最多的一段重合区间，即最大的区间厚度，把他们分成不同的组，剩下的区间随便分给哪个组都可，因为不会再有比最大区间厚度还厚的了，所以本题相当于是让我们求 -> 最大区间厚度。

用你的思路做出来啦，感谢

#include <iostream>
#include <algorithm>

using namespace std;

typedef pair<int, int> PII;
const int N = 1e5 + 10;

int n;

PII edges[2 * N];

bool cmp(const PII a, const PII b)
{
    if(a.first == b.first) return false;
    return a.first < b.first;
}

int main()
{
    cin >> n;

    for(int i = 0; i < n; i ++ )
    {
        int l, r;
        cin >> l >> r;
        edges[i] = {l, 1}, edges[n + i] = {r, -1};
    }

    sort(edges, edges + 2 * n, cmp);

    // for(int i = 0; i < 2 * n; i ++ ) printf("[%d, %d]\n", edges[i].first, edges[i].second);

    int sum = 0, res = 0;
    for(int i = 0; i < 2 * n; i ++ )
    {
        res += edges[i].second;
        sum = max(sum, res);
    }

    cout << sum << endl;

    return 0;
}

理解了很久“求最大区间厚度”这句话，中于懂了，最多区间重叠部分

感谢楼主提供的思路，以下是我的代码，稍微简化了一下

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1e5 + 10;

int n;
int l[N], r[N];

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++ ) cin >> l[i] >> r[i];

    sort(l, l + n);
    sort(r, r + n);

    int res = 0;

    for (int i = 0, j = 0; i < n; i ++)
    {
        if (l[i] > r[j]) j ++;
        else res ++;
    }
    cout << res << endl;
    return 0;
}

请问为什么res初始化为1呢？ 我用int res =0试了一下，也ac了

res表示的是所求的最少需要的教室数量（最小组数），也即是所有浮动的教室数量的最大值，而数据至少输入一个活动（一个区间），所以至少需要一个教室，理论上只要初始化res<=1都是可以的

明白了，谢谢！

求的是最大值，t 负责计数，res 无关啦

什么是无意义的评论啊？

与讨论问题无关的吧， 比如tql之类的hhh

政治敏感、色情、暴力之类的吧

豁然开朗

太牛逼了

### tql看不懂

太妙了，左端点为奇数右端点为偶数也是有理解的，当出现左端点和右端点相同时，应该先ans++再ans–。

操作系统 进程处理思想，用的真活

没懂 进程处理 有啥思想，优先级吗？

前一个活动的结束时间和当前活动开始时间一样， 这个方法就不对了吧。
比如 [1,5] , [5,7] 只需要一间教室， 这个方法得出两间

这里活动的时间安排不能交叠的含义是边界也不能有交叠，与原题目的使得每组内部的区间两两之间（包括端点）没有交集保持一致，我这里引入这个问题是为了让大家好理解些。

而且我们在用这个方法求的时候，当出现了某个活动结束时间与另一个活动的开始时间相同的时候，由于开始的时间我们设置为偶数，结束时间为奇数，那么在计算的时候肯定是先遍历到开始时间先，再到结束时间。

啊。。这句话是什么意思啊？如果这个问题转换成教室使用的问题的话，时间使用在[1,5],[5,7]的时候应该怎么办呢？

如果是[1,5],[5,7],那么计算得到的结果就是[2,10,11,15],注意这个10是第二个区间的左端点,所以此时可以统计到结果最大为2

great

只能说 太牛逼了！

太 踏 🐎 🐂 🍺 了！

666