[luoguP5290/十二省联考 2019] 春节十二响

题意

将一颗树划分为任意部分，要求每部分中都不存在祖先后代关系，求每部分的最大值的和的最小值

sol

首先考虑其链上的部分分：如果 \(1\) 是链的一端，那么直接输出和；如果 \(1\) 不是链的一端，那么可以在将其两个子树都压入堆中，每次贪心地取堆顶的最大值压入堆中，再压入点 \(1\)，最后求出堆中的和即可。
仔细考虑第二种情况，会发现每次贪心地取堆顶最大值的方法不止适用于链，只需要将两个子树转换为两个堆即可，因此可以向下递归并将所有子树合并为一个堆即可。
在合并时，将所有值都重新压入原堆中无法保证复杂度，可以使用启发式合并，全部合并完最大值后将原值替换掉，由于每次替换的复杂度均为 \(O(\log n)\)，因此总的时间复杂度为 \(O(n\log n)\)

代码

#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <vector>

using namespace std;

const int N = 200005;

int h[N], e[N], ne[N], idx;
int n, m[N];
vector<int> temp;
priority_queue<int> heap[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void merge(int x, int y){ 
    if (heap[x].size() < heap[y].size()) swap(heap[x], heap[y]);
    while (!heap[y].empty()) {
        temp.push_back(max(heap[x].top(), heap[y].top()));
        heap[x].pop(); heap[y].pop();
    }
    for (int p : temp) heap[x].push(p);
    temp.clear();
}

void dfs(int u){
    // printf("#%d\n", u);
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        dfs(j);
        // puts("aa");
        merge(u, j);
    }
    heap[u].push(m[u]);
}

int main(){
    memset(h, -1, sizeof h);
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &m[i]);
    for (int i = 2; i <= n; i ++ ) {
        int f;
        scanf("%d", &f);
        add(f, i);
    }
    dfs(1);
    long long ans = 0;
    while (!heap[1].empty()) ans += heap[1].top(), heap[1].pop();
    printf("%lld\n", ans);
}