目录
Contest Info
| 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;
}
95
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
