P7562 [JOISC 2021 Day4] イベント巡り 2 (Event Hopping 2) 题解

P7562 [JOISC 2021 Day4] イベント巡り 2 (Event Hopping 2)

lxl 上课讲了这题，我听了选取答案区间的思路，恍然大雾 ，于是就有了这篇题解——

sto lxl orz ！！！

---

本题解主要详解区间选取。

前置知识：倍增

---

策略

首先，本题的 \(L_i\)、\(R_i\) 较大，离散化即可。

另外，我个人觉得把所有的 \(R_i\) 减掉一之后会好写一点，转成了 \([L_i, R_i]\) 区间覆盖。然而我却调了半个多小时

然后问题是：若固定选择一个区间，最大化再向右选择的区间个数。

考虑贪心，每次选择没有交叉、右端点最靠左的。证明显然， 因为如果选择右端点更靠右的区间，那么能选的区间不会变多，答案只可能更劣。

由此一来，从每个区间开始，都有固定的方案来最大化答案，于是就能倍增啦～～

倍增

设 \(nxt[k][i]\) 表示从 \(i\) 开始选 \(2^k\) 个区间后最靠左的点。

\(nxt\) 数组的初值，可以枚举区间，用右端点更新左端点的 \(nxt\)：

\[nxt[0][L_i] = \min\left\{R_i + 1\right\} \]

（\(R_i\) 要加一是因为跳完 \([L_i,R_i]\) 这个区间后，下一个要从 \(R_i+1\) 开始）

转移方程也很显然：

\[nxt[k][i] = nxt[k-1][nxt[k-1][i]] \]

另外，由于区间之间可以有空隙，所以还要用 \(nxt[k][i + 1]\) 更新 \(nxt[k][i]\)。

怎么样，简单吧？

然后查询 \([L_i, R_i]\) 最多能放几个区间（以下写为 \(\operatorname{query}(L_i,R_i)\)）时，只要把 \(k\) 从大往小枚举，能跳尽量跳就行了，可以做到 \(O(log n)\)。

如何保证字典序最小？

首先，若 \(\operatorname{query}(1,m)<k\)（\(m\) 为值域），肯定无解。

否则，维护一些“块”。初始时块为 \([1,m]\)。

然后考虑这样做：从编号 \(1\) 到 \(n\) 枚举区间，若该区间被某一个块包含，并且选择该区间后仍有选择 \(k\) 个区间的方案（可以用 \(\operatorname{query}\) 算出，选它之后，块内最多可选区间个数的变化量来判断），那么直接选择该区间，并回收没有被区间覆盖的块。

如下图。

不难看出，这样做保证了有解的前提下，字典序最小。是不是很妙？

问题来了，要怎么维护“块”呢？方法有很多，这里介绍一种用 set 维护的方法。（类似 ODT 的思想，但是为了找相交的块所以用的 operator< 不一样）

写一个结构体，里面存 \(l\) 和 \(r\) ，重载运算符 < 为 r < t.l 。然后可以用 find() 函数找到与区间有交的块，再判断是否包含区间就好了。

注：find(k) 找到的是 x < k 和 k < x 都不满足的元素，所以相当于找与区间有交的块。

然后就做完了。时间复杂度 \(O(n\log n)\)。

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 2e5 + 5, LOGM = 19; // N是区间个数，M是值域
int n, K, li[N], ri[N];
int a[M], m; // 离散化数组
int nxt[LOGM][M];
struct range
{
    int l, r;
    bool operator<(const range t) const
    {
        return r < t.l;
    }
};
set<range> res; // 维护“块”
vector<int> ans; // 选择的区间

int lsh(int x) // 离散化
{
    return lower_bound(a + 1, a + m + 1, x) - a;
}

int query(int l, int r) // 查询[l,r]最多能放几个区间
{
    if (l > r) return 0;
    int res = 0;
    for (int k = LOGM - 1; k >= 0; k--)
        if (nxt[k][l] <= r + 1)
        {
            l = nxt[k][l];
            res += 1 << k;
        }
    return res;
}

int main()
{
    cin >> n >> K;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d%d", li + i, ri + i);
        ri[i]--; // 转为[l,r]
        a[++m] = li[i]; a[++m] = ri[i];
    }

    sort(a + 1, a + m + 1);
    m = unique(a + 1, a + m + 1) - a - 1;

    for (int k = 0; k < LOGM; k++)
        for (int i = 1; i <= m + 4; i++)
            nxt[k][i] = m + 3; // 设为极大值
    for (int i = 1; i <= n; i++)
    {
        li[i] = lsh(li[i]), ri[i] = lsh(ri[i]);
        nxt[0][li[i]] = min(nxt[0][li[i]], ri[i] + 1); // 赋nxt初值，注意要+1！
    }
    for (int i = m; i >= 1; i--)
    {
        nxt[0][i] = min(nxt[0][i + 1], nxt[0][i]); // 用后一个转移
        for (int k = 1; k < LOGM; k++)
            nxt[k][i] = min(nxt[k - 1][nxt[k - 1][i]], nxt[k][i + 1]); // 用小的合并
    }

    int sum = query(1, m);
    if (sum < K) // 无解就输出-1
    {
        puts("-1");
        return 0;
    }

    res.insert({1, m}); // 初始块为[1,m]
    for (int i = 1; i <= n; i++)
    {
        if (res.find({li[i], ri[i]}) == res.end()) continue; // 若没有相交，就肯定没有覆盖
        auto it = res.find({li[i], ri[i]});
        range tmp = *it;
        if (li[i] < tmp.l || tmp.r < ri[i]) continue; // 没有完全覆盖也不能选
        int delta = query(tmp.l, li[i] - 1) + 1 + query(ri[i] + 1, tmp.r) - query(tmp.l, tmp.r);
        if (sum + delta >= K) // 若选了该区间之后仍有合法方案
        {
            sum += delta;
            ans.push_back(i);
            res.erase(it);
            if (tmp.l <= li[i] - 1) res.insert({tmp.l, li[i] - 1}); // 回收左边剩下的块
            if (ri[i] + 1 <= tmp.r) res.insert({ri[i] + 1, tmp.r}); // 回收右边剩下的块
        }
        if (ans.size() >= K) break; // 选完了
    }
    for (auto &&i : ans)
        printf("%d\n", i);
    return 0;
}