解法一

引理：令一个二分图两部分别为 \(X, Y(|X| \le |Y|)\)，若其存在完美匹配当且仅当 \(\forall S \subseteq X, f(S) \ge |S|\)（其中 \(f(S)\) 表示 \(S\) 连到的点集）。（即霍尔定律）

可以发现，原题要求的本质上就是最少添加几个椅子使得构成完美匹配。

那么添加的椅子能使得所有人都能选一定是最好的，故根据霍尔定律我们要求的本质上是 \(\max\limits_{S \subseteq X}{|S| - |f(S)|}\)，即 \(\max\limits_{S \subseteq X} |S| - \bigcup\limits_{i \in S} [0, l_i] \cup [r_i, m]\)。

注意到并集是不好处理的，在我们知道全集的情况下可以反过来考虑求其补集的交即：\(\max\limits_{S \subseteq X} |S| + \bigcap\limits_{i \in S} [l_i, r_i] - m\)。

可以发现我们是不好直接枚举点集的，但是在枚举区间的情况下统计存在多少个包含这样区间的点有多少个是非常好统计的。

于是先预处理好每个位置包含多少个右端点和左端点然后使用前缀和容斥计算即可做到 \(\mathcal{O(n + m ^ 2)}\)。

考虑优化这个流程，只枚举左端点 \(l\) 然后动态维护所有点中左端点在 \(l\) 左侧的点所组成的点集对对于每个右端点的答案。

不难发现在左端点移动的时候只需要支持区间加和求区间最大值，使用线段树即可。

#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l; i <= r; ++i)
const int N = 2e5 + 5;
struct node { int l, r;} a[N];
int n, m, ans;
int read() {
    char c; int x = 0, f = 1;
    c = getchar();
    while (c > '9' || c < '0') { if(c == '-') f = -1; c = getchar();}
    while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x * f;
}
namespace ST {
    #define ls (p << 1)
    #define rs (p << 1 | 1)
    #define mid (l + r >> 1)
    struct tree { int mx, tag;} t[N << 2];
    void lazy(int p, int k) { t[p].mx += k; t[p].tag += k;}
    void pushup(int p) { t[p].mx = max(t[ls].mx, t[rs].mx);}
    void down(int p) { lazy(ls, t[p].tag), lazy(rs, t[p].tag); t[p].tag = 0;}
    void build(int p, int l, int r) {
        if(l == r) { t[p].mx = l; return ;}
        build(ls, l, mid), build(rs, mid + 1, r);
        pushup(p);
    }
    void update(int p, int l, int r, int x, int y, int k) {
        if(x > y) return ;
        if(l >= x && r <= y) { lazy(p, k); return ;}
        down(p);
        if(mid >= x) update(ls, l, mid, x, y, k);
        if(mid < y) update(rs, mid + 1, r, x, y, k);
        pushup(p);
    }
    int query(int p, int l, int r, int x, int y) {
        if(x > y) return 0;
        if(l >= x && r <= y) return t[p].mx;
        down(p); int ans = 0;
        if(mid >= x) ans = max(ans, query(ls, l, mid, x, y));
        if(mid < y) ans = max(ans, query(rs, mid + 1, r, x, y));
        return ans;
    }
}
bool cmp(node a, node b) { return a.l == b.l ? a.r > b.r : a.l < b.l;}
int main() {
    n = read(), m = read() + 1;
    rep(i, 1, n) a[i].l = read() + 2, a[i].r = read();
    ST :: build(1, 1, m);
    sort(a + 1, a + n + 1, cmp);
    rep(i, 1, n) {
        if(a[i].l > m || a[i].l > a[i].r) { ans = max(ans, n - m + 1); continue;}
        ST :: update(1, 1, m, 1, min(a[i].r, m), 1);
        ans = max(ans, ST :: query(1, 1, m, a[i].l, m) - a[i].l - m + 2);
    }
    printf("%d", ans);
    return 0;
}

解法二

从特殊的情形出发，若只存在左端点的限制，那么我们只需将所有人按照左端点从小到大排序维护当前选到的最前位置然后贪心地让每个人选取即可。

此时出现了对于右端点的限制，可以调整上述这个贪心。

首先我们还是按照左端点排序，能选择选。

若出现不能选择的情况，那么此时 \(j\) 总是能替换掉之前选择过的一个人使得答案不变的，但显然的是不是所有情况都能替换。

近一步观察可以发现如果之前选择的 \(i\) 的 \(r_i < r_j\) 那么此时 \(j\) 替换 \(i\) 一定是更优的，因为将 \(i\) 留下放在右边的可能性比 \(j\) 大，同时为了最大化这个可能每次我们只能选择替换 \(r_i\) 最小的 \(i\)，使用小根堆维护即可。

那么最后我们可以得到一个拿出来需要放置在右侧的一个序列，此时就只有右端点的限制了直接做最开始的贪心即可。

#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l; i <= r; ++i)
const int N = 2e5 + 5;
struct node { int l, r;} a[N];
int n, m, L, P, cnt, b[N];
priority_queue <int, vector <int>, greater <int> > Q;
bool cmp1(node a, node b) { return a.l < b.l;}
bool cmp2(int a, int b) { return a > b;}
int main() {
    cin >> n >> m;
    rep(i, 1, n) cin >> a[i].l >> a[i].r;
    sort(a + 1, a + n + 1, cmp1);
    P = 1;
    rep(i, 1, n) {
        if(P <= a[i].l) ++P, Q.push(a[i].r);
        else {
            if(!Q.empty() && a[i].r > Q.top()) b[++cnt] = Q.top(), Q.pop(), Q.push(a[i].r);
            else b[++cnt] = a[i].r;
        }
    }
    sort(b + 1, b + cnt + 1, cmp2);
    L = P, P = m;
    rep(i, 1, cnt) if(P >= b[i] && P >= L) --P;
    printf("%d", n - (m - P + L - 1));
    return 0;
}

在解法一当中，多次使用正难则反的思想，这是需要注意的解题关键。

在解法二当中，使用的是放宽条件特殊化问题之后通过调整使得其能适应原问题。