HDU 6393 Traffic Network in Numazu（树形DP+在线倍增LCA+BIT+并查集）

Description

给出一个$n$个点$n$条边的连通无向图，边有边权，$q$次操作，操作分两种

$0\ X\ Y$:将第$X$条边边权修改为$Y$

$1\ X\ Y$:查询$X,Y$两点间的最短路

Input

第一行一整数$T$表示用例组数，每组用例首先输入两个整数$n,m$表示点数和操作数，之后$n$行每行输入三个整数$u,v,w$表示$u,v$之间有一条边权为$w$的边，最后$m$行每行一个操作

$(1\le n\le 10^5,1\le q,w,Y\le 10^5)$

Output

对于每次查询操作，输出查询结果

Sample Input

2
5 5
1 2 3
2 3 5
2 4 5
2 5 1
4 3 3
0 1 5
1 3 2
1 5 4
0 5 4
1 5 1
5 3
1 2 3
1 3 2
3 4 4
4 5 5
2 5 5
0 1 3
0 4 1
1 1 4

Sample Output

5
6
6
6

Solution

用并查集维护连通性得到一条环上的边，删去这条边后该基环变成一棵树，进而可以树形$DP$得到每点到根节点距离，再求出两点$LCA$即可快速得到树上两点距离，每次修改边权即为修改一棵子树所有点到达根节点的距离，这些点的$dfs$序为一段连续区间，那么修改边权即为一个区间更新，差分后用树状数组维护修改值即可，对于查询$x,y$之间的最短路，只有两种情况，是否经过删去的那条边，不经过删去的边时的最短路即为在树上的两点距离$d(x,y)$，经过删去的边（假设删去的边为$u\rightarrow v$，边权为$w$），则最短路为$min(d(x,u)+d(y,v)+w,d(x,v)+d(y,u)+w)$，取较小值即为答案，时间复杂度$O(nlogn+mlogn)$

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
namespace fastIO 
{
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror=0;
    inline char nc() 
    {
        static char buf[BUF_SIZE],*p1=buf+BUF_SIZE,*pend=buf+BUF_SIZE;
        if(p1==pend) 
        {
            p1=buf;
            pend=buf+fread(buf,1,BUF_SIZE,stdin);
            if(pend==p1) 
            {
                IOerror=1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) 
    {
        return ch==' '||ch=='\n'||ch=='\r'||ch=='\t';
    }
    inline void read(int &x) 
    {
        char ch;
        while(blank(ch=nc()));
        if(IOerror)return;
        int sgn=1;
        if(ch=='-')sgn=-1;
        for(x=ch-'0';(ch=nc())>='0'&&ch<='9';x=x*10+ch-'0');
        x=sgn*x;
    }
    #undef BUF_SIZE
};
using namespace fastIO;
typedef long long ll;
typedef pair<int,int>P;
#define maxn 100005
struct BIT 
{
    #define lowbit(x) (x&(-x))
    ll b[maxn];
    int n;
    void init(int _n)
    {
        n=_n;
        for(int i=1;i<=n;i++)b[i]=0;
    }
    void update(int x,int v)
    {
        while(x<=n)
        {
            b[x]+=v;
            x+=lowbit(x);
        }
    }
    ll query(int x)
    {
        int ans=0;
        while(x)
        {
            ans+=b[x];
            x-=lowbit(x);
        }
        return ans;
    }
}bit;
int T,n,q,e[maxn][3],fa[maxn],L[maxn],R[maxn],index,p[maxn][18],dep[maxn];
vector<P>g[maxn];
ll dis[maxn];
int find(int x)
{
    if(fa[x]==x)return x;
    return fa[x]=find(fa[x]);
}
void dfs(int u,int f)
{
    L[u]=index++;
    for(int i=0;i<g[u].size();i++)
    {
        int v=g[u][i].first,w=g[u][i].second;
        if(v==f)continue;
        dis[v]=dis[u]+w;
        dep[v]=dep[u]+1;
        p[v][0]=u;
        dfs(v,u);
    }
    R[u]=index;
}
int lca(int a,int b)
{
    int i,j;
    if(dep[a]<dep[b])swap(a,b);
    for(i=0;(1<<i)<=dep[a];i++);
    i--;
    for(j=i;j>=0;j--)
        if(dep[a]-(1<<j)>=dep[b])
            a=p[a][j];
    if(a==b)return a;
    for(j=i;j>=0;j--)
        if(p[a][j]&&p[a][j]!=p[b][j])
            a=p[a][j],b=p[b][j];
    return p[a][0];
}
ll get(int u,int v)
{
    ll ans=dis[u]+bit.query(L[u])+dis[v]+bit.query(L[v]);
    int w=lca(u,v);
    ans-=2ll*(dis[w]+bit.query(L[w]));
    return ans;
}
int main()
{
    read(T);
    while(T--)
    {
        read(n);read(q);
        for(int i=1;i<=n;i++)g[i].clear(),fa[i]=i;
        int Id;
        for(int i=1;i<=n;i++)
        {
            int u,v,w;
            read(u);read(v);read(w);
            e[i][0]=u,e[i][1]=v,e[i][2]=w;
            if(find(u)==find(v))Id=i;
            else 
            {
                g[u].push_back(P(v,w));
                g[v].push_back(P(u,w));
                u=find(u),v=find(v);
                fa[u]=v;
            }
        }
        index=1;
        dep[1]=0;
        memset(p,0,sizeof(p));
        dfs(1,0);
        for(int j=1;j<18;j++)
            for(int i=1;i<=n;i++)
                p[i][j]=p[p[i][j-1]][j-1];
        for(int i=1;i<=n;i++)
            if(dep[e[i][0]]<dep[e[i][1]])swap(e[i][0],e[i][1]);
        bit.init(n);
        while(q--)
        {
            int op,x,y;
            read(op);read(x);read(y);
            if(op==0)
            {
                if(x!=Id)
                {
                    int u=e[x][0];
                    bit.update(L[u],y-e[x][2]);
                    bit.update(R[u]+1,e[x][2]-y);
                }
                e[x][2]=y;
            }
            else
            {
                ll ans=get(x,y);
                ans=min(ans,get(x,e[Id][0])+get(y,e[Id][1])+e[Id][2]);
                ans=min(ans,get(x,e[Id][1])+get(y,e[Id][0])+e[Id][2]);
                printf("%lld\n",ans);
            }
        }
    }
    return 0;
}