bzoj 5249 [2018多省省队联测] IIIDX
Link
Solution
首先想到贪心，直接按照从大到小的顺序在后序遍历上一个个填
但是这样会有大问题，就是有相同的数的时候，会使答案不优
比如考虑 \((1, 2)(1, 3)(2, 4)\) 这样一棵树，并且点权是 \({1,1,1,2}\)
那么直接贪心会使得答案为 \(v_1=1,v_2=1,v_3=1,v_4=2\)，但是实际上最优解为 \(v_1=1,v_2=1,v_3=2,v_4=1\)
问题出在我们先考虑 \(v_2\) 的时候，直接填上了第三个 \(1\)，导致他的儿子 \(v_4\) 只有第四个数 \(2\) 一种填法，而事实上最优解里面 \(v_2\) 对应的是第二个 \(1\)
所以做出修改：将权值按照从大到小的顺序排的时候，直接贪心当前填的数为 \(v\) 时，我们选择最靠右的 \(v\) 填入，也就是填入最小的 \(v\)
那么怎么维护这个玩意呢？本来因为所有子树对应的区间都连续，只需要记录 \(l\) 和 \(r\) 即可，现在不连续了，我们只能对每个数记录下它左侧（大于等于它的数）有多少个被预定了，那么考虑当前点的时候这些预定的位置就不能填
所以具体操作如下：
- 使用线段树维护每个位置左侧还有几个数可以使用，区间的值为其左子区间和右子区间权值的 \(\min\)，记录 \(\text{nxt}\) 数组表示当前位置距离和他值相等且最靠右的位置的距离，如果当前这个位置就是最靠右的，那么它的 \(\text{nxt}\) 表示它左侧第一个未被选中的和它值相同的位置与它之间的距离
- 设当前点为 \(v\)，当前点的父亲为 \(u\)
- 假如 \(v\) 是 \(u\) 的第一个儿子，那么处理 \(u\) 的时候为 \(u\) 的子树预定的 \(size_u\) 个位置即将被使用了，我们需要把预定取消，也就是在 \(ans_u\) 及其右侧所有数的值加上 \(size_u - 1\)
- 在线段树上二分，找到第一个权值大于等于 \(size_v\) 的数，下面调整位置
- 根据上面的做法，我们需要把当前数对应上最右侧的未被选中的位置，我们用
ans += nxt[ans]将 \(\text{ans}\) 先放到它最右侧的位置上，再使用ans -= nxt[ans]，将 \(\text{ans}\) 放到当前的值中最靠右的未被选中的位置上，最后nxt[ans]++表示这个位置及其右侧所有和它相等的一段都已经被选了，所以下次再找到这个位置的时候只能走到下一段值上去- 预定它的子树，就是给 \(ans_v\) 及其右侧的所有数的值减去 \(size_v\)
Code
// Copyright lzt
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<iostream>
#include<queue>
#include<string>
#include<ctime>
using namespace std;
typedef long long ll;
typedef std::pair<int, int> pii;
typedef long double ld;
typedef unsigned long long ull;
typedef std::pair<long long, long long> pll;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define rep(i, j, k) for (register int i = (int)(j); i <= (int)(k); i++)
#define rrep(i, j, k) for (register int i = (int)(j); i >= (int)(k); i--)
#define Debug(...) fprintf(stderr, __VA_ARGS__)
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * f;
}
#define lc (i << 1)
#define rc (i << 1 | 1)
const double eps = 1e-8;
const int maxn = 500500;
struct Node {
int l, r, val, tag;
} tr[maxn << 2];
int n; double k;
int a[maxn], ans[maxn], fa[maxn], sz[maxn], nxt[maxn];
inline void build(int i, int l, int r) {
tr[i].l = l; tr[i].r = r;
if (l == r) {
tr[i].val = l; tr[i].tag = 0;
return;
}
int md = (l + r) >> 1;
build(lc, l, md); build(rc, md + 1, r);
tr[i].val = min(tr[lc].val, tr[rc].val);
}
inline void pushdown(int i) {
tr[lc].val += tr[i].tag;
tr[rc].val += tr[i].tag;
tr[lc].tag += tr[i].tag;
tr[rc].tag += tr[i].tag;
tr[i].tag = 0;
}
inline void add(int i, int p, int v) {
if (p <= tr[i].l) {
tr[i].tag += v; tr[i].val += v;
return;
}
pushdown(i);
add(rc, p, v);
if (tr[lc].r >= p) add(lc, p, v);
tr[i].val = min(tr[lc].val, tr[rc].val);
}
int ask(int i, int x) {
if (tr[i].l == tr[i].r) return tr[i].val >= x ? tr[i].l : tr[i].l + 1;
pushdown(i);
if (tr[rc].val >= x) return ask(lc, x);
else return ask(rc, x);
}
void work() {
scanf("%d %lf", &n, &k);
build(1, 1, n);
rep(i, 1, n) a[i] = read();
sort(a + 1, a + n + 1, greater<int>());
rrep(i, n - 1, 1) if (a[i] == a[i + 1]) nxt[i] = nxt[i + 1] + 1;
rrep(i, n, 1) {
fa[i] = (int)(i / k + eps);
sz[i]++; sz[fa[i]] += sz[i];
}
rep(i, 1, n) {
if (fa[i] && fa[i] != fa[i - 1]) add(1, ans[fa[i]], sz[fa[i]] - 1);
ans[i] = ask(1, sz[i]);
ans[i] += nxt[ans[i]]; ans[i] -= nxt[ans[i]];
nxt[ans[i]]++;
add(1, ans[i], -sz[i]);
}
rep(i, 1, n) printf("%d ", a[ans[i]]);
}
int main() {
#ifdef LZT
freopen("in", "r", stdin);
#endif
work();
#ifdef LZT
Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
}Review
贪心可以得到 \(60\) 分，正解比较难想到，JS考场上只有yzl过了这道题
关键在于发现贪心的错误在于没有选择最靠右的相同的数，就是条件被加紧了，我们需要放松条件
然后用线段树维护的过程比较自然，\(\text{nxt}\) 数组很精妙，完成了找到最靠右的未被选中的值得任务