树上倍增、树分治学习总结

树上倍增：

　　核心：

　　  F[u][i] 表示u节点往上走2ⁱ步到达的祖先节点，F[u][0]=fa[u],F[u][i]=F[F[u][i-1]][i-1]，其他需要维护的数值也与此格式类似

 

【SCOI2016】幸运数字（题目）：

　　倍增时合并一下线性基即可

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N = 20010;

int n, q;
LL G[N], dep[N], ans[N];
LL fa[N][21], p[N][21][62];
int h[N], num[N << 1], nex[N << 1], dqx;

inline void add(int a, int b)
{
    num[dqx] = b;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

inline void get_p(LL *a, LL val)
{
    for (int i = 61; i >= 0; i--)
    {
        if ((val >> i) & 1)
        {
            if (!a[i])
            {
                a[i] = val;
                break;
            }
            val ^= a[i];
        }
    }
}

void dfs(int u, int f)
{
    fa[u][0] = f;
    dep[u] = dep[f] + 1;
    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if (j == f) continue;
        dfs(j, u);
    }
}

void merge(LL* a, LL* b)
{
    for (int i = 61; i >= 0; i--)
    {
        if (b[i]) get_p(a, b[i]);
    }
}

void get_lca()
{
    for (int j = 1; j < 20; j++)
    {
        for (int i = 1; i <= n; i++)
        {
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
            memcpy(p[i][j], p[i][j - 1], sizeof(p[i][j - 1]));
            merge(p[i][j], p[fa[i][j - 1]][j - 1]);
        }
    }
}

inline void LCA(int u, int v)
{
    if (dep[u] < dep[v]) swap(u, v);

    for (int i = 20; i >= 0; i--)
    {
        if (dep[fa[u][i]] >= dep[v])
        {
            merge(ans, p[u][i]);
            u = fa[u][i];
        }
    }
        
    if (u == v)
    {
        merge(ans, p[u][0]);
        return;
    }

    for (int i = 20; i >= 0; i--)
    {
        if (fa[u][i] != fa[v][i])
        {
            merge(ans, p[u][i]), merge(ans, p[v][i]);
            u = fa[u][i], v = fa[v][i];
        }
    }
        
    merge(ans, p[u][0]);
    merge(ans, p[v][0]);
    merge(ans, p[fa[u][0]][0]);
}

int main()
{
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++)
    {
        scanf("%lld", &G[i]);
        get_p(p[i][0], G[i]);
    }

    memset(h, -1, sizeof(h));
    for (int i = 1; i <= n - 1; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }

    dfs(1, 0);
    get_lca();

    for (int i = 1; i <= q; i++)
    {
        memset(ans, 0, sizeof(ans));

        int a, b;
        scanf("%d%d", &a, &b);
        LCA(a, b);
        LL res = 0;

        for (int j = 61; j >= 0; j--) res = max(res, res ^ (LL)ans[j]);
        printf("%lld\n", res);
    }
}

 

【NOI2018】归程（题目）：

　　进行一次Dijkstra，算出每个点到根（1号点）的最短距离dis，再把每条边按照海拔进行排序后进行kruskal重构树，重构树中的每个节点存储的是它代表的边的海拔以及他的子树中最小的dis（相当于是距离1最近的点的距离）。求值时倍增上去，第一个上不去的点的dis就是答案。

　　ps：关于kurskal重构树

　　树中除了叶节点是原树的点外其他的节点都代表原树的边，当要连接两个点时，将两个点所属的并查集的最高点合并，这两个最高点的父节点便变成代替当前这条边的节点。

　　如图，假如有一条编号为6的边要连接1,3两个点，则将1和5的父节点变成6（图中的1,2,3皆为点，其余为边）。

　　

 

 

 

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

typedef pair<int, int> PII;

const int N = 2000010;

int n, m;
int fa[N];
int dis[N];
int dep[N], F[N][20];
int h1[N], num1[N], nex1[N], dqx1;
int h[N], num[N], nex[N], v[N], dqx;
bool st[N];

struct Edge
{
    int a, b, l, v;
    Edge() {}
    Edge(int a, int b, int l, int v) : a(a), b(b), l(l), v(v) {}
}; 

Edge edge[N << 2], p[N << 2];

void add(int a, int b, int c)
{
    num[dqx] = b;
    v[dqx] = c;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

void Dijkstra()
{
    memset(st, 0, sizeof(st));
    memset(dis, 0x3f, sizeof(dis));

    priority_queue<PII, vector<PII>, greater<PII> > que;
    dis[1] = 0;
    que.push(make_pair(dis[1], 1));

    while (!que.empty())
    {
        PII t = que.top();
        que.pop();
        int u = t.second, d = t.first;

        if (st[u]) continue;
        st[u] = true;

        for (int i = h[u]; ~i; i = nex[i])
        {
            int j = num[i];
            if (st[j]) continue;
            if (dis[j] > dis[u] + v[i])
            {
                dis[j] = dis[u] + v[i];
                que.push(make_pair(dis[j], j));
            }
        }
    }
}

bool cmp(Edge a, Edge b)
{
    return a.v > b.v;
}

void addx(int a, int b)
{
    num1[dqx1] = b;
    nex1[dqx1] = h1[a];
    h1[a] = dqx1++;
}

void dfs(int u, int f)
{
    dep[u] = dep[f] + 1;
    F[u][0] = f;

    for (int i = 1; i <= 19; i++)
    {
        F[u][i] = F[F[u][i - 1]][i - 1];
    }

     for (int i = h1[u]; ~i; i = nex1[i])
    {
        int j = num1[i];
        if (j == f) continue;
        dfs(j, u);
        p[u].l = min(p[u].l, p[j].l);
    }
}

int find1(int x)
{
    return fa[x] == x ? x : fa[x] = find1(fa[x]);
}

void kruskal()
{
    int tot = 0, cnt = n;

    for (int i = 1; i <= (n << 1); i++) fa[i] = i;
    sort(edge + 1, edge + m + 1, cmp);

    memset(h1, -1, sizeof(h1));
    for (int i = 1; i <= m; i++)
    {
        int a = edge[i].a, b = edge[i].b;
        int fx = find1(a), fy = find1(b);
        if (fx == fy) continue;

        addx(++cnt, fx), addx(cnt, fy);

        fa[fx] = cnt, fa[fy] = cnt;

        p[cnt].v = edge[i].v;
        tot++;
        if (tot == n - 1) break;
    }

    dfs(cnt, 0);
}

int query(int a, int v)
{
    for (int i = 19; i >= 0; i--) if (dep[a] - (1 << i) > 0 && p[F[a][i]].v > v) a = F[a][i];
    return p[a].l;
}

void init()
{
    dqx = dqx1 = 0;
    memset(edge, 0, sizeof(edge));
    memset(h, -1, sizeof(h));
    memset(h1, -1, sizeof(h1));
    memset(F, 0, sizeof(F));
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        init();

        scanf("%d%d", &n, &m);

        for (int i = 1; i <= m; i++)
        {
            int a, b, l, v;
            scanf("%d%d%d%d", &a, &b, &l, &v);
            edge[i] = Edge(a, b, l, v);
            add(a, b, l), add(b, a, l);
        }

        for (int i = n + 1; i <= n * 2; i++) p[i].l = 2e9 + 7;

        Dijkstra();
        for (int i = 1; i <= n; i++) p[i].l = dis[i];

        kruskal();

        int ans = 0;
        int q, k, s;
        scanf("%d%d%d", &q, &k, &s);
        while (q--)
        {
            int u0, p0;
            scanf("%d%d", &u0, &p0);
            u0 = (u0 + k * ans - 1) % n + 1;
            p0 = (p0 + k * ans) % (s + 1);

            ans = query(u0, p0);
            printf("%d\n", ans);
        }

    }
}

 

【美团 CodeM 复赛】城市网络（题目）：

　　对于每次询问，新建一个节点，与u相连，权值为c。之后进行dfs，每个节点的父节点定为深度最深的权值比他大的点，求答案时从该询问对应新建的节点网上倍增，每次倍增时答案加上倍增往上跳的节点数。

 

#include<cstdio>
#include<cstring>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 200010;

int n, m;
int k, t;
int a[N], dep[N], to[N], F[20][N];

vector<int> e[N];

void dfs(int x, int f)
{
    int pos = f;
    for (int i = 19; i >= 0; i--)
    {
        if (F[i][pos] && a[F[i][pos]] <= a[x])
        {
            pos = F[i][pos];
        }
    }

    if (a[pos] > a[x]) F[0][x] = pos;
    else F[0][x] = F[0][pos];

    for (int i = 1; F[i - 1][F[i - 1][x]]; i++)
    {
        F[i][x] = F[i - 1][F[i - 1][x]];
    }
    dep[x] = dep[f] + 1; 

    for (int i : e[x])
    {
        if (i == f)continue;
        dfs(i, x);
    }
}

int main()
{
    int q;
    scanf("%d%d", &n, &q);

    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i < n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        e[a].push_back(b), e[b].push_back(a);
    }

    for (int i = 1; i <= q; i++)
    {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        a[n + i] = z;
        e[n + i].push_back(x);
        e[x].push_back(n + i);
        to[n + i] = y;
    }

    dfs(1, 0);

    for (int i = n + 1; i <= n + q; i++)
    {
        int ret = 0, pos = i;
        for (int j = 19; j >= 0; j--)
        {
            if (dep[F[j][pos]] >= dep[to[i]])
            {
                ret += (1 << j);
                pos = F[j][pos];
            }
        }
        printf("%d\n", ret);
    }
    return 0;
}

 

【BJWC2010】严格次小生成树（题目）：

　　倍增数组多存储一个边的次大值，之后枚举边时若和最大值相同就比较次大值。

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N = 500010;
const LL INF = 2e18 + 7;

int n, m;
int F[N][20], dep[N], fa[N];
LL ma[N][20], mi[N][20];
int h[N], num[N], nex[N], v[N], dqx;
bool st[N];

struct Edge
{
    int a, b, d;
    Edge() {}
};

Edge e[N];

bool cmp(Edge a, Edge b)
{
    return a.d < b.d;
}

void add(int a, int b, int c)
{
    num[dqx] = b;
    v[dqx] = c;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

int find1(int x)
{
    return fa[x] == x ? x : fa[x] = find1(fa[x]);
}

void dfs(int u, int pa)
{
    F[u][0] = pa;
    dep[u] = dep[pa] + 1;

    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if (j == pa) continue;
        ma[j][0] = v[i];
        mi[j][0] = -INF;
        dfs(j, u);
    }
}

LL query_max(int a, int b, int c)
{
    LL ans = -INF;
    for (int i = 18; i >= 0; --i)
    {
        if (dep[F[a][i]] >= dep[b])
        {
            if (c != ma[a][i]) ans = max(ans, ma[a][i]);
            else ans = max(ans, mi[a][i]);
            a = F[a][i];
        }
    }
    return ans;
}

int LCA(int a, int b)
{
    if (dep[a] < dep[b]) swap(a, b);

    for (int i = 18; i >= 0; i--)
    {
        if (dep[F[a][i]] >= dep[b]) a = F[a][i];
    }
    if (a == b) return a;

    for (int i = 18; i >= 0; i--)
    {
        if (F[a][i] != F[b][i])
        {
            a = F[a][i];
            b = F[b][i];
        }
    }

    return F[a][0];
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &e[i].a, &e[i].b, &e[i].d);
    }

    sort(e + 1, e + 1 + m, cmp);

    LL res = 0;
    memset(h, -1, sizeof(h));
    for (int i = 1; i <= n; i++) fa[i] = i;
    for (int i = 1; i <= m; i++)
    {
        int a = e[i].a, b = e[i].b, d = e[i].d;
        int fx = find1(a), fy = find1(b);

        if (fx == fy) continue;
        fa[fx] = fy;
        add(a, b, d);
        add(b, a, d);
        res += d;

        st[i] = true;
    }

    mi[1][0] = -INF;
    dfs(1, 0);
    
    for (int i = 1; i <= 18; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            F[j][i] = F[F[j][i - 1]][i - 1];
            ma[j][i] = max(ma[j][i - 1], ma[F[j][i - 1]][i - 1]);
            mi[j][i] = max(mi[j][i - 1], mi[F[j][i - 1]][i - 1]);
            if (ma[j][i - 1] > ma[F[j][i - 1]][i - 1]) mi[j][i] = max(mi[j][i], ma[F[j][i - 1]][i - 1]);
            else if (ma[j][i - 1] < ma[F[j][i - 1]][i - 1]) mi[j][i] = max(mi[j][i], ma[j][i - 1]);
        }
    }
        
    LL ans = INF;
    for (int i = 1; i <= m; i++)
    {
        if (st[i]) continue;

        int a = e[i].a, b = e[i].b, d = e[i].d;

        int lca = LCA(a, b);
        LL m1 = query_max(a, lca, d);
        LL m2 = query_max(b, lca, d);
        ans = min(ans, res - max(m1, m2) + d);
    }

    printf("%lld", ans);
}

 

【CF519E】A and B and Lecture Rooms（题目）：

　　如图，若a点为16，b点为15，先求出他们的LCA，为2，这时候a到b的路径的中点为5，答案就是size[5]-size[7]。

　　若a点为16，b点为8，LCA为2，这时候中点就是LCA，答案就是n-size[4]-size[5]。

　　若两点的深度差为奇数，则无解。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 200010;

int n;
int F[N][20];
int size1[N], dep[N];
int h[N], num[N], nex[N], dqx;

void add(int a, int b) 
{
    num[dqx] = b;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

void dfs(int u, int pa)
{
    size1[u] = 1;
    dep[u] = dep[pa] + 1;

    F[u][0] = pa;
    for (int i = 1; i <= 18; i++) F[u][i] = F[F[u][i - 1]][i - 1];

    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if (j == pa) continue;
        dfs(j, u);
        size1[u] += size1[j];
    }
}

int LCA(int a, int b)
{
    if (a == b) return n;
    if (dep[a] == dep[b])
    {
        for (int i = 18; i >= 0; i--)
        {
            if (F[a][i] != F[b][i])
            {
                a = F[a][i];
                b = F[b][i];
            }
        }
        return n - size1[a] - size1[b];
    }

    if (dep[a] < dep[b]) swap(a, b);

    if ((dep[a] - dep[b]) % 2) return 0;

    int x = a, d = (dep[a] - dep[b]) / 2;
    for (int i = 18; i >= 0; i--)
    {
        if (dep[F[a][i]] >= dep[b]) a = F[a][i];
    }

    if (a == b)
    {
        d = dep[a] + d;
        for (int i = 18; i >= 0; i--)
        {
            if (dep[F[x][i]] > d) x = F[x][i];
        }
        return size1[F[x][0]] - size1[x];
    }
    
    for (int i = 18; i >= 0; i--)
    {
        if (F[a][i] != F[b][i])
        {
            a = F[a][i], b = F[b][i];
        }
    }

    d = dep[a] - 1 + d;
    for (int i = 18; i >= 0; i--)
    {
        if (dep[F[x][i]] > d) x = F[x][i];
    }

    return size1[F[x][0]] - size1[x];
}

int main()
{
    scanf("%d", &n);

    memset(h, -1, sizeof(h));
    for (int i = 1; i < n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b);
        add(b, a);
    }

    dfs(1, 0);

    int m;
    scanf("%d", &m);
    while (m--)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", LCA(a, b));
    }
}

 

【ZJOI2012】灾难（题目）：

　　正反向图都建一个，然后用反向图拓扑排序，这样就能使拓扑排序中每个动物的食物都在它的前面。再遍历拓扑序，用正向图求出当前节点代表的动物的食物的公共祖先，因为只有所有的食物的公共祖先消失后，它的食物才会全部消失，它才会消失。再将它的所有食物的公共祖先向它连边，最后dfs遍历求出每个节点的子树大小，子树大小减一便是灾难值。

 

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010;

int n;
int ran[N];
int ind[N], dep[N], size1[N], F[N][20];
int h[N], num[N], nex[N], dqx;
int h1[N], num1[N], nex1[N], dqx1;
int h2[N], num2[N], nex2[N], dqx2;

void add(int a, int b)
{
    num[++dqx] = b;
    nex[dqx] = h[a];
    h[a] = dqx;
}

void add1(int a, int b)
{
    num1[++dqx1] = b;
    nex1[dqx1] = h1[a];
    h1[a] = dqx1;
}

void add2(int a, int b)
{
    num2[++dqx2] = b;
    nex2[dqx2] = h2[a];
    h2[a] = dqx2;
}

void topsort()
{
    queue<int> que;
    for (int i = 1; i <= n; i++)
    {
        if (!ind[i]) que.push(i);
    }

    int cnt = 0;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();
        ran[++cnt] = u;

        for (int i = h[u]; i; i = nex[i])
        {
            int j = num[i];
            if (--ind[j] == 0) que.push(j);
        }
    }
}

int LCA(int a, int b)
{
    if (dep[a] < dep[b]) swap(a, b);

    for (int i = 18; i >= 0; i--)
    {
        if (dep[F[a][i]] >= dep[b]) a = F[a][i];
    }

    if (a == b) return a;

    for (int i = 18; i >= 0; i--)
    {
        if (F[a][i] != F[b][i])
        {
            a = F[a][i];
            b = F[b][i];
        }
    }

    return F[a][0];
}

void dfs(int u)
{
    size1[u] = 1;
    for (int i = h2[u]; i; i = nex2[i])
    {
        int j = num2[i];
        dfs(j);
        size1[u] += size1[j];
    }
}

int main()
{
    scanf("%d", &n);

    for (int i = 1; i <= n; i++)
    {
        int x, a;
        while (scanf("%d", &x), x)
        {
            ind[i]++;
            add(x, i);
            add1(i, x);
        }
    }

    topsort();

    for (int i = 1; i <= n; i++)
    {
        int u = num1[h1[ran[i]]];
        for (int j = h1[ran[i]]; j; j = nex1[j]) u = LCA(u, num1[j]);

        add2(u, ran[i]);
        dep[ran[i]] = dep[u] + 1;
        F[ran[i]][0] = u;
        for (int j = 1; j <= 18; j++) F[ran[i]][j] = F[F[ran[i]][j - 1]][j - 1];
    }

    dfs(0);

    for (int i = 1; i <= n; i++) printf("%d\n", size1[i] - 1);
}

 

【洛谷P4197】Peaks（题目）：

　　kruskal重建树，记录每个节点的子树区间左端点右端点（range），然后用主席树来求第k大数。

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 6000010;

int n, m;
int cnt, tot;
int w[N];
int fa[N], F[N][20];
int b[N], lenb;
int range[N][2], dis[N];
int rt[N], ls[N], rs[N], sum[N];
int h[N], num[N], nex[N], dqx;

struct Edge
{
    int a, b, d;
    Edge() {}
    Edge(int a, int b, int d) :a(a), b(b), d(d) {}
};

Edge e[N];

bool cmp(Edge a, Edge b)
{
    return a.d < b.d;
}

void add(int a, int b)
{
    num[dqx] = b;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

void build(int& q, int l, int r)
{
    q = ++cnt;
    if (l == r) return;
    int mid = (l + r) >> 1;
    build(ls[q], l, mid);
    build(rs[q], mid + 1, r);
}

void modify(int pre, int& q, int l, int r, int k)
{
    q = ++cnt;
    ls[q] = ls[pre], rs[q] = rs[pre], sum[q] = sum[pre] + 1;
    if (l == r) return;
    int mid = (l + r) >> 1;
    if (k <= mid) modify(ls[pre], ls[q], l, mid, k);
    else modify(rs[pre], rs[q], mid + 1, r, k);
}

int query(int pre, int q, int l, int r, int k)
{
    if (l == r) return l;
    int mid = (l + r) >> 1;
    int d = sum[rs[q]] - sum[rs[pre]];
    if (k > d) return query(ls[pre], ls[q], l, mid, k-d); // 因为要求第k高，但主席树的值是从小到大的，所以要反着来
    else return query(rs[pre], rs[q], mid + 1, r, k);
}

void dfs(int u)
{
    for (int i = 1; i <= 18; i++) F[u][i] = F[F[u][i - 1]][i - 1];

    range[u][0] = tot;
    if (!(~h[u]))
    {
        int k = lower_bound(b + 1, b + lenb + 1, w[u]) - b;
        range[u][0] = ++tot;
        modify(rt[tot - 1], rt[tot], 1, lenb, k);
        return;
    }

    for (int i = h[u]; ~i; i = nex[i])
    {
        dfs(num[i]);
    }

    range[u][1] = tot;
}

int find1(int x)
{
    return fa[x] == x ? x : fa[x] = find1(fa[x]);
}

void kruskal()
{
    sort(e + 1, e + 1 + m, cmp);
    for (int i = 1; i <= n; i++) fa[i] = i;

    int tmp = n;
    memset(h, -1, sizeof(h));
    for (int i = 1; i <= m; i++)
    {
        int x = e[i].a, y = e[i].b;
        int fx = find1(x), fy = find1(y);
        if (fx == fy) continue;

        fa[fx] = ++tmp;
        fa[fy] = tmp;
        fa[tmp] = tmp;

        add(tmp, fx), add(tmp, fy);
        F[fx][0] = F[fy][0] = tmp;
        dis[tmp] = e[i].d;
    }

    build(rt[0], 1, lenb);
    dfs(tmp);
}

int main()
{
    int q;
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &w[i]);
        b[i] = w[i];
    }

    sort(b + 1, b + n + 1);
    lenb = unique(b + 1, b + 1 + n) - b - 1;

    for (int i = 1; i <= m; i++)
    {
        int x, y, z;
        scanf("%d%d%d", &x, &y, &z);
        e[i] = Edge(x, y, z);
    }

    kruskal();

    while (q--)
    {
        int x, d, k;
        scanf("%d%d%d", &x, &d, &k);
        for (int i = 18; i >= 0; i--)
        {
            if (F[x][i] && dis[F[x][i]] <= d) x = F[x][i];
        }
        if (sum[rt[range[x][1]]] - sum[rt[range[x][0]]] < k) puts("-1");
        else    printf("%d\n", b[query(rt[range[x][0]], rt[range[x][1]], 1, lenb, k)]);
    }
}

 

【PA2014】Fiolki（题目）：

　　类似于kurskal重构树，每次混合药剂后，新建一个节点，表示混合后的b_i瓶子，新节点分别是a_i,b_i的父节点，下次需要用到b_i来混合时就要用这个新建节点来加边。

反应发生的位置就是会发生反应的两个药剂的LCA，将反应按照LCA深度从大到小为第一关键字，编号从小到大为第二关键字排序，没有LCA的反应踢掉（没有一次混合会发生这个反应）。遍历一遍反应，将反应需要的两种药剂都减去两种药剂中剂量较少的药剂的剂量，答案加上较少药剂的剂量*2。

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010;

int n, m;
int w[N], pos[N];
int dep[N], F[N][20];
int h[N], num[N], nex[N], dqx;

struct Node
{
    int a, b, dep, id;
    Node() {}
    Node(int a, int b, int dep, int id) :a(a), b(b), dep(dep), id(id) {}
};

Node rea[N];

bool cmp(Node a, Node b)
{
    return a.dep == b.dep ? a.id < b.id : a.dep > b.dep;
}

void add(int a, int b)
{
    num[dqx] = b;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

void dfs(int u)
{
    dep[u] = dep[F[u][0]] + 1;

    for (int i = 1; i <= 18; i++) F[u][i] = F[F[u][i - 1]][i - 1];

    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if (j == F[u][0]) continue;
        F[j][0] = u;
        dfs(j);
    }
}

int LCA(int a, int b)
{
    if (dep[a] < dep[b]) swap(a, b);
    for (int i = 18; i >= 0; i--)
    {
        if (dep[F[a][i]] >= dep[b]) a = F[a][i];
    }

    if (a == b) return a;

    for (int i = 18; i >= 0; i--)
    {
        if (F[a][i] != F[b][i])
        {
            a = F[a][i];
            b = F[b][i];
        }
    }

    return F[a][0];
}

int main()
{
    int q;
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; i++)
    {
        pos[i] = i;
        scanf("%d", &w[i]);
    }

    memset(h, -1, sizeof(h));
    for (int i = 1; i <= m; i++)
    {
        int a, b;
        int c = n + i;
        scanf("%d%d", &a, &b);
        add(c, pos[a]);
        add(c, pos[b]);
        pos[b] = c;
    }

    for (int i = n + m; i; i--)
    {
        if (!F[i][0]) dfs(i);
    }

    for (int i = 1; i <= q; i++)
    {
        int a, b;
        scanf("%d%d", &a,&b);
        int lca = LCA(a, b);
        if (!lca) continue;
        rea[i] = Node(a, b, dep[lca], i);
    }

    sort(rea + 1, rea + 1 + q, cmp);

    long long ans = 0;
    for (int i = 1; i <= q; i++)
    {
        int a = rea[i].a, b = rea[i].b;
        int t = min(w[a], w[b]);
        ans += t * 2;
        w[a] -= t, w[b] -= t;
    }

    printf("%lld", ans);
}

 

树分治：

　　核心：

　　 用来处理树上所有点对路径的问题，每次递归找出当前子树的重心，经过重心的路径进行统计，该重心统计完后再递归子树进行相同操作。

 

【CF293E】Close Vertices（题目）：

　　每次递归找出子树的重心，从重心往其他点查询满足的点对数。

 

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 2000010;

int n, l, w;
long long ans;
int t[N], f[N];
int head, tail, sum, root;
int size1[N], dep[N], len[N], dis[N];
int h[N], num[N], nex[N], v[N], dqx;
bool st[N];

queue<int> que;

struct Node
{
    int l, d;
    Node() {}
    Node(int l, int d) :l(l), d(d) {}
};

Node q[N];

bool cmp1(Node x, Node y)
{
    return x.d < y.d;
}

bool cmp2(Node x, Node y)
{
    return x.d > y.d;
}

void add(int a, int b, int c)
{
    num[dqx] = b;
    v[dqx] = c;
    nex[dqx] = h[a];
    h[a] = dqx++;
}

void get_root(int u, int fa)
{
    size1[u] = 1;
    f[u] = 0;
    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if ((j == fa) || st[j]) continue;

        get_root(j, u);
        size1[u] += size1[j];
        f[u] = max(f[u], size1[j]);
    }

    f[u] = max(f[u], sum - size1[u]);
    if ((f[u] < f[root]) || (!root)) root = u;
}

int lowbit(int x)
{
    return x & -x;
}

void update(int u, int k)
{
    while (u <= n)
    {
        t[u] += k;
        u += lowbit(u);
    }
}

int get(int x)
{
    int res = 0;
    while (x > 0)
    {
        res += t[x];
        x -= lowbit(x);
    }
    return res;
}

void dfs(int u, int fa)
{
    size1[u] = 1;
    for (int i = h[u]; ~i; i = nex[i])
    {
        int j = num[i];
        if (j == fa || st[j]) continue;

        len[j] = len[u] + 1;
        dis[j] = dis[u] + v[i];
        q[++tail] = Node(len[j], dis[j]);

        dfs(j, u);

        size1[u] += size1[j];
        if (u == root)
        {
            sort(q + 1, q + head + 1, cmp1);
            sort(q + head + 1, q + tail + 1, cmp2);
            int k = 1;
            for (int j = head + 1; j <= tail; j++)
            {
                while ((q[k].d + q[j].d <= w) && (k <= head))
                {
                    update(q[k].l + 1, 1);
                    k++;
                }
                ans += (long long)get(l - q[j].l + 1);
            }
            for (int g = 1; g < k; g++) update(q[g].l + 1, -1);
            head = tail;
            que.push(j);
        }
    }
}

int main()
{
    scanf("%d%d%d", &n, &l, &w);

    memset(h, -1, sizeof(h));
    for (int i = 2; i <= n; i++)
    {
        int x, d;
        scanf("%d%d", &x, &d);
        add(i, x, d), add(x, i, d);
    }

    que.push(1);
    size1[1] = n;
    while (!que.empty())
    {
        int u = que.front();
        que.pop();

        sum = size1[u];
        root = 0;
        get_root(u, 0);
        len[root] = dis[root] = 0;

        head = 1, tail = 1;
        q[1] = Node(0, 0);
        dfs(root, 0);
        st[root] = true;
    }
    printf("%lld", ans);
}

 

【NOI2014】购票（题目）：

　　设f[u]为u到1的最小代价，则：

　　　　

　　设d[u]=dis[u]×p_u​+q_u，则：

　　　　

 

 　　若有两个合法的转移点j，k，比较他们转移的优劣：

　　　　

 

 　　当j比k更优时，则：

　　　　

 

 　　即点(dis[j],f[j])和点(dis[k],f[k])之间的斜率大于p_u，用所以我们需要用单调栈维护一个合法点的下凸壳，这样可以根据不同的 p_u​ 在凸壳上二分得到决策点。维护一些区间中的凸壳，查询时选择一些区间的并恰好等于需要的后缀，在每个区间内分别查询最优决策并更新。用树状数组维护后缀信息

 

 

 

 

#include<cstdio>
#include<cstring>
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;

typedef long long LL;

const int N = 4000010;
const LL INF = 2e18 + 7;

int n, faz[N];
LL wgh[N];
LL dep[N], dis[N];
LL p[N], q[N], b[N], len[N];
LL stds[N], tds;
LL f[N], * X = dis, * Y = f;

std::vector<int> G[N];

int stkp[N], valp[N], tpp[N];
int* istk[N], * ival[N], * itp[N], it[N];

double slope(int i, int j) 
{
    return X[i] == X[j] ? 1e60 : (double)(Y[j] - Y[i]) / (X[j] - X[i]);
}

void push(int id, int u) 
{
    int t = it[id], tp = itp[id][t], * stk = istk[id];
    while (tp > 0 && slope(stk[tp - 1], stk[tp]) >= slope(stk[tp], u)) --tp;
    ++t, ival[id][t] = stk[itp[id][t] = ++tp], stk[tp] = u, it[id] = t;
}

void pop(int id)
{
    istk[id][itp[id][it[id]]] = ival[id][it[id]];
    --it[id];
}

int check(int id, LL slp) 
{
    int t = it[id], tp = itp[id][t], * stk = istk[id];

    if (!~tp) return -1;
    int lb = 0, rb = tp - 1, x = tp, mid;

    while (lb <= rb) 
    {
        mid = (lb + rb) >> 1;
        if (slope(stk[mid], stk[mid + 1]) <= slp) lb = mid + 1;
        else x = mid, rb = mid - 1;
    }
    return stk[x];
}

void push_all(int i, int u)
{
    for (; i <= n; i += i & -i) push(i, u);
}

void pop_all(int i)
{
    for (; i <= n; i += i & -i) pop(i);
}

void get_DP(int u) 
{
    f[u] = INF;
    int i = lower_bound(stds + 1, stds + tds + 1, dis[u] - len[u]) - stds;
    for (i = n - i + 1; i; i -= i & -i) 
    {
        int v = check(i, p[u]);
        if (~v) f[u] = std::min(f[u], f[v] - dis[v] * p[u] + b[u]);
    }
}

void dfs(int u) 
{
    dep[u] = dep[faz[u]] + 1;
    dis[u] = dis[faz[u]] + wgh[u];
    stds[++tds] = dis[u];
    b[u] = dis[u] * p[u] + q[u];

    get_DP(u);
    push_all(n - dep[u], u);
    for (auto v : G[u]) dfs(v);
    pop_all(n - dep[u]);
    --tds;
}

int main()
{
    scanf("%d%*d", &n);

    istk[1] = stkp;
    itp[1] = tpp;
    ival[1] = valp;
    itp[1][it[1] = 0] = -1;

    for (int i = 2; i <= n; ++i)
    {
        int lenl = ((i - 1) & (1 - i)) + 1;
        istk[i] = istk[i - 1] + lenl;
        itp[i] = itp[i - 1] + lenl;
        ival[i] = ival[i - 1] + lenl;
        itp[i][it[i] = 0] = -1;
    }

    for (int i = 2; i <= n; ++i) 
    {
        scanf("%d%lld%lld%lld%lld", &faz[i], &wgh[i], &p[i], &q[i], &len[i]);
        G[faz[i]].push_back(i);
    }

    push_all(n, 1);
    stds[tds = 1] = 0;

    for (auto u : G[1]) dfs(u);
    for (int i = 2; i <= n; ++i) printf("%lld\n", f[i]);
}