[模拟训练][Codeforces 838B Diverging Directions]graph

题目描述

传送门

【描述】

给你一个图，一共有N个点，2*N-2条有向边。
边目录按两部分给出
1、 开始的n-1条边描述了一颗以1号点为根的生成树，即每个点都可以由1号点到达。
2、 接下来的N-1条边，一定是从i 到1（2<=i<=N）的有向边，保证每个点都能到1 号点。
有q次询问：
1 x w :表示将第x条边的边权修改为w
2 u v ：询问u到v的最短距离

【输入格式】

第一行是2个整数N,Q，表示一共N个点Q次询问
接下来是N-1行，每行3个整数U,V,W，表示了前N-1条边,u到v的有向边
接下来N-1行，每行3个整数U,V,W，描述了每个点到1号点的边，V==1
接下来是Q行，表示Q次修改与询问

【输出格式】

若干行，每行回答一次询问

【输入样例】

5 9
1 3 1
3 2 2
1 4 3
3 5 4
5 1 5
3 1 6
2 1 7
4 1 8
2 1 1
2 1 3
2 3 5
2 5 2
1 1 100
2 1 3
1 8 30
2 4 2
2 2 4

【输出样例】

0
1
4
8
100
132
10

【数据规模】

20%数据 没有修改
30%数据 2<=N,Q<=1000 (其中有10%数据没有修改)
100%数据2<=N,Q<=100 000, 1 <=边权 <= 1000,000

---

分析

对于询问（u,v），分2中情况：
1．u是v的祖先，所以dis[u]-dis[v] 。
2、u 不是 v 的祖先节点，则 u 不得不先到达 1 号点再到达 v 点。此时 u 必
须先找到回到 1 的最短路（一定是自身直接回到 1 或通过以 u 为根子树的某点回到 1 ）。而 1 号点到 v 点的路径唯一。

我们有dfs序 维护子树 1->i->1 的值dist，每个点记录第一次的dfs序st[i]，
子树结束的ed[i]，在对于第2种情况 是min{dist[i]}-dis[u] + dis[v]
其中i是u的子树，dis[u]表示从1到u的值
考虑修改：
当边u->v修改为w，则 st[v]…ed[v] 增加w- w’，w’表示u->v原来的值。
同时，当边u->1修改为w：则 st[u]..st[u]增加w-w’

*思路

由于加入、询问的次数和节点数的规模非常大，因而考虑用线段树来维护。
再来对这个特殊的“图”，进行分析：
首先它是一棵树，因而从根节点到每个节点的路径唯一。
其次，它是有向图，且每个节点都可以直接到根节点，所以考虑从u到v的路径的几种情况（见分析）。
这时便发现了直接线段树维护dist[1->i]时的处理很麻烦，于是开拓一种新的思路，维护子树 1->i->1 的值dist，这时便大大简化了维护的方便性。
借鉴树链剖分中对树的处理方式

---

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
#define N 101000
#define lc (x<<1)
#define rc (x<<1|1)
#define ll long long
int n,q;
ll dis[N];
int siz[N],seg[N],dep[N];
int fa[N][25],ret[N],rev[N],a[N*4],b[N*4],c[N*4];
struct Node{
    int u,v,w,nxt;
}e[N<<1];
struct NODE{
    ll l,r,sum,add;
}rt[N*4];
int cnt=0,first[N];
void add(int u,int v,int w){
    e[++cnt].v=v;e[cnt].w=w;
    e[cnt].nxt=first[u];first[u]=cnt;
}
void pushup(int x){
    rt[x].sum=min(rt[lc].sum,rt[rc].sum);
}
void pushnow(int x,ll v){
    rt[x].sum+=v;
}
void pushdown(int x){
    if(rt[x].add){
        rt[lc].add+=rt[x].add;
        rt[rc].add+=rt[x].add;
        pushnow(lc,rt[x].add);
        pushnow(rc,rt[x].add);
        rt[x].add=0;
    }
}
void build(int x,int l,int r){
    rt[x].l=l;rt[x].r=r;
    rt[x].add=0;
    if(l==r){
        rt[x].sum=dis[rev[l]];
        return ;
    }
    int mid=(l+r)>>1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    pushup(x);
}
ll query(int x,int l,int r){
    if(rt[x].l>=l&&rt[x].r<=r) return rt[x].sum;
    pushdown(x);
    ll ans=0x7fffffff,mid=(rt[x].l+rt[x].r)>>1;
    if(mid>=l) ans=min(ans,query(lc,l,r));
    if(mid<r) ans=min(ans,query(rc,l,r));
    return ans;
}
void update(int x,int l,int r,ll v){
    if(rt[x].l>=l&&rt[x].r<=r){
        rt[x].add+=v;
        pushnow(x,v);
        return ;
    }
    pushdown(x);
    int mid=(rt[x].l+rt[x].r)>>1;
    if(mid>=l) update(lc,l,r,v);
    if(mid<r) update(rc,l,r,v);
    pushup(x);
}
void dfs(int u,int fat){
    for(int i=1;i<=20;i++)
        fa[u][i]=fa[fa[u][i-1]][i-1];
    siz[u]=1;
    seg[u]=++seg[0];
    rev[seg[0]]=u;
    dep[u]=dep[fat]+1;
    for(int i=first[u];i;i=e[i].nxt){
        int v=e[i].v,w=e[i].w;
        if(v==fat) continue;
        if(!dep[v]){
            dis[v]=dis[u]+w;
            fa[v][0]=u;
            dfs(v,u);
            siz[u]+=siz[v];
        }
    }
}
int lca(int x,int y){
    if(dep[x]<dep[y]) swap(x,y);
    int t=dep[x]-dep[y];
    for(int i=0;i<=20;i++)
        if(t&(1<<i)) x=fa[x][i];
    if(x==y) return x;
    for(int i=20;i>=0;i--)
        if(fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
int main(){
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n*2-2;i++){
        scanf("%d%d%d",&a[i],&b[i],&c[i]);
        if(i>=n) ret[a[i]]=c[i];
        else add(a[i],b[i],c[i]);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++) dis[i]+=ret[i];
    build(1,1,n);
    int x,y,z;
    while(q--){
        scanf("%d%d%d",&x,&y,&z);
        if(x==1){
            int k;
            if(y<=n-1) k=b[y],update(1,seg[k],seg[k]+siz[k]-1,z-c[y]),c[y]=z;
            else k=a[y],update(1,seg[k],seg[k],z-ret[k]),ret[k]=z;
        }
        else{
            ll ans,du,dv;
            ans=query(1,seg[y],seg[y]+siz[y]-1)-query(1,seg[y],seg[y])+ret[y];
            dv=query(1,seg[z],seg[z])-ret[z];
            ans+=dv;
            if(lca(y,z)==y){
                du=query(1,seg[y],seg[y])-ret[y];
                dv=query(1,seg[z],seg[z])-ret[z];
                ans=min(ans,dv-du);
            }
            printf("%lld\n",ans);
        }
    }
    return 0;
}