ZOJ3649 Social Net

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3649

---

这题倍增维护信息之多，也能算是一道毒瘤题了……

解题思路

这题分为两个部分，第一个是最大生成树，第二个是若干个询问，问在生成树上 x−>y x − > y 的路径上最大的 ck−cj(ck>=cj,j<=k) c k − c j ( c k >= c j , j <= k ) 。
第一个部分我想就不用多讲，直接跑最小生成树（只是把最小换成了最大）。
第二个部分，重点在于 (ck>=cj,j<=k) ( c k >= c j , j <= k ) 这个限制。由于题目特性，看起来是逃不过倍增的了。首先，我们自然地将 x−>y x − > y 分成了 x−>lca(x,y)−>y x − > l c a ( x , y ) − > y 。通过这个分段，我们观察我们倍增时需要维护那些东西。仔细分析发现一共有如下几样：

• d[x][i].d d [ x ] [ i ] . d ：维护 x x 的第 2i 2 i 个祖先
• d[x][i].maxnum d [ x ] [ i ] . m a x n u m ：维护从 x x 到　 x x 的第 2i 2 i 个祖先中的最大值
• d[x][i].minnum d [ x ] [ i ] . m i n n u m ：维护从 x x 到　 x x 的第 2i 2 i 个祖先中的最小值
• d[x][i].max_up d [ x ] [ i ] . m a x _ u p ：维护从 x x 到　 x x 的第 2i 2 i 个祖先中的最大差值（由下至上)
• d[x][i].max_dn d [ x ] [ i ] . m a x _ d n ：维护从 x x 到　 x x 的第 2i 2 i 个祖先中的最大差值（由上至下)

对于后两条的解释：从公式中可以看出，相减具有方向性，而且 x−>lca(x,y) x − > l c a ( x , y ) 与 lca(x,y)−>y l c a ( x , y ) − > y 方向不同。
另行说明：本文 d[x][i] d [ x ] [ i ] 所含信息不包括 x x （这样可以很方便地分成两个不相交的区间）（或许可以不这么做qwq）

然后我们考虑如何维护这五个值。前三个没有什么大问题，后两个要注意整合时要考虑三个值，千万不要漏了两个区间并中的值（最大值与最小值相减）。以下给出维护这五个值的递推式:

• d[x][i].d=d[d[x][i−1].d][i−1].d d [ x ] [ i ] . d = d [ d [ x ] [ i − 1 ] . d ] [ i − 1 ] . d
• d[x][i].maxnum=max(d[x][i−1].maxnum,d[d[x][i−1].d][i−1].maxnum) d [ x ] [ i ] . m a x n u m = m a x ( d [ x ] [ i − 1 ] . m a x n u m , d [ d [ x ] [ i − 1 ] . d ] [ i − 1 ] . m a x n u m )
• d[x][i].minnum=min(d[x][i−1].minnum,d[d[x][i−1].d][i−1].minnum) d [ x ] [ i ] . m i n n u m = m i n ( d [ x ] [ i − 1 ] . m i n n u m , d [ d [ x ] [ i − 1 ] . d ] [ i − 1 ] . m i n n u m )
• d[x][i].max_up=max(d[x][i−1].max_up,d[d[x][i−1].d][i−1].max_up,d[d[pos][i−1].d][i−1].maxnum−d[pos][i−1].minnum) d [ x ] [ i ] . m a x _ u p = m a x ( d [ x ] [ i − 1 ] . m a x _ u p , d [ d [ x ] [ i − 1 ] . d ] [ i − 1 ] . m a x _ u p , d [ d [ p o s ] [ i − 1 ] . d ] [ i − 1 ] . m a x n u m − d [ p o s ] [ i − 1 ] . m i n n u m )
• d[pos][i].max_up=max(d[pos][i−1].max_up,d[d[pos][i−1].d][i−1].max_up,d[pos][i−1].maxnum−d[d[pos][i−1].d][i−1].minnum) d [ p o s ] [ i ] . m a x _ u p = m a x ( d [ p o s ] [ i − 1 ] . m a x _ u p , d [ d [ p o s ] [ i − 1 ] . d ] [ i − 1 ] . m a x _ u p , d [ p o s ] [ i − 1 ] . m a x n u m − d [ d [ p o s ] [ i − 1 ] . d ] [ i − 1 ] . m i n n u m )

我们可以以类似的方法合并 x−>lca(x,y) x − > l c a ( x , y ) 和 lca(x,y)−>y l c a ( x , y ) − > y 两段区间，得到最后的答案。

---

参考程序

tip：程序中 x−>lca(x,y)−>y x − > l c a ( x , y ) − > y 是以 y−>lca(x,y)−>x y − > l c a ( x , y ) − > x 的顺序做的。

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 30010, MAXM = 50010;
const int INF = 1000000000;
int n, m, b[MAXN];
struct Edge {
    int x, y, z;
    Edge(int x_ = 0, int y_ = 0, int z_ = 0) { x = x_; y = y_; z = z_; return; }
};
Edge edge[MAXM];
int x, y, z;
bool cmp(Edge x, Edge y) {
    return x.z > y.z;
}
int father[MAXN];
int lp, f[MAXN], lin[MAXN << 1], nxt[MAXN << 1];
inline void add(int x, int y) { lin[++lp] = y; nxt[lp] = f[x]; f[x] = lp; return; }
int ans;
int get_father(int x) {
    if(father[x] == x) return x;
    father[x] = get_father(father[x]);
    return father[x];
}
int q;

struct Node {
    int d, maxnum, minnum, max_dn, max_up;
};
Node d[MAXN][16];
int deep[MAXN];
void build_tree(int pos, int fa) {//建树，同事处理完成倍增相关的信息
    deep[pos] = deep[fa] + 1;
    d[pos][0].d = fa;
    d[pos][0].maxnum = b[fa];
    d[pos][0].minnum = b[fa];
    d[pos][0].max_dn = -INF;
    d[pos][0].max_up = -INF;
    for(int i = 1; i < 16; i++) {
        d[pos][i].d = d[d[pos][i - 1].d][i - 1].d;
        d[pos][i].maxnum = max(d[pos][i - 1].maxnum, d[d[pos][i - 1].d][i - 1].maxnum);
        d[pos][i].minnum = min(d[pos][i - 1].minnum, d[d[pos][i - 1].d][i - 1].minnum);
        d[pos][i].max_dn = max(d[pos][i - 1].max_dn, d[d[pos][i - 1].d][i - 1].max_dn);
        d[pos][i].max_dn = max(d[pos][i].max_dn, d[d[pos][i - 1].d][i - 1].maxnum - d[pos][i - 1].minnum);
        d[pos][i].max_up = max(d[pos][i - 1].max_up, d[d[pos][i - 1].d][i - 1].max_up);
        d[pos][i].max_up = max(d[pos][i].max_up, d[pos][i - 1].maxnum - d[d[pos][i - 1].d][i - 1].minnum);
    }
    for(int t = f[pos]; t; t = nxt[t]) {
        if(lin[t] == fa) continue;
        build_tree(lin[t], pos);
    }
    return;
}
int get_lca(int x, int y) {//求最近公共祖先
    if(deep[x] < deep[y]) swap(x, y);
    for(int i = 15; i >= 0; i--)
        if(deep[d[x][i].d] >= deep[y]) x = d[x][i].d;
    if(x == y) return x;
    for(int i = 15; i >= 0; i--)
        if(d[x][i].d != d[y][i].d) x = d[x][i].d, y = d[y][i].d;
    return d[x][0].d;
}
int recmin, recmax;
void go_up(int x, int y){//y->lca(x, y)
    if(x == y) return;//由于倍增中设定是不包含ｘ的
    recmax = max(recmax, b[x]);
    for(int i = 15; i >= 0; i--) {
        if(deep[d[x][i].d] <= deep[y]) continue;
        ans = max(ans, recmax - d[x][i].minnum);
        recmax = max(recmax, d[x][i].maxnum);
        ans = max(ans, d[x][i].max_up);
        x = d[x][i].d;
    }
    return;
}
void go_down(int x, int y){//lca(x, y)->x
    recmin = min(recmin, b[x]);
    for(int i = 15; i >= 0; i--) {
        if(deep[d[x][i].d] < deep[y]) continue;
        ans = max(ans, d[x][i].maxnum - recmin);
        recmin = min(recmin, d[x][i].minnum);
        ans = max(ans, d[x][i].max_dn);
        x = d[x][i].d;
    }
    return;
}
int main() {
    while(scanf("%d", &n) == 1) {//多组数据
        memset(b, 0, sizeof(b));
        lp = 0;
        memset(f, 0, sizeof(f)); memset(lin, 0, sizeof(lin)); memset(nxt, 0, sizeof(nxt));
        memset(edge, 0, sizeof(edge));
        memset(deep, 0, sizeof(deep));
        memset(d, 0, sizeof(d));//初始化

        for(int i = 1; i <= n; i++) father[i] = i;
        for(int i = 1; i <= n; i++) scanf("%d", &b[i]);
        scanf("%d", &m);
        for(int i = 1; i <= m; i++) {
            scanf("%d%d%d", &x, &y, &z);
            edge[i] = Edge(x, y, z);
        }
        sort(edge + 1, edge + m + 1, cmp);
        z = 1;
        ans = 0;
        for(int i = 1; i < n; i++) {
            x = get_father(edge[z].x);
            y = get_father(edge[z].y);
            while(x == y) {
                x = get_father(edge[++z].x);
                y = get_father(edge[z].y);
            }
            ans += edge[z].z;
            father[y] = x;
            add(edge[z].x, edge[z].y);
            add(edge[z].y, edge[z].x);//加入树边
            z++;
        }
        printf("%d\n", ans);//最大生成树（库鲁斯卡尔）

        build_tree(1, 1);//建树，同事处理完成倍增相关的信息
        scanf("%d", &q);
        for(int i = 1; i <= q; i++) {
            scanf("%d%d", &x, &y);
            int lca = get_lca(x, y);//求最近公共祖先
            ans = 0; recmin = INF; recmax = -INF;
            go_up(y, lca);//y->lca(x, y)
            go_down(x, lca);//lca(x, y)->x
            ans = max(ans, recmax - recmin);//合并答案
            printf("%d\n", ans);
        }
    }
    return 0;
}