230602 做题记录 // 儿童节快乐

一共有七块钱，花了两块买了一个我叶的吧唧。

为什么只买一个呢？因为剩下的几个长得还没我自己画的好看，，，

还有两块钱买了一个灯，剩下三块钱加入崩门，还有一块钱充公了。

你说，2 + 2 + 3 + 1 不是等于 8 吗？你猜 ~

---

A. Strange Way to Express Integers

http://222.180.160.110:1024/contest/3656/problem/1

Click me XD

---

B. 滑动窗口

http://222.180.160.110:1024/contest/3656/problem/2

字面意思。。。

namespace XSC062 {
using namespace fastIO;
const int maxn = 1e6 + 5;
int n, k, h, t;
int a[maxn], q[maxn];
int main() {
	read(n), read(k);
	h = 1, t = 0;
	for (int i = 1; i <= n; ++i) {
		read(a[i]);
		if (h <= t && i - q[h] >= k)
			++h;
		while (h <= t && a[i] <= a[q[t]])
			--t;
		q[++t] = i;
		if (i >= k)
			print(a[q[h]], ' ');
	}
	putchar('\n');
	h = 1, t = 0;
	for (int i = 1; i <= n; ++i) {
		if (h <= t && i - q[h] >= k)
			++h;
		while (h <= t && a[i] >= a[q[t]])
			--t;
		q[++t] = i;
		if (i >= k)
			print(a[q[h]], ' ');
	}
	return 0;
}
} // namespace XSC062

---

C. 工作安排

http://222.180.160.110:1024/contest/3656/problem/3

妙妙贪心题，想了好久好久。

不难发现被选中的 $i$ 需要满足 $b_i \le S_a - a_i$。

然后下意识变形，得到 $a_i + b_i \le S_a$。

不难想到尝试枚举可能的 $S_a$ 的值，并判断是否存在 $k$ 个 $i$，使得 $\sum a_i = S_a$，且对于 $\forall \, i$，有 $a_i + b_i \le S_a$。

那光是枚举就会起飞，更何况还存在一个目测只能暴搜判定的 check。

这里有两个分化点：

1. 若 $\sum a_i \ge S_a$，且 $a_i + b_i \le S_a$，那么明显有 $a_i + b_i \le S_a$。

   这代表着什么呢？$S_a$ 对 $a_i$ 的要求从 $\sum a_i = S_a$ 下降为了 $\sum a_i \ge S_a$。

   那么 check 就会好判定很多了。

   题外话：智力没悟到这个 trick 哈哈哈，我给他讲了半天他都是懵的，后来幡然醒悟气得差点从七楼跳下去哈哈哈

2. 这个点有点抽象。不妨这么想：假设平面上有若干个起点相同的区间，区间 $i$ 的范围为 $[0, a_i + b_i]$，赋予其权值为 $a_i$。将这些区间按照长度从小到大排序。

   

   那么待求就可以转化为，在数轴上寻找一个 $S_a$，满足存在 $k$ 个右端点在 $S_a$ 左边的区间，其权值和大于等于 $S_a$。

   一个很关键的 trick 就是，$S_a$ 一定会落在某个区间的右端点，即上图中的灰色分割线处。

   为什么呢？对于 $a_i + b_i$ 和 $a_{i + 1} + b_{i + 1}$ 中间的部分，即任意两根相邻分割线中间的空白部分，$S_a$ 落在上面是没有意义的。从 区间 $i$ 的右端点开始，一直到 区间 $i + 1$ 的右端点之前，右端点在 $S_a$ 前面的区间都只有前 $i$ 个，而当 $S_a$ 越小时，$\sum a_i \ge S_a$ 越容易满足，所以就选择可行范围内最小的 $a_i + b_i$。

那么思路就出来了。我们把给定的区间按 $a_i + b_i$ 从小到大排序，对于每一个 $i$，我们判定一下 $\sum _{j = 1}^i a_j$ 是否大于等于 $a_i + b_i$。

如果是，那么就会存在一组可行解，满足 $k = i$。因为 $i$ 越往后越大，我们只求最小的 $k$，所以输出第一个可行的 $i$ 即可…… 真的是这样吗？

在前 $i$ 个区间中，如果我们去除一个权值最小的区间，$\sum a \ge a_i + b_i$ 仍有可能成立，去除了第二小、第三小…… 也都有可能。

所以我们用一个小根堆存储所有权值，只要 $\sum a\ge a_i + b_i$，我们就不断弹出队头。

还没完。因为现在 $k$ 不一定等于 $i$ 了，所以得到的第一个可行解不一定就是最优解。所以我们要把所有 $a_i + b_i$ 作为 $S_a$ 的情况都过一遍。

那就又迎来了一个问题，假如我们在 $i=i_1$ 时从优先队列中弹出了一些元素，但在 $i=i_2 \ge i_1$ 时不想弹出这些元素，怎么办呢？

也就是说，对于 $p\le i_1, i_1\le q\le i_2$，存在 $a_p \ge a_q$，且 $a_p$ 已被弹出。下证这种情况不可能成为最优解。

对于 $i = i_1$，假设答案为 $k_1$，那么这 $k_1$ 个区间权值一定都大于等于 $a_p$。既然要恢复 $a_p$，那么不可能抛弃权值更大的原先 $k_1$ 个区间。即使抛弃了在 $i_1$ 之后的所有区间，答案也是会比 $k_1$ 大的。

题外话：这个 trick 我在 A 了过后写博客的时候才发现……

时间复杂度 $\mathcal O(n \log n)$，其中 $\log$ 是排序。

#define int long long
namespace XSC062 {
using namespace fastIO;
const int inf = 1e18;
const int maxn = 5e5 + 5;
struct _ { int a, b; };
_ a[maxn];
int n, s, cnt, res = inf;
std::priority_queue<int, std::vector<int>,
                            std::greater<int> > q;
inline int min(int x, int y) {
	return x < y ? x : y;
}
int main() {
    read(n);
    for (int i = 1; i <= n; ++i) {
        read(a[i].a), read(a[i].b);
        a[i].b += a[i].a;
	}
    std::sort(a + 1, a + n + 1,
        [&](_ x, _ y) { return x.b < y.b; } );
    for (int i = 1; i <= n; ++i) {
        s += a[i].a;
        q.push(a[i].a);
        if (s >= a[i].b) {
            while (q.size() && s - q.top() >= a[i].b)
                s -= q.top(), q.pop(), ++cnt;
            res = min(res, i - cnt);
        }
    }
    if (res == inf)
    	puts("-1");
    else print(res);
    return 0;
}
} // namespace XSC062
#undef int