[BZOJ1576] [BZOJ3694] [USACO2009Jan] 安全路径(最短路径+树链剖分)

[BZOJ1576] [BZOJ3694] [USACO2009Jan] 安全路径(最短路径+树链剖分)

题面

BZOJ1576和BZOJ3694几乎一模一样，只是BZOJ3694直接给出了最短路树

给出一个n个点m条边的无向图，n个点的编号从1~n，定义源点为1。定义最短路树如下：从源点1经过边集T到任意一点i有且仅有一条路径，且这条路径是整个图1到i的最短路径，边集T构成最短路树。 给出最短路树，求对于除了源点1外的每个点i，求最短路，要求不经过给出的最短路树上的1到i的路径的最后一条边。

分析

求最短路树的过程略。

删掉了树上一个点i到父亲的边(即1到i路径上最后一条边)后,我们必须经过非树边才能到达i。贪心考虑，只经过一条非树边显然是最优的。

对于一条非树边(x,y) [图中蓝色虚线],它在树上对应一条路径(x,y).对于这条路径上的点z,在z往它父亲的边被删除后，我们可以走这样的路径1->x->y->z。1->x的距离显然为\(dist(x)\),x->y的距离为\(len(x,y)\),y->z的距离[绿线]是\(dist[y]-dist[z]\).因此到z的路径长度就是\(dist[x]+dist[y]+len(x,y)-dist[z]\)

注意到当z=lca(x,y)时，是不能从1->x->y->z的，因为z到父亲的边被删除后无法到达x.

那么方法就很明确了。对于每条边，我们用\(dist[x]+dist[y]+len(x,y)\)去更新路径(x,y)(不包含lca)上的点，每个点\(z\)求出\(min(dist[x]+dist[y]+len(x,y))\)。最后输出\(min(dist[x]+dist[y]+len(x,y))-dist[z]\)即可。路径修改，单点查询，可以用树链剖分解决。时间复杂度\(O(n \log^2 n)\)

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
#define maxn 4000
#define maxm 100000 
#define INF 0x3f3f3f3f3f3f3f3f
using namespace std;
typedef long long ll;

int n,m;
struct edge{
    int from;
    int to;
    int next;
    int len;
    int type;
}E[maxm*2+5];
int head[maxn+5];
int esz=1;
void add_edge(int u,int v,int w,int t){
    esz++;
    E[esz].from=u;
    E[esz].to=v;
    E[esz].next=head[u];
    E[esz].len=w;
    E[esz].type=t;
    head[u]=esz;
}

struct node{
    int id;
    ll dist;
    node(){
        
    }
    node(int _id,ll _dist){
        id=_id;
        dist=_dist;
    }
    friend bool operator < (node p,node q){
        return p.dist>q.dist;
    }
};
bool vis[maxn+5];
ll dist[maxn+5];
void dijkstra(int s){
    priority_queue<node>q;
    memset(vis,0,sizeof(vis));
    memset(dist,0x3f,sizeof(dist));
    dist[s]=0;
    q.push(node(s,0));
    while(!q.empty()){
        int x=q.top().id;
        q.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=head[x];i;i=E[i].next){
            int y=E[i].to;
            if(dist[y]>dist[x]+E[i].len){
                dist[y]=dist[x]+E[i].len;
                if(!vis[y]) q.push(node(y,dist[y]));
            }
        }
    }
}

vector<int>T[maxn+5];
int deep[maxn+5];
int sz[maxn+5];
int fa[maxn+5];
int son[maxn+5];
int top[maxn+5];
int dfn[maxn+5];
int tim;
void dfs1(int x,int f){
    sz[x]=1;
    fa[x]=f;
    deep[x]=deep[f]+1;
    for(int i=0;i<T[x].size();i++){
        int y=T[x][i];
        if(y!=f){
            dfs1(y,x);
            sz[x]+=sz[y];
            if(sz[y]>sz[son[x]]) son[x]=y;
        }
    }
}
void dfs2(int x,int t){
    top[x]=t;
    dfn[x]=++tim;
    if(son[x]) dfs2(son[x],t);
    for(int i=0;i<T[x].size();i++){
        int y=T[x][i];
        if(y!=fa[x]&&y!=son[x]){
            dfs2(y,y);
        }
    }
}

struct segment_tree{
    struct node{
        int l;
        int r;
        ll val;
        ll mark;
    }tree[maxn*4+5];
    void push_up(int pos){
        tree[pos].val=max(tree[pos<<1].val,tree[pos<<1|1].val);
    }
    void build(int l,int r,int pos){
        tree[pos].l=l;
        tree[pos].r=r;
        tree[pos].mark=INF;
        tree[pos].val=INF;
        if(l==r) return;
        int mid=(l+r)>>1;
        build(l,mid,pos<<1);
        build(mid+1,r,pos<<1|1);
        push_up(pos);
    }
    void push_down(int pos){
        if(tree[pos].mark!=INF){
            tree[pos<<1].mark=min(tree[pos<<1].mark,tree[pos].mark);
            tree[pos<<1|1].mark=min(tree[pos<<1|1].mark,tree[pos].mark);
            tree[pos<<1].val=min(tree[pos<<1].val,tree[pos].mark);
            tree[pos<<1|1].val=min(tree[pos<<1|1].val,tree[pos].mark);
            tree[pos].mark=INF;
        }
    } 
    void update(int L,int R,ll uval,int pos){
        if(L<=tree[pos].l&&R>=tree[pos].r){
            tree[pos].mark=min(tree[pos].mark,uval);
            tree[pos].val=min(tree[pos].val,uval);
            return;
        }
        push_down(pos);
        int mid=(tree[pos].l+tree[pos].r)>>1;
        if(L<=mid) update(L,R,uval,pos<<1);
        if(R>mid) update(L,R,uval,pos<<1|1);
        push_up(pos);
    }
    ll query(int L,int R,int pos){
        if(L<=tree[pos].l&&R>=tree[pos].r){
            return tree[pos].val;
        }
        push_down(pos);
        int mid=(tree[pos].l+tree[pos].r)>>1;
        ll ans=INF;
        if(L<=mid) ans=min(ans,query(L,R,pos<<1));
        if(R>mid) ans=min(ans,query(L,R,pos<<1|1));
        return ans;
    }
}S;

int lca(int x,int y){
    while(top[x]!=top[y]){
        if(deep[top[x]]<deep[top[y]]) swap(x,y);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y]) swap(x,y);
    return x;
}
void update(int x,int y,ll val){
//  printf("update %d->%d val=%d\n",x,y,val);
    int tx=top[x],ty=top[y];
    while(tx!=ty){
        if(deep[tx]<deep[ty]){
            swap(tx,ty);
            swap(x,y);
        }
        S.update(dfn[tx],dfn[x],val,1);
        x=fa[tx];
        tx=top[x];
    }
    if(deep[x]>deep[y]) swap(x,y);
    S.update(dfn[son[x]],dfn[y],val,1);//注意是son[x]而不是x，因为不包含lca
}

int main(){
    int u,v,w,t;
    scanf("%d %d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%d %d %d %d",&u,&v,&w,&t);
        add_edge(u,v,w,t);
        add_edge(v,u,w,t);
        if(t==1){
            T[u].push_back(v);
            T[v].push_back(u);
        }
    }
    dijkstra(1);
    dfs1(1,0);
    dfs2(1,0);
    S.build(1,n,1); 
    for(int i=2;i<=esz;i+=2){
        if(E[i].type==0){
            int x=E[i].from;
            int y=E[i].to;
            update(x,y,dist[x]+dist[y]+E[i].len);
        }
    }
    for(int i=2;i<=n;i++){
        ll ans=S.query(dfn[i],dfn[i],1);
        if(ans==INF) printf("-1 ");
        else printf("%lld ",ans-dist[i]);
    }
}