HDU6393(LCA + RMQ + 树状数组) n边图，两点最短距离 ， 修改边权

这道题的进阶版本

进阶版本

题意：

一个n个点，n条边的图，2中操作，1是将某条边的权值更改，2是询问两点的最短距离。

题解：

由于n个点，n条边，所以是树加一个环，将环上的边随意取出一条，就是1颗树，以取出的边的一个端点为根，建立有根树。虚线就是取出的边。红色为环上的边。

对于更改边的权值的操作，用dfs序+区间修改点查询的树状树组维护。

对于询问最短路的操作，用LCA分类解决。假设询问的两点是x、y，LCA是 z。

若z不是环上的点，那么最短路就是：x到根的距离+y到根的距离-z到根的距离*2；
若z是环上的点，最短路可能是经过图中红线的路径，也可能是经过图中虚线的路径，取最短的即可

#include<bits/stdc++.h>
#define lson (i<<1)
#define rson (i<<1|1)

using namespace std;
typedef long long ll;
const int N =1e5+;

struct node
{
    int u,v,next;
    int id,f;
    ll w;
}edge[N*];

struct node1
{
    int l,r;
    ll w;
    ll lz;
}tr[N<<];

int tot,head[N];
int n,q;
int anc[N<<][];

int dfn;
int dfns[N*];
int dep[N*];
int pos[N];
int inde[N];
int L[N];
int R[N];
int clo;

int to[N];
int vis[N];
ll ww[N];

int uu,vv;
ll cost;
int huan;
int idd;

void init()
{
    tot=;
    memset(head,-,sizeof(head));
    memset(vis,,sizeof(vis));
    memset(inde,-,sizeof(inde));
    memset(pos,-,sizeof(pos));
    clo=; huan=; idd=; dfn=;  /// dfn竟然没清零 MMP
}

void add(int u,int v,ll w,int id)
{
    edge[++tot].u=u; edge[tot].v=v; edge[tot].id=id; edge[tot].w=w; edge[tot].f=;
    edge[tot].next=head[u]; head[u]=tot;
}

void dfs1(int u,int fa)
{
    if(vis[u]){
        uu=fa; vv=u; huan=; return ;
    }
    vis[u]=;
    for(int i=head[u];i!=-;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa) continue;
        dfs1(v,u);
    }
}

void dfs2(int u,int deep) /// dfs序
{
    //cout<<" u "<<u<<" deep "<<deep<<endl;
    dfns[dfn]=u; dep[dfn]=deep; pos[u]=dfn++;
    L[u]=++clo;
    inde[u]=L[u]; /// 记录u在线段树中的位置
    for(int i=head[u];i!=-;i=edge[i].next){
        if(edge[i].f) continue;  /// 如果是标记的边跳过
        int v=edge[i].v;
        if(pos[v]==-){
            to[edge[i].id]=v; /// 表示这条边指向哪个点？
            dfs2(v,deep+);
            dfns[dfn]=u; dep[dfn++]=deep;
        }
    }
    R[u]=clo;
}

void init_RMQ(int n)  /// dfn
{
    for(int i=;i<=n;++i) anc[i][]=i;
    for(int j=;(<<j)<=n;++j)
        for(int i=;i+(<<j)-<=n;++i){
            if(dep[anc[i][j-]]<dep[anc[i+(<<(j-))][j-]]) anc[i][j]=anc[i][j-];
            else anc[i][j]=anc[i+(<<(j-))][j-];
        }
}

inline int RMQ(int L,int R)
{
    int k=;
    while(<<(k+)<=R-L+) ++k;
    if(dep[anc[L][k]]<dep[anc[R-(<<k)+][k]]) return anc[L][k];
    return anc[R-(<<k)+][k];
}

inline int LCA(int u,int v)
{
    if(pos[u]>pos[v]) return dfns[RMQ(pos[v],pos[u])];
    return dfns[RMQ(pos[u],pos[v])];
}

void push_up(int i)
{
    tr[i].w=tr[lson].w+tr[rson].w;
}

void push_down(int i)
{
    if(tr[i].lz){ /// 查询只有点查询，所以不必更新区间点的sum
        ll &lz=tr[i].lz;
        tr[lson].lz+=lz; tr[rson].lz+=lz;
        tr[lson].w+=lz;  tr[rson].w+=lz;
        lz=;
    }
}

void build(int i,int l,int r)
{
    tr[i].l=l; tr[i].r=r; tr[i].w=; tr[i].lz=;
    if(l==r) return ;
    int mid=(l+r)>>;
    build(lson,l,mid);
    build(rson,mid+,r);
}

void update(int i,int l,int r,ll w)
{
    if(tr[i].l==l&&tr[i].r==r){
        tr[i].lz+=w; tr[i].w+=w;
        return ;
    }
    push_down(i);
    int mid=(tr[i].l+tr[i].r)>>;
    if(r<=mid) update(lson,l,r,w);
    else if(l>mid ) update(rson,l,r,w);
    else{
        update(lson,l,mid,w);
        update(rson,mid+,r,w);
    }
    push_up(i);
}

ll query(int i,int aim)
{
    if(tr[i].l==tr[i].r&&tr[i].l==aim){
        return tr[i].w;
    }
    push_down(i);
    int mid=(tr[i].l+tr[i].r)>>;
    if(aim<=mid) return query(lson,aim);
    else return query(rson,aim);
}

ll getans(int u,int v)
{
    int lca=LCA(u,v);
    ll sum1,sum2,sum3;
    sum1=query(,L[u]); sum2=query(,L[v]);
    sum3=query(,L[lca]);
    return sum1+sum2-sum3*;
}

int main()
{
    int T;
    int u,v,op;
    ll w;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&q);
        init();
        for(int i=;i<=n;i++){
            scanf("%d %d %lld",&u,&v,&w);
            add(u,v,w,i);
            add(v,u,w,i);
            ww[i]=w;
        }

        dfs1(,-);/// 第一遍dfs 先找到环中的任意一条边
        for(int i=;i<=tot;i++){  /// 给边打上标记
            if((edge[i].u==uu&&edge[i].v==vv)||(edge[i].u==vv&&edge[i].v==uu)){
                edge[i].f=;
                idd=edge[i].id;
                cost=edge[i].w;
            }
        }
        dfs2(,);
        /*cout<<"dfn "<<dfn<<endl;
        cout<<uu<<" *** "<<vv<<endl;
        for(int i=1;i<=n;i++){
            cout<<"l "<<L[i]<<" r "<<R[i]<<endl;
        }
        */
        init_RMQ(dfn);

        build(,,n);  /// 以dfs的遍历出的 L,R 建树  那么接下来就是一个区间更新，单点查询的问题了
        for(int i=;i<=n;i++){
            if(i==idd) continue;
            u=to[i];
            update(,L[u],R[u],ww[i]);
        }
        /*
        for(int i=1;i<=n;i++){
            ll tmp=query(1,L[i]);
            cout<<" dis "<<tmp<<endl;
        }
        */

        while(q--)
        {
            scanf("%d",&op);
            if(op==){
                scanf("%d %lld",&u,&w);
                if(u==idd){ /// 如果是标记的环中的边，那么就没必要更新线段树
                    ww[u]=w;
                }
                else{
                    int tmp=to[u];
                    //cout<<"tmp "<<tmp<<" L "<<L[tmp]<<" R "<<R[tmp]<<" w "<<ww[u]<<endl;
                    update(,L[tmp],R[tmp],-ww[u]);
                    ww[u]=w;
                    update(,L[tmp],R[tmp],ww[u]);
                }
            }
            else{
                scanf("%d %d",&u,&v);
                ll ans=getans(u,v);
                ans=min(ans,getans(uu,u)+getans(vv,v)+cost); /// 经过标记的路的两个不同的方向。
                ans=min(ans,getans(uu,v)+getans(vv,u)+cost);
                printf("%lld\n",ans);
            }
        }

    }
    return ;
}