【堆的启发式合并】【P5290】[十二省联考2019]春节十二响

Description

给定一棵 $n$ 个节点的树，点有点权，将树的节点划分成多个集合，满足集合的并集是树的点集，最小化每个集合最大点权之和。

Limitation

$1~\leq~n~\leq~2~\times~10^5,~1~\leq~M~\leq~10^9$

其中 $M$ 表示树的最大点权。

Subtasks:

对于前 $45\%$ 的数据， $n~\leq~16$

另有 $15\%$ 的数据，保证树的形态是一条链，但是 $1$ 号节点不一定是根节点

另有 $15\%$ 的数据，$n~\leq~2000$

另有 $25\%$ 的数据无特殊限制。

Solution

联考里唯一会做的送温暖题。

考虑前 $45\%$ 可以直接状压

考虑一条链的数据，显然根节点的同一方向的后代不能放到集合中，于是显然需要将两个方向的后代合并。考虑其中一条链的最大权值的点显然应该选择另一侧最大的合并。证明上可以考虑调整法，如果选择另一个点的话对答案的贡献不会更优。

于是将两条链分别排序，最后加上根节点的贡献即可。

考虑将这个结论推广到一般树上也是成立的。证明：对拍了半小时没有挂

那么考虑 $n~\leq~2000$ 的点，先按照点权排序，然后枚举没有被选进集合的点，暴力在树上将子树和到根节点的链都打上时间戳，然后向后枚举所有的点，如果一个点没有被选择且没有被打上当前时间戳，则将其选入集合，同时暴力染色，打上相同的时间戳。

考虑这样做的时间复杂度：枚举每个点和集合中的其他点是 $O(n^2)$ 的，对于每个点，会在树上 $O(n)$ 暴力染色一次，查询是否染色是 $O(1)$ 的，由于上述两个操作的次数多都是 $O(n)$ 的，于是染色和查询的总复杂度是 $O(n^2)$ 的，加上枚举的复杂度，总复杂度 $O(n^2)$。

考虑剩下的部分，发现选出的集合个数显然是 $O(maxdepth)$ 的，同时每个集合中非最大权值是无需维护的，合并两个子树可以使用同样的方法贪心。于是对每一棵子树开一个 std::priority_queue，维护该子树内选择的每个集合的最大值。考虑到发现每个对树进行长链剖分，将非长链的元素合并到长链上，由于每合并一次会有一个数被删掉，会删 $O(n)$ 个数，于是总复杂度 $O(n \log n)$。

注意长链剖分在向上合并长链信息的时候只能交换两个节点的头指针，如果暴力枚举子节点的元素插入父节点的话复杂度是不对的，例如：考虑一条链的情况，会被卡到 $O(n^2)$。

Code

#include <cstdio>
#include <queue>
#include <vector>
#ifdef ONLINE_JUDGE
#define freopen(a, b, c)
#endif
typedef long long int ll;
namespace IPT {
  const int L = 1000000;
  char buf[L], *front=buf, *end=buf;
  char GetChar() {
    if (front == end) {
      end = buf + fread(front = buf, 1, L, stdin);
      if (front == end) return -1;
    }
    return *(front++);
  }
}
template <typename T>
inline void qr(T &x) {
  char ch = IPT::GetChar(), lst = ' ';
  while ((ch > '9') || (ch < '0')) lst = ch, ch=IPT::GetChar();
  while ((ch >= '0') && (ch <= '9')) x = (x << 1) + (x << 3) + (ch ^ 48), ch = IPT::GetChar();
  if (lst == '-') x = -x;
}
namespace OPT {
  char buf[120];
}
template <typename T>
inline void qw(T x, const char aft, const bool pt) {
  if (x < 0) {x = -x, putchar('-');}
  int top = 0;
  do {OPT::buf[++top] = static_cast<char>(x % 10 + '0');} while (x /= 10);
  while (top) putchar(OPT::buf[top--]);
  if (pt) putchar(aft);
}
const int maxn = 200005;
int n;
ll ans;
int fa[maxn], MU[maxn];
std::vector<int>son[maxn];
std::priority_queue<int>Q[maxn];
void dfs(const int u);
void merge(std::priority_queue<int> &u, std::priority_queue<int> &v);
int main() {
  freopen("1.in", "r", stdin);
  qr(n);
  for (int i = 1; i <= n; ++i) qr(MU[i]);
  for (int i = 2; i <= n; ++i) {
    qr(fa[i]);
    son[fa[i]].push_back(i);
  }
  dfs(1);
  while (!Q[1].empty()) {
    ans += Q[1].top(); Q[1].pop();
  }
  qw(ans, '\n', true);
  return 0;
}
void dfs(const int u) {
  int wson = 0;
  for (auto v : son[u]) {
    dfs(v);
    if (Q[wson].size() < Q[v].size()) wson = v;
  }
  for (auto v : son[u]) if (v != wson) {
    merge(Q[wson], Q[v]);
  }
  Q[u].swap(Q[wson]);
  Q[u].push(MU[u]);
}
void merge(std::priority_queue<int> &u, std::priority_queue<int> &v) {
  static int tmp[maxn];
  int cnt = 0;
  while (!v.empty()) {
    tmp[++cnt] = std::max(u.top(), v.top());
    u.pop(); v.pop();
  }
  while (cnt) u.push(tmp[cnt--]);
}

Summary