BZOJ2870 最长道路tree

ZKY："如果把分治过程记录下来就可以做到动态修改询问,不过好像没人给这种数据结构起名字(或者我太弱了不知道)……我就给它起名叫点分树了……"

结果什么是"点分树"蒟蒻还是没有搞懂= =Orz

这题就是先点分治，然后暴力求出子树里面所有的链。但是合并两个子树的链。。。有点，不太科学

于是做法是把子树分成两部分，穿过这两个部分的所有链的答案，然后递归这两部分子树。

恩很好。。。于是敲了起来，最后竟然调了2h，错因是。。。

树的重心求错了

我还是滚回PJ组玩泥巴算了。。。

/**************************************************************
    Problem: 2870
    User: rausen
    Language: C++
    Result: Accepted
    Time:1032 ms
    Memory:6596 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
 
using namespace std;
typedef long long ll;
const int N = 50005;
 
struct edge {
    int next, to;
    edge() {}
    edge(int _n, int _t) : next(_n), to(_t) {}
} e[N << 1];
int first[N], tot;
 
struct data {
    int l, v;
    data() {}
    data(int _l, int _v) : l(_l), v(_v) {}
     
    inline bool operator < (const data &x) const {
        return l < x.l;
    }
} t1[N], t2[N];
int cnt_t1, cnt_t2;
 
struct tree_node {
    int sz, w, vis;
} tr[N];
 
ll ans;
int n, now;
int q1[N], q2[N], top1, top2;
 
inline int read() {
    int x = 0;
    char ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}
 
inline void Add_Edges(int x, int y) {
    e[++tot] = edge(first[x], y), first[x] = tot;
    e[++tot] = edge(first[y], x), first[y] = tot;
}
 
int Maxsz, Root;
 
void dfs(int p, int fa, int sz) {
    int x, y, maxsz = 0;
    tr[p].sz = 1;
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != fa && !tr[y].vis) {
            dfs(y, p, sz);
            tr[p].sz += tr[y].sz;
            maxsz = max(maxsz, tr[y].sz);
        }
    maxsz = max(maxsz, sz - tr[p].sz);
    if (maxsz < Maxsz)
        Root = p, Maxsz = maxsz;
}
 
int find_root(int p, int sz) {
    Maxsz = N << 1;
    dfs(p, 0, sz);
    return Root;
}
 
void count_sz(int p, int fa) {
    int x, y;
    tr[p].sz = 1;
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != fa && !tr[y].vis) {
            count_sz(y, p);
            tr[p].sz += tr[y].sz;
        }
}
 
void count1(int p, int fa, int len, int v) {
    int x, y;
    t1[++cnt_t1] = data(len, v);
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != fa && !tr[y].vis)
            count1(y, p, len + 1, min(v, tr[y].w));
}
 
void count2(int p, int fa, int len, int v) {
    int x, y;
    t2[++cnt_t2] = data(len, v);
    for (x = first[p]; x; x = e[x].next)
        if ((y = e[x].to) != fa && !tr[y].vis)
            count2(y, p, len + 1, min(v, tr[y].w));
}
 
void count(int p, int first_p) {
    int x, y;
    t1[++cnt_t1] = data(1, tr[p].w);
    for (x = first[p]; x != first_p; x = e[x].next)
        if (!tr[y = e[x].to].vis)
            count1(y, p, 2, min(tr[p].w, tr[y].w));
    t2[++cnt_t2] = data(1, tr[p].w);
    for (x = first_p; x; x = e[x].next)
        if (!tr[y = e[x].to].vis)
            count2(y, p, 2, min(tr[p].w, tr[y].w));
}
 
void work(int p, int cnt_p) {
    int root = find_root(p, cnt_p), sz1 = 0, sz2 = 0, tmp;
    int x, y, first_root, i, l1, l2;
    count_sz(root, 0);
    for (x = first[root]; x; x = e[x].next)
        if (!tr[y = e[x].to].vis) {
            sz1 += tr[y].sz;
            if (sz1 + 1 << 1 >= tr[root].sz) {
                first_root = e[x].next;
                sz2 = tr[root].sz - (sz1++);
                break;
            }
        }
    cnt_t1 = cnt_t2 = 0;
    count(root, first_root);
     
    sort(t1 + 1, t1 + cnt_t1 + 1), sort(t2 + 1, t2 + cnt_t2 + 1);
    for (i = 1, top1 = 0; i <= cnt_t1; ++i) {
        while (top1 && t1[i].v > t1[q1[top1]].v) --top1;
        q1[++top1] = i;
    }
    for (i = 1, top2 = 0; i <= cnt_t2; ++i) {
        while (top2 && t2[i].v > t2[q2[top2]].v) --top2;
        q2[++top2] = i;
    }
     
    for (l1 = 1, l2 = 0; l1 <= top1; ++l1) {
        while (l2 < top2 && t2[q2[l2 + 1]].v >= t1[q1[l1]].v) ++l2;
        ans = max(ans, (ll) (t1[q1[l1]].l + t2[q2[l2]].l - 1) * t1[q1[l1]].v);
    }
    for (l1 = 0, l2 = 1; l2 <= top2; ++l2) {
        while (l1 < top1 && t1[q1[l1 + 1]].v >= t2[q2[l2]].v) ++l1;
        ans = max(ans, (ll) (t1[q1[l1]].l + t2[q2[l2]].l - 1) * t2[q2[l2]].v);
    }
     
    tmp = ++now;
    if (sz2 - 1 >= 2) {
        for (x = first[root]; x != first_root; x = e[x].next)
            if (!tr[y = e[x].to].vis)
                tr[y].vis = now;
        work(root, sz2);
        for (x = first[root]; x != first_root; x = e[x].next)
            if (tr[y = e[x].to].vis == tmp)
                tr[y].vis = 0;
    }
    tmp = ++now;
    if (sz1 - 1 >= 2) {
        for (x = first_root; x; x = e[x].next)
            if (!tr[y = e[x].to].vis)
                tr[y].vis = now;
        work(root, sz1);
        for (x = first_root; x; x = e[x].next)
            if (tr[y = e[x].to].vis == tmp)
                tr[y].vis = 0;
    }
}
 
int main() {
    int i;
    n = read();
    for (i = 1; i <= n; ++i)
        tr[i].w = read();
    for (i = 1; i < n; ++i)
        Add_Edges(read(), read());
    work(1, n);
    printf("%lld
", ans);
    return 0;
}