bzoj 4390（树上差分）

最新推荐文章于 2019-09-09 13:13:18 发布

转载最新推荐文章于 2019-09-09 13:13:18 发布 · 72 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Chen-Jr/p/11007151.html

文章标签：

#ui

本文介绍了一种通过树上差分解决特定树形结构路径计数问题的方法。利用LCA算法和差分技巧，实现了O(nlogn)的时间复杂度。

传送门

题意：

给你一颗有 $n$ 个结点的树以及 $m$ 个路径。对于每一个路径 $path_i$ ，代表着你将会从 $u_i$ 走到 $v_i$ 。现在问你，你走完着 $m$ 个路径后，在这 $n$ 个结点中经过的最多的次数。

题目分析：

首先，如果我们用 $d f s$ 在树上暴力去跑的话，显然时间肯定是接受不了的。因此我们需要考虑一种较为优美的算法。

我们发现，经过每一个路径 $path_i$ ，本质上是使路径 $path_i$ 上的所有的点权 $+ 1$ ，如果这个问题是在序列上的话，我们直接就可以用线段树或差分树状数组去做。而正因为这个问题是在树上进行的，因此为了简化问题，我们则需要将树形的结构转化成链式结构。

因此根据转化的不同，该问题可以通过树链剖分或者树上差分去解决。

而显然树上差分相对来说比较简单。

我们只需要令 $cnt[u_i]+1$ ， $cnt[v_i]+1$ ，并且令 $cnt[~lca[u_i,v_i]~]-1$ ， $cnt[~fa[~lca[u_i,v_i]~] ~]-1$ 即可。如果我们采用上述差分方法，在最后我们进行 $d f s$ 回溯的时候，当前结点 $u$ 就能够获得他的儿子们的权值。

整体的时间复杂度： $O(nlogn)\mathcal{O}(nlogn)$

代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn=500005;
const int LOG=20;
struct Node{
    int to,next;
}q[maxn<<1];
int head[maxn],cnt=0;
void add_edge(int from,int to){
    q[cnt].to=to;
    q[cnt].next=head[from];
    head[from]=cnt++;
}
struct LCA{//倍增lca
    int anc[maxn][LOG],depth[maxn];
    void dfs(int x,int fa,int dis){
        anc[x][0]=fa;depth[x]=dis;
        for(int i=head[x];i!=-1;i=q[i].next){
            int to=q[i].to;
            if(to==fa) continue;
            dfs(to,x,dis+1);
        }
    }
    void init(int root,int n){
        dfs(root,-1,1);
        for(int j=1;j<LOG;j++){
            for(int i=1;i<=n;i++){
                anc[i][j]=anc[ anc[i][j-1] ][j-1];
            }
        }
    }
    void swim(int &x,int h){
        for(int i=0;h>0;i++){
            if(h&1)
                x=anc[x][i];
            h>>=1;
        }
    }
    int query(int x,int y){
        if(depth[x]<depth[y]) swap(x,y);
        swim(x,depth[x]-depth[y]);
        if(x==y) return x;
        for(int i=LOG-1;i>=0;i--){
            if(anc[x][i]!=anc[y][i]){
                x=anc[x][i];
                y=anc[y][i];
            }
        }
        return anc[x][0];
    }
}lca;
int Bit[maxn];
void Search(int x,int fa){//最优一次dfs获取权值
    for(int i=head[x];i!=-1;i=q[i].next){
        int to=q[i].to;
        if(to==fa) continue;
        Search(to,x);
        Bit[x]+=Bit[to];
    }
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof(head));
    cnt=0;
    for(int i=1;i<n;i++){
        int from,to;
        scanf("%d%d",&from,&to);
        add_edge(from,to);
        add_edge(to,from);
    }
    lca.init(1,n);
    while(m--){
        int l,r;
        scanf("%d%d",&l,&r);
        Bit[l]++,Bit[r]++;//差分
        int x=lca.query(l,r);
        Bit[x]--;
        Bit[lca.anc[x][0]]--;
    }
    Search(1,-1);
    int maxx=0;
    for(int i=1;i<=n;i++){
        maxx=max(maxx,Bit[i]);
    }
    printf("%d\n",maxx);
    return 0;
}