边分治

跟点分治差不多的东西，先转二叉，然后找边，分治。可以动态，还听说有个骚操作叫边分树合并...

注意虚点虚边的处理！注意边分治不能善终，_n = 1的时候特判。

void rebuild(int x, int f) {
    int temp = 0;
    for(int i = 0; i < (int)G[x].size(); i++) {
        int y = G[x][i];
        if(y == f) continue;
        if(!temp) {
            temp = x;
            add(x, y, 1);
            add(y, x, 1);
        }
        else if(i == G[x].size() - 1) {
            add(temp, y, 1);
            add(y, temp, 1);
        }
        else {
            add(temp, ++cnt, 0);
            add(cnt, temp, 0);
            val[cnt] = val[temp];
            temp = cnt;
            add(temp, y, 1);
            add(y, temp, 1);
        }
        rebuild(y, x);
    }
    return;
}

例题：bzoj2870 最长道路

找到重心边，然后考虑在两边各选取一个点使得它们路径上的最小值 * 距离最大。

于是把两边的点分别提取出来排序，然后用一个指针扫过去，维护最值即可。

注意距离的处理，跟分治边的虚实有关。

#include <bits/stdc++.h>

#define forson(x, i) for(int i = e[x]; i; i = edge[i].nex)

typedef long long LL;
const int N = 100010, INF = 0x3f3f3f3f;

struct Edge {
    int nex, v, len;
    bool vis;
}edge[N << 1]; int tp = 1;

struct Node {
    LL v, d;
    Node(LL D = 0, LL V = 0) {
        v = V;
        d = D;
    }
    inline bool operator < (const Node &w) const {
        return v < w.v;
    }
}stk[2][N];

int e[N], cnt, n, siz[N], d[N], _n, small, root, head[2];
LL val[N], Val[N], ans;
std::vector<int> G[N];

inline void add(int x, int y, int z) {
    tp++;
    edge[tp].v = y;
    edge[tp].len = z;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void rebuild(int x, int f) {
    int temp = 0;
    for(int i = 0; i < (int)G[x].size(); i++) {
        int y = G[x][i];
        if(y == f) continue;
        if(!temp) {
            temp = x;
            add(x, y, 1);
            add(y, x, 1);
        }
        else if(i == G[x].size() - 1) {
            add(temp, y, 1);
            add(y, temp, 1);
        }
        else {
            add(temp, ++cnt, 0);
            add(cnt, temp, 0);
            val[cnt] = val[temp];
            temp = cnt;
            add(temp, y, 1);
            add(y, temp, 1);
        }
        rebuild(y, x);
    }
    return;
}

void getroot(int x, int f) {
    siz[x] = 1;
    forson(x, i) {
        int y = edge[i].v;
        if(y == f || edge[i].vis) continue;
        getroot(y, x);
        if(std::max(siz[y], _n - siz[y]) < small) {
            small = std::max(siz[y], _n - siz[y]);
            root = i;
        }
        siz[x] += siz[y];
    }
    return;
}

void DFS_1(int x, int f, int flag) {
    siz[x] = 1;
    Val[x] = std::min(val[x], Val[f]);
    //printf("x = %d d = %d Val = %lld 
", x, d[x], Val[x]);
    stk[flag][++head[flag]] = Node(d[x], Val[x]);
    forson(x, i) {
        int y = edge[i].v;
        if(y == f || edge[i].vis) continue;
        d[y] = d[x] + edge[i].len;
        DFS_1(y, x, flag);
        siz[x] += siz[y];
    }
    return;
}

void e_div(int x) {
    if(_n == 1) return;
    small = INF;
    getroot(x, 0);
    edge[root].vis = edge[root ^ 1].vis = 1;

    x = edge[root].v;
    int y = edge[root ^ 1].v;
    //printf("div x = %d y = %d 
", x, y);

    head[0] = head[1] = 0;
    d[x] = d[y] = 0;
    DFS_1(x, 0, 0);
    DFS_1(y, 0, 1);
    std::sort(stk[0] + 1, stk[0] + head[0] + 1);
    std::sort(stk[1] + 1, stk[1] + head[1] + 1);

    int p1 = head[1];
    LL large = -INF;
    for(int i = head[0]; i >= 1; i--) {
        while(p1 && stk[1][p1].v >= stk[0][i].v) {
            large = std::max(large, stk[1][p1].d);
            p1--;
        }
        ans = std::max(ans, stk[0][i].v * (stk[0][i].d + large + edge[root].len + 1));
    }
    large = -INF;
    p1 = head[0];
    for(int i = head[1]; i >= 1; i--) {
        while(p1 && stk[0][p1].v >= stk[1][i].v) {
            large = std::max(large, stk[0][p1].d);
            p1--;
        }
        ans = std::max(ans, stk[1][i].v * (stk[1][i].d + large + edge[root].len + 1));
    }
    //printf("ans = %lld 
", ans);
    _n = siz[x];
    e_div(x);
    _n = siz[y];
    e_div(y);
    return;
}
/*
3
5 3 5
1 2
1 3
*/

void out(int x, int f) {
    printf("x = %d f = %d  val = %lld
", x, f, val[x]);
    forson(x, i) {
        int y = edge[i].v;
        if(y == f) continue;
        //printf("%d -> %d 
", x, y);
        out(y, x);
    }
    return;
}

int main() {

    Val[0] = INF;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%lld", &val[i]);
        ans = std::max(ans, val[i]);
    }
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d", &x, &y);
        G[x].push_back(y);
        G[y].push_back(x);
    }
    cnt = n;
    rebuild(1, 0);

    //out(1, 0);
    _n = cnt;
    e_div(1);
    printf("%lld
", ans);
    return 0;
}

例题：暴力写挂。通道。