计蒜客 444 / xtuoj 1024 京东的物流路径（并查集+离线lca）或者 （点分治）

题意：
一颗树，定义一条路径的权值等于路径的边权之和，需要求这颗树所有路径中权值的最大值

思路：

考虑到路径权值与点权的最值有关，而最值的问题通常可以通过排序就行处理，于是想到先把点权排序。

容易看出如果某条路径的权值是通过某个点算出的最小 ，那么肯定这条路径肯定不会经过权值更小的点，于是有了两种处理思路

1.按点权从小到大删点，对于即将删除的点，比他权值小的点已经被删去了，所以只要在当前状态的森林里找一条最长路径乘以次点权就可以更新答案

2.按点权从大到小加点，显然新加进来的点权值最小，当前树里的任何路径的点权最小值都不会小于新加进来的点，所以可以通过维护直径来更新答案

对于思路1，如果是一条链的话，对于一个将要删除的点，可以直接二分得到当前点附近已经被删除的点并更新答案，然而在树里面就不太好从处理了，至少我肯定是不会的

于是考虑思路2：

加点建树很明显可以通过并查集维护

但是在树的合并过程中怎么维护直径呢？这里需要用到一个定理。。一颗树的直径的两个端点一定是他子树直径的端点

于是就可以进行直径的维护了，具体求距离可以选择logn的lca

代码：

#include <bits/stdc++.h>
using namespace std;
long long f[200010];
// 节点编号[1,n]
// 最大节点数
#define MAXN 200010
// 满足2^M > MAXN
#define M 20
struct node
{
    long long to,val;
};
struct tree
{
    long long r,x,y;
    void clear()
    {
        r=0;
        x=y=-1;
    }
}t[100010];
vector<node>g[200010];
long long d[200010];
long long n;
int a[200010];
long long ans;
long long ch[MAXN]={0}; // 节点i下面的孩子的个数（包括i）
long long fa[MAXN][M+2]; // ch[i][j]表示与节点i距离为2^j的i的祖先
long long len[MAXN][M+2];
long long deep[MAXN]={0}; // i的深度（根节点的深度为1）
// 初始化deep数组，ch数组，fa数组的初始值
// 默认根节点为1
long long dfs(int cur=1, int father = 0,long long val=0)
{
    deep[cur] = deep[father]+1;
    fa[cur][0] = father;
    len[cur][0]=val;
    ch[cur] = 1;
    int sz = g[cur].size();
    for(int i=0;i<sz;i++)
    {
        if(g[cur][i].to != father)
            ch[cur] += dfs(g[cur][i].to,cur,g[cur][i].val);
    }
    return ch[cur];
}
// 初始化fa数组
void initFa(int n)
{
    for(int i=1;i<=19;i++)
        for(int node=1;node<=n;node++)
        {
            fa[node][i] = fa[fa[node][i-1]][i-1];
            len[node][i]= len[fa[node][i-1]][i-1]+len[node][i-1];
        }
}
// 将node上升height的高度
int binaryRaise(int node, int height,long long &val)
{
    val=0;
    for(int i=M; i>=0; i--)
    {
        if(fa[node][i] && height >= (1<<i))
        {
            val+=len[node][i];
            node = fa[node][i];
            height -= (1<<i);
        }
    }
    return node;
}
// a的深度比b大
long long lca(int a, int b)
{
    if(a==0||b==0)
        return -1;
    // 先移动a到与b同样深度的地方
    if(deep[a]<deep[b])
        swap(a,b);
    long long res=0;
    a = binaryRaise(a, deep[a]-deep[b],res);
    if(a==b) // 此时，b就是a和b的公共祖先
        //return a;
        return res;
    for(int i=M;i>=0;i--)
    {
        if(a!=b && fa[a][i]!=fa[b][i])
        {
            res+=len[a][i];
            a = fa[a][i];
            res+=len[b][i];
            b = fa[b][i];
        }
    }

    return res+len[a][0]+len[b][0];
}
int find(int a)
{
    if(f[a]==a||f[a]==-1)
        return f[a]=a;
    f[a]=find(f[f[a]]);
    t[a]=t[f[a]];
    return f[a];
}
int uni(int a,int b)
{
    int x=find(a),y=find(b);
    return f[y]=x;
}
bool issame(int a,int b)
{
    return find(a)==find(b);
}

bool cmp(int a,int b)
{
    return d[a]>d[b];
}
void merg(int a,int b)
{
    int fb=find(b);
    long long l11=lca(t[a].x,t[fb].x);
    long long l12=lca(t[a].x,t[fb].y);
    long long l21=lca(t[a].y,t[fb].x);
    long long l22=lca(t[a].y,t[fb].y);
    long long maxl=max(max(max(max(max(l11,l12),l21),l22),t[a].r),t[fb].r);
    int x1=t[a].x;
    int x2=t[fb].x;
    int y1=t[a].y;
    int y2=t[fb].y;
    if(l11==maxl)
    {
        t[a].x=x1;
        t[a].y=x2;
    }
    if(l12==maxl)
    {
        t[a].x=x1;
        t[a].y=y2;
    }
    if(l21==maxl)
    {
        t[a].x=y1;
        t[a].y=x2;
    }
    if(l22==maxl)
    {
        t[a].x=y1;
        t[a].y=y2;
    }
    if(t[a].r==maxl)
    {
        t[a].x=x1;
        t[a].y=y1;
    }
    if(t[fb].r==maxl)
    {
        t[a].x=x2;
        t[a].y=y2;
    }
    t[a].r=maxl;
    f[fb]=a;
}
void put(int p)
{
    t[p]=tree{0,p,p};
    f[p]=p;
    for(int i=0;i<(int)g[p].size();i++)
    {
        int to=g[p][i].to;
        if(f[to]==-1)
            continue;
        merg(p,to);
    }
    ans=max(ans,d[p]*t[p].r);
}
int main()
{
    freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(ch,0,sizeof(ch));
        memset(fa,0,sizeof(fa));
        memset(len,0,sizeof(len));
        memset(deep,0,sizeof(deep));
        //scanf("%I64d",&n);
        scanf("%lld",&n);
        for(int i=0;i<=n;i++)
            g[i].clear();
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",d+i);
            a[i-1]=i;
        }
        int x,y;
        long long v;
        for(int i=1;i<n;i++)
        {
            //scanf("%d%d%I64d",&x,&y,&v);
            scanf("%d%d%lld",&x,&y,&v);
            g[x].push_back(node{y,v});
            g[y].push_back(node{x,v});
        }
        dfs();
        initFa(n);
        sort(a,a+n,cmp);
        memset(f,-1,sizeof(f));
        memset(t,0,sizeof(t));
        ans=-1;
        for(int i=0;i<n;i++)
        {
            put(a[i]);
        }
        //printf("%I64d
",ans);
        printf("%lld
",ans);
    }
    return 0;
}

 思路2：对点考虑， 对于当前点s（每次选取重心）， 可以求出以它为根， 每一个子树上的点上到s的点权最小值， 和边权和， 然后 把每一个每一个子树分类， 这是为了避免计算的结果在同一个子树里。

然后计算不同子树中的结果， 这里计算结果时需要排个序， 按照点权最小值从大到小排序， 每次选取两个属于不同子树的最大边权和。

如此递归计算即可

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5+10;
int siz[MAXN], n, val[MAXN];
bool center[MAXN];

typedef pair<int, int>pii;
struct Edge{
    int to, next;
    int c;
}e[MAXN * 2];
int head[MAXN], edge_tot;
void Add_Edge(int x, int y, int z){
    e[edge_tot].to = y;
    e[edge_tot].next = head[x];
    e[edge_tot].c = z;
    head[x] = edge_tot++;
}

void init (){
    edge_tot = 0;
    memset(head, -1, sizeof (head));
    memset(center, 0, sizeof (center));
}

pair <pair<long long, long long>, int>Mval[MAXN];
pii Find(int s, int pa, int tot) {
    pii res = make_pair(INT_MAX, -1);
    int m = 0;
    siz[s] = 1;
    for (int i = head[s]; ~i; i = e[i].next) {
        int  u = e[i].to;
        if (u == pa || center[u]) {
            continue;
        }
        res = min(res, Find(u, s, tot));
        siz[s] += siz[u];
        m = max(m, siz[u]);
    }
    m = max(m, tot-siz[s]);
    return min(res, make_pair(m, s));
}

int idx, tim;
void Get_Min_Sum(int u, int pa, long long minval, long long sum){
    Mval[idx++] = make_pair(make_pair(minval, sum), tim);
    for (int i = head[u]; ~i; i = e[i].next){
        int v = e[i].to;
        if (v != pa && !center[v]){
            Get_Min_Sum(v, u, min(minval, (long long)val[v]), sum+e[i].c);
        }
    }
}
long long sub_solve(){
    sort (Mval, Mval+idx);
    long long res = 0;
    long long sum1 = Mval[idx-1].first.second, sum2 = 0;
    int t1 = Mval[idx-1].second;
    for (int i = idx-2; i >= 0; i--){
        if (Mval[i].second != t1){
            res = max(res, Mval[i].first.first*(Mval[i].first.second+sum1));
        }else{
            res = max(res, Mval[i].first.first*(Mval[i].first.second+sum2));
        }
        long long tmp = Mval[i].first.second;
        if (tmp > sum1){
            if (Mval[i].second == t1){
                sum1 = tmp;
            }else{
                sum2 = sum1;
                //t2 = t1;
                sum1 = tmp;
                t1 = Mval[i].second;
            }

        }else{
            if (tmp > sum2 && Mval[i].second != t1){
                sum2 = tmp;
                //t2 = Mval[i].second;
            }
        }

    }
    return res;
}
long long solve (int u, int tot){
    int g = Find(u, 0, tot).second;
    center[g] = true;
    long long res = 0;
    idx = 0;
    //tim++;
    Mval[idx++] = make_pair(make_pair(val[g],0), tim);
    for (int i = head[g]; ~i; i = e[i].next){
        int v = e[i].to;
        int cost = e[i].c;
        if (!center[v]){
            tim++;
            Get_Min_Sum(v, g, min(val[v], val[g]), cost);
        }
    }
    res = max(res, sub_solve());
    for (int i = head[g]; ~i; i = e[i].next){
        int v = e[i].to;
        if (!center[v]){
            res = max(res, solve(v, siz[v]));
        }
    }
    return res;
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int T;
    scanf ("%d", &T);
    while (T--){
        init();
        tim = 0;
        scanf ("%d", &n);
        for (int i = 0; i < n; i++){
            scanf ("%d", val+i+1);
        }
        for (int i = 0; i < n-1; i++){
            int u, v, c;
            scanf ("%d%d%d", &u, &v, &c);
            Add_Edge(u, v, c);
            Add_Edge(v, u, c);
        }
        long long res = solve(1, n);
        printf("%lld
", res);

    }
    return 0;
}