Educational Codeforces Round 69

目录

• Contest Info
• Solutions
  • A. DIY Wooden Ladder
  • B. Pillars
  • C. Array Splitting
  • D. Yet Another Subarray Problem
  • E. Culture Code

Contest Info

---

[Practice Link](https://codeforc.es/contest/1197)

Solved	A	B	C	D	E	F
5/6	O	O	O	O	Ø	-

• O 在比赛中通过
• Ø 赛后通过
• ! 尝试了但是失败了
• - 没有尝试

Solutions

---

A. DIY Wooden Ladder

签到题。

#include <bits/stdc++.h>
using namespace std;

#define N 100010
int n, a[N];

int main() {
	int T; scanf("%d", &T);
	while (T--) {
		scanf("%d", &n);
		for (int i = 1; i <= n; ++i) scanf("%d", a + i);
		sort(a + 1, a + 1 + n);
		int res = 0;
		for (int i = 2; i < n; ++i) {
			res = max(res, min(a[i] - 1, i - 1));
		}
		printf("%d\n", res);
	}
	return 0;
}

B. Pillars

题意：

有\(n\)根柱子，每根柱子上有一个磁盘，一个磁盘能从第\(i\)根柱子移动到第\(j\)根柱子的前提是：

• 第\(j\)根柱子上没有磁盘
• 或者第\(i\)根柱子上的磁盘半径颜色小于第\(j\)根柱子的磁盘
  
  现在给出每根柱子上磁盘的半径，问能够存在一种方案使得将所有的磁盘都移动的一根柱子上

思路：

考虑假设能将所有磁盘移动到一根柱子上，那么最终肯定是移动到初始磁盘半径最大的那根柱子上。

那么考虑从这个柱子开始，每次往两边扩展，取大的贪心往这根柱子上移动。

如果不能移动就是不行。

因为考虑最后那根柱子上的磁盘半径肯定是递增的，所以不可能存在跨越移动的情况。

代码：

#include <bits/stdc++.h>
using namespace std;

#define N 200010
int n, a[N];

int main() {
	while (scanf("%d", &n) != EOF) {
		for (int i = 1; i <= n; ++i) scanf("%d", a + i);
		int pos = 1;
		for (int i = 2; i <= n; ++i) {
			if (a[i] > a[pos]) pos = i;
		}
		int l = pos - 1, r = pos + 1;
		bool F = 1;
		int lst = a[pos];
		while (l >= 1 || r <= n) {
			if (l < 1) {
				if (a[r] >= lst) {
					F = 0;
					break;
				}
				lst = a[r];
				++r;
			} else if (r > n) {
				if (a[l] >= lst) {
					F = 0;
					break;
				}
				lst = a[l];
				--l;
			} else {
				if (a[l] > a[r]) {
					if (a[l] >= lst) {
						F = 0;
						break;
					}
					lst = a[l];
					--l;
				} else {
					if (a[r] >= lst) {
						F = 0;
						break;
					}
					lst = a[r];
					++r;
				}
			}
		}
		puts(F ? "YES" : "NO");
	}
	return 0;
}

C. Array Splitting

题意：

有一个长度为\(n\)的序列\(a_i\)，要将序列分成\(k\)段，使得下式最小：

\[\begin{eqnarray*}
\sum\limits_{i = 1}^k (max(i) - min(i))
\end{eqnarray*}
\]

其中\(max(i)\)表示第\(i\)段中最大的数，\(min(i)\)表示第\(i\)段中最小的数，保证\(a_i\)是单调非降序的。

思路：

考虑\(a_i\)是单调非降的，那么\(max(i) - min(i)\)这个东西肯定是区间的末尾减去区间的开头，那么注意到区间的末尾的下一个数即为下一个区间的开头，变换式子有：

\[\begin{eqnarray*}
a_n - a_1 + \sum\limits_{i = 1}^{k - 1} a_{b_i} - a_{b_i + 1}
\end{eqnarray*}
\]

其中\(b_i\)表示第\(i\)段末尾的下标。

然后这个东西用堆维护一下，贪心取\(k - 1\)个即可。

代码：

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 300010
int n, k, a[N];

int main() {
	while (scanf("%d%d", &n, &k) != EOF) {
		for (int i = 1; i <= n; ++i) {
			scanf("%d", a + i);
		}
		ll res = a[n] - a[1];
		vector <int> vec;
		for (int i = 1; i < n; ++i) {
			vec.push_back(a[i] - a[i + 1]);
		}
		sort(vec.begin(), vec.end());
		for (int i = 0; i < k - 1; ++i) {
			res += vec[i];
		}
		printf("%lld\n", res);
	}
	return 0;
}

D. Yet Another Subarray Problem

题意：

有一个序列\(a_i\)，定义一个子区间的价值：

\[\begin{eqnarray*}
\sum\limits_{i = l}^r a_i - k \left\lceil \frac{r - l + 1}{m} \right\rceil
\end{eqnarray*}
\]

问所有子区间中最大的价值是多少?

思路：

维护一个前缀和\(S\)，那么变换式子有：

\[\begin{eqnarray*}
S_r - S_l - k \left\lceil \frac{r - l}{m} \right\rceil
\end{eqnarray*}
\]

我们希望将\(\left\lceil \frac{r - l}{m} \right\rceil\)拆开成\(\left\lceil \frac{r}{m} \right\rceil - \left\lceil \frac{l}{m} \right\rceil\)，但是这样是不行的。

注意到\(m\)很小，所以可以通过分类讨论一下将\(\left\lceil \frac{x}{m} \right\rceil\)按\(x \bmod m\)进行分类，然后讨论一下合并即可。

代码：

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 300010
int n, m, k;
ll a[N];
ll f[20]; 

int main() {
	while (scanf("%d%d%d", &n, &m, &k) != EOF) {
		for (int i = 1; i <= n; ++i) scanf("%lld", a + i);
		ll res = 0;
		for (int i = 0; i < m; ++i) f[i] = 0;
	    f[0] = -k;
		for (int i = 1; i <= n; ++i) {
			a[i] += a[i - 1];
			for (int j = 0; j < m; ++j) {
				if (m - i % m >= m - j) {
					res = max(res, a[i] - f[j] - 1ll * k * (i / m + 1));
				} else {
					res = max(res, a[i] - f[j] - 1ll * k * (i / m + 2));
				}
			}
			f[i % m] = min(f[i % m], a[i] - 1ll * k * (i / m + 1));
		}
		printf("%lld\n", res);
	}
	return 0;
}

E. Culture Code

题意：

有\(n\)个俄罗斯套娃，每个套娃有内径\(in_i\)和外径\(out_i， out_i > in_i\)，一个套娃\(i\)能套在套娃\(j\)里面，当且仅当\(out_i \leq in_j\)。

定义一组套在的额外空间为

\[\begin{eqnarray*}
in_1 + (in_2 - out_1) + (in_3 - out_3) + \cdots + (in_k - out_{k - 1})
\end{eqnarray*}
\]

其中\(in_k\)为最外成那个套娃的内径。

定义一组套娃是个极大套娃组：当且仅当不能再有另外一个套娃套在他们身上了。

询问有多少种极大套娃组的额外空间最小。

思路：

先将套娃分成两类：

• 第一类：没有另外一个套娃能套在它头上
• 第二类：至少存在一个套娃能够套在它头上

那么考虑把方案数全都算在第一类套娃头上。

那么先将所有套娃按内径从小到大排序，那么定义\(f[i]\)表示第\(i\)个套娃产生最小额外空间时的方案数，那么它能从第\(j\)个套娃转移过来当且仅当第\(out_j <= in_i\)。

那么再考虑变换额外空间的式子：

\[\begin{eqnarray*}
in_k + \sum\limits_{i = 1}^{k - 1} out_i - in_i
\end{eqnarray*}
\]

这样就变成了极大套娃组的额外空间中除了第一个套娃，其他套娃的贡献独立，为\(out_i - in_i\)。

那么转移的时候维护一下最小额外空间，如果最小额外空间相同就合并方案数，否则更新方案数。

代码：

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define INFLL 0x3f3f3f3f3f3f3f3f
#define N 400010
#define pii pair <ll, ll>
#define fi first
#define se second
const ll p = 1e9 + 7;
int n, tot;
pii a[N];
int b[N];
ll c[N], d[N];

struct SEG {
	struct node {
		ll Min, sum;
		node() {
			sum = 0;
			Min = INFLL;
		}
		node(ll Min, ll sum) : Min(Min), sum(sum) {}
	   	node operator + (const node &other) const {
			node res = node();
			if (Min == other.Min) {
				res.Min = Min;
				res.sum = (sum + other.sum) % p;
			} else if (Min < other.Min) {
				res.Min = Min;
				res.sum = sum;
			} else {
				res.Min = other.Min;
				res.sum = other.sum;
			}
			return res;
		}
	}t[N << 2], res;
	void build(int id, int l, int r) {
		t[id] = node();
		if (l == r) return;
		int mid = (l + r) >> 1;
		build(id << 1, l, mid);
		build(id << 1 | 1, mid + 1, r);
	}
	void update(int id, int l, int r, int pos, node x) {
		if (l == r) {
			t[id] = t[id] + x;
			return;
		}
		int mid = (l + r) >> 1;
		if (pos <= mid) update(id << 1, l, mid, pos, x);
		else update(id << 1 | 1, mid + 1, r, pos, x);
		t[id] = t[id << 1] + t[id << 1 | 1];
	}
	void query(int id, int l, int r, int ql, int qr) {
		if (l >= ql && r <= qr) {
			res = res + t[id];
			return;
		}
		int mid = (l + r) >> 1;
		if (ql <= mid) query(id << 1, l, mid, ql, qr);
		if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
	}
}seg;

int id(int x) {
	return lower_bound(b + 1, b + 1 + tot, x) - b;
}

int main() {
	while (scanf("%d", &n) != EOF) {
		tot = 0;
		for (int i = 1; i <= n; ++i) scanf("%lld%lld", &a[i].fi, &a[i].se);
		for (int i = 1; i <= n; ++i) {
			b[++tot] = a[i].fi;
			b[++tot] = a[i].se;
		}
		sort(b + 1, b + 1 + tot);
		tot = unique(b + 1, b + 1 + tot) - b - 1;
		sort(a + 1, a + 1 + n, [](pii x, pii y) {
			if (x.se != y.se) return x.se < y.se;
			return x.fi > y.fi;
		});
		ll Min = INFLL;
		ll res = 0;
		seg.build(1, 1, tot);
		for (int i = 1; i <= n; ++i) {
			seg.res = SEG::node();
			seg.query(1, 1, tot, 1, id(a[i].se));
			if (seg.res.Min == INFLL) {
				seg.res = SEG::node(-a[i].fi + a[i].se, 1);
				seg.update(1, 1, tot, id(a[i].fi), seg.res);
				c[i] = a[i].se;
				d[i] = 1;
			} else {
				c[i] = a[i].se + seg.res.Min;
				d[i] = seg.res.sum;
				seg.res.Min += -a[i].fi + a[i].se;
				seg.update(1, 1, tot, id(a[i].fi), seg.res);
			}
			if (a[i].fi > a[n].se) {
				Min = min(Min, c[i]);
			}
		}
		for (int i = 1; i <= n; ++i) {
			if (a[i].fi > a[n].se && c[i] == Min) {
				res = (res + d[i]) % p;
			}
		}
		printf("%lld\n", res);
	}
	return 0;
}