SGU 507 Treediff（平衡树）

题目链接：点击打开链接

思路：我们要求叶子结点的值相差最小， 那么这是一个大小关系， 我们可以维护一棵平衡树， 这样， 对于每一个数， 和他相差最小的情况只能是他相邻左边或右边。

但是如果开n棵平衡树， 复杂度高达n^2logn，还不如n^2暴力来的快。  我们可以采用一种叫做： 启发式合并  的技巧。 每次将一棵比较小的树合并到一棵比较大的树上。 使得复杂度达到nlogn， 证明也很简单：考虑每一个叶子结点， 因为它每次插入某棵平衡树， 它所处的树中节点数都至少是原来的2倍， 所以最多被插入logn次。 这样总的复杂度将是    n(logn)^2

细节参见代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <bitset>
#include <cstdlib>
#include <cmath>
#include <set>
#include <list>
#include <deque>
#include <map>
#include <queue>
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
using namespace std;
typedef long long ll;
typedef long double ld;
const ld eps = 1e-9, PI = 3.1415926535897932384626433832795;
const int mod = 1000000000 + 7;
const ll INF = (1LL<<31)-1;
const int seed = 131;
const ll INF64 = ll(1e18);
const int maxn = 5e4 + 10;
int T,n,m,a[maxn];
struct node {
    node *ch[2];
    int r, v, s, maxv, minv, res;
    node(int v=0):v(v) {
        r = rand();
        maxv = minv = v;
        res = INF;
        ch[0] = ch[1] = NULL;
        s = 1;
    }
    int cmp(int x) const {
        if(x == v) return -1;
        return x < v ? 0 : 1;
    }
    void maintain() {
        s = 1;
        minv = maxv = v;
        if(ch[0] != NULL) {
            s += ch[0]->s;
            minv = min(minv, ch[0]->minv);
            maxv = max(maxv,ch[0]->maxv);
            res = min(res, v-ch[0]->maxv);
            res = min(res, ch[0]->res);
        }
        if(ch[1] != NULL) {
            s += ch[1]->s;
            maxv = max(maxv, ch[1]->maxv);
            minv = min(minv,ch[1]->minv);
            res = min(res, ch[1]->minv-v);
            res = min(res, ch[1]->res);
        }
    }
} *g[maxn];
void rotate(node* &o, int d) {
    node* k = o->ch[d^1];  //旋转， 使得优先级满足堆的意义
    o->ch[d^1] = k->ch[d];
    k->ch[d] = o;
    o->maintain();
    k->maintain();
    o = k;
}
void insert(node* &o, int x) {
    if(o == NULL) o = new node(x);
    else {
        int d = (x < o->v ? 0 : 1);
        insert(o->ch[d], x);
        if(o->ch[d]->r > o->r) rotate(o, d^1);
    }
    o->maintain();
}
vector<int> gg[maxn];
int val[maxn], ID[maxn], cnt[maxn], ans[maxn];
multiset<int> G[maxn];
multiset<int> :: iterator it;
void dfs(int u) {
    int len = gg[u].size();
    for(int i = 0; i < len; i++) {
        int v = gg[u][i];
        if(v >= n-m+1 && v <= n) ;
        else dfs(v);
    }
    for(int i = 0; i < len; i++) {
        int v = gg[u][i];
        if(v >= n-m+1 && v <= n) {
            insert(g[ID[u]], val[v]);
            G[ID[u]].insert(val[v]);
            cnt[ID[u]] += cnt[ID[v]];
        }
        else {
            int id1 = ID[u];
            int id2 = ID[v];
            if(cnt[id1] >= cnt[id2]) {
                for(it = G[id2].begin(); it != G[id2].end(); it++) {
                    G[id1].insert(*it);
                    insert(g[id1], *it);
                }
                cnt[id1] += cnt[id2];
            }
            else {
                ID[u] = ID[v];
                cnt[id2] += cnt[id1];
                for(it = G[id1].begin(); it != G[id1].end(); it++) {
                    G[id2].insert(*it);
                    insert(g[id2], *it);
                }
            }
        }
    }
    ans[u] = g[ID[u]]->res;
}
void init() {
    for(int i = 1; i <= n; i++) {
        ID[i] = i;
        cnt[i] = 0;
    }
}
int fa;
int main() {
    scanf("%d%d",&n,&m);
    init();
    for(int i = 2; i <= n; i++) {
        scanf("%d", &fa);
        gg[fa].push_back(i);
    }
    for(int i = n-m+1; i <= n; i++) {
        scanf("%d", &val[i]);
        cnt[i] = 1;
    }
    dfs(1);
    for(int i = 1; i <= n-m; i++) {
        printf("%d%c", ans[i], i == n-m ? '\n' : ' ');
    }
    return 0;
}