Kick Start 2019 Round A Contention

$$

[题目链接](https://codingcompetitions.withgoogle.com/kickstart/round/0000000000050e01/0000000000069881)

题目大意

一排 $N$ 个座位，从左到右编号 $1$ 到 $N$ 。

有 $Q$ 个预定座位的请求，第 $i$ 个请求想要预定编号从 $L_i$ 到 $R_i$ 的所有座位。

可以按任意顺序处理这 $Q$ 个请求，处理一个请求时，把对应区间中尚未被分配的座位分配给这个请求。

试问每个请求最终订到的座位数量的最小值最大可能是多少？

Limits

• Time limit: 30 seconds per test set.
• Memory limit: 1GB.
• Number of test cases $T=100$.
• $1\le N\le {10}^6$.
• $1\le L_i\le R_i\le N$.
• $1\le Q\le 30000$.
• For at least 85 of the test cases, $Q\le 3000$.

分析

Observation 1： 第 $i$ 个被处理的请求所获得的座位数量与处理前 $i-1$ 个请求的顺序无关。

Observation 2：
设 $A,B$ 是相邻的两个请求。假设若先处理 $A$，则 $A$ 得到 $a$ 个座位；若先处理 $B$，则 $B$ 得到 $b$ 个座位；又设 $A,B$ 两请求共得到 $c$ 个座位，显然 $c$ 跟 $A,B$ 被处理的先后顺序无关，且有 $a+b\ge c$ 。不妨设 $a>b$ 。若先 $A$ 后 $B$ 则两个请求得到的座位数的最小值为 $min(a,c-a)=c-a$；若先 $B$ 后 $A$，则最小值为 $min(b,c-b)$ 。注意到 $b\ge c-a$ 且 $c-b>c-a$，故有 $min(b,c-b)\ge min(a,c-a)$；换言之，对于相邻的两个请求，应当先处理分到座位较少的那个请求。

注意：满足上述条件的处理顺序也许不唯一，因为 $a,b$ 的大小关系依赖于之前处理的那些请求。

到这里我就想不通了。

---

官方题解

We can observe that for a chosen ordering of the requests, the number of seats that the system books in the last request does not depend on the ordering of the previous $Q-1$ requests. So, we could start by finding the request to be processed last and move backwards towards the earlier requests.

这一段我能理解，但问题在于 how can you determine which request should be processed last in an optimal solution?

---

我想通了。

考虑若干个请求的任意排列，按此排列进行操作，把每个请求获得的座位数的最小值简称为此「排列的最小值」。

Key observation：

从任意 $k$（$k>1$）个请求的任意排列中拿走一个请求，余下的 $k-1$ 请求的排列的最小值一定不小于原先 $k$ 个请求的排列的最小值。

定义函数 $f(x)$ 表示最后（即第 $Q$ 个）处理请求 $x$，$x$ 能得到多少个座位。将 $f(x)$ 的最大值记作 $m$ 。

对于 $Q$ 个请求的任一排列 $P:=p_1,p_2,\dots ,p_Q$，设其最小值为 $a$ 。
假设 $f(p_Q)<m$，我们有 $a\le f(p_Q)<m$，又设 $f(p_i)=m$；
考虑排列 $P^{\prime }:=p_1,p_2,\dots ,p_{i-1},p_{i+1},p_{i+2},\dots ,p_Q$ ，设其最小值为 $b$ 。
对比 $P$ 和 $P^{\prime }$ 这两个排列；显然，$p_1,p_2\dots ,p_{i-1}$ 这些请求获得的座位数不变；在 $P^{\prime }$ 中，由于少了 $p_i$ 的竞争，$p_{i+1},p_{i+2},\dots ,p_Q$ 这些请求获得的座位数不会减少；于是有 $b\ge a$ 。

考虑排列 $P^{″}:=p_1,p_2,\dots ,p_{i-1},p_{i+1},\dots ,p_Q,p_i$，设其最小值为 $c$，易见 $c=min(b,m)$ 。
由于 $b\ge a$ 且 $m>a$ 故有 $c\ge a$ 。所以把 ${\arg \max }_{x}f(x)$ 放最后能导致最优解。

官方题解的做法是根据上述贪心策略，用数据结构辅助求解 ${\arg \max }_{x}f(x)$；这里不详述，只给出代码。

接下来给出另一种做法：二分答案。

Another approach：二分答案

这种做法来自 Mahmoudian 的 submission，其思路比官方解法更为简单，巧妙而富有启发性。

此做法的最坏时间复杂度是 $O(Q^2\log N)$；不过由于常数小并且在随机数据上复杂度离此上界甚远，实际上相当快，明显快于官方题解中给出的基于线段树的算法。

我对其代码做了少许修改并加了注释

const int Q = 30000;
int n, q, xl[Q], xr[Q], mvl[Q]; // mvl意思是move l to a new index
pair<int, int> sr[Q]; // sr 代表 sort

int check(int k) {
    for (int j = 0; j < q; ++j)
        mvl[j] = xl[j];
    for (int j = 0; j < q; ++j) {
        int r = xr[j];
        int st = mvl[j]; // st即start，表示当前能分配给j的那一段的左端点
        int allowed_after = r;
        int cnt = 0;
        // 判断能否在[l,r]中分配k个座位给j
        for (int i = j + 1; i < q; ++i) {
            // 遍历被j包含的那些区间
            if (xl[i] >= r) break;
            if (xr[i] <= r) {
                // 被j包含的区间一定要在j之前处理，不然这些区间一个座位也得不到
                // 换言之，j得不到它所包含的那些区间内的座位
                if (xl[i] <= st) {
                    st = max(st, xr[i]);
                } else {
                    cnt += xl[i] - st;
                    st = max(st, xr[i]);
                    if (cnt >= k) {
                        // j 已经获得k个座位。
                        // allowed_after 之后的那些座位，留给别的区间。
                        allowed_after = xl[i] - (cnt - k);
                        break;
                    }
                }
            }
        }
        if (cnt < k) {
            cnt += r - st;
            if (cnt < k) return 0;
            allowed_after = r - (cnt - k);
        }
        //排序在j之后，与j有交集但没被j包含的那些区间，
        //如果左端点在allowed_after之前，那么这个区间要放在j之后处理，
        //否则j获得座位就达不到k个。
        for (int i = j + 1; i < q; ++i) {
            if (xl[i] >= allowed_after) break;
            if (xr[i] > r) {
                //这一句的效果就相当于把i放在j之后处理
                mvl[i] = max(mvl[i], r);
            }
        }
    }
    return 1;
}
int main() {
    int tc;
    cin >> tc;
    for (int tt = 1; tt <= tc; ++tt) {
        cin >> n >> q;
        for (int j = 0; j < q; ++j) {
            // 区间采用左闭右开表示，座位改成从0开始编号
            cin >> xl[j] >> xr[j], --xl[j];
            sr[j] = {xl[j], -xr[j]};
        }
        //区间按左端点从小到大排序；左端点相同的，按右端点从大到小排序；
        //效果是若区间A包含区间B，则B排在A后面
        sort(sr, sr + q);
        for (int j = 0; j < q; ++j)
            xl[j] = sr[j].first, xr[j] = -sr[j].second;

        int bl = 0, br = n;
        for (int j = 0; j < q; ++j)
            br = min(br, xr[j] - xl[j]);
        ++br;
        while (bl < br - 1) {
            int bm = (bl + br) / 2;
            if (check(bm)) {
                bl = bm;
            } else {
                br = bm;
            }
        }
        cout << "Case #" << tt << ": " << bl << '\n';
    }
}

References

https://blog.csdn.net/Dylan_Frank/article/details/88985444

https://blog.csdn.net/lfhase/article/details/88823761