bzoj3694: 最短路【树链剖分+线段树&&最短路】

Description

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

Input

第一行包含两个数n和m，表示图中有n个点和m条边。
接下来m行，每行有四个数ai，bi，li，ti，表示图中第i条边连接ai和bi权值为li，ti为1表示这条边是最短路树上的边，ti为0表示不是最短路树上的边。

Output

输出n-1个数，第i个数表示从1到i+1的要求的最短路。无法到达输出-1。

Sample Input

5 9

3 1 3 1

1 4 2 1

2 1 6 0

2 3 4 0

5 2 3 0

3 2 2 1

5 3 1 1

3 5 2 0

4 5 4 0

Sample Output

6 7 8 5

HINT

对于100%的数据，n≤4000，m≤100000，1≤li≤100000

解题思路；

如果1不经过树上最后一条边到达i，肯定是绕过一个非树边和过i的树边组成的环的另一侧过来，且肯定是只经过一条非树边最优，所以我们主要要计算一条非树边(u,v)的贡献。

设u,v的lca是t，那么根据上面的分析，该非树边会使u,v及以上，t以下(不包括t)的点多一条路径，且该路径长度变为dis[u]+dis[v]+w(u,v)-dis[x]，所以只需对每个x找最小的dis[u]+dis[v]-w(u,v)即可，而一条非树边会改变树上一条链(u,v)的值，树链剖分+线段树即可。

#include<bits/stdc++.h>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c!='-')&&(c<'0'||c>'9');c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=4005,M=100005,INF=0x3f3f3f3f;
int n,m,cnt,tot,idx;
int first[N],nxt[N<<1],to[N<<1],w[N<<1];
int fa[N],dep[N],size[N],son[N],top[N],pos[N],dis[N];
int mn[N<<2],tag[N<<2];
struct node{int x,y,val;}bian[M];

void add(int x,int y,int z)
{
    nxt[++tot]=first[x],first[x]=tot,to[tot]=y,w[tot]=z;
}

void dfs1(int u)
{
    size[u]=1;
    for(int e=first[u];e;e=nxt[e])
    {
        int v=to[e];
        if(v==fa[u])continue;
        fa[v]=u,dep[v]=dep[u]+1,dis[v]=dis[u]+w[e];
        dfs1(v),size[u]+=size[v];
        if(size[v]>size[son[u]])son[u]=v;
    }
}

void dfs2(int u,int f)
{
    pos[u]=++idx,top[u]=f;
    if(son[u])dfs2(son[u],f);
    for(int e=first[u];e;e=nxt[e])
    {
        int v=to[e];
        if(v==fa[u]||v==son[u])continue;
        dfs2(v,v);
    }
}

void build(int k,int l,int r)
{
    tag[k]=mn[k]=INF;
    if(l==r)return;
    int mid=l+r>>1;
    build(k<<1,l,mid),build(k<<1|1,mid+1,r);
}

void pushdown(int k)
{
    mn[k<<1]=min(mn[k<<1],tag[k]);
    mn[k<<1|1]=min(mn[k<<1|1],tag[k]);
    tag[k<<1]=min(tag[k<<1],tag[k]);
    tag[k<<1|1]=min(tag[k<<1|1],tag[k]);
    tag[k]=INF;
}

void modify(int k,int l,int r,int x,int y,int v)
{
    if(l>r||x>y)return;
    if(l==x&&r==y)
    {
        tag[k]=min(tag[k],v),mn[k]=min(mn[k],v);
        return;
    }
    if(tag[k]!=INF)pushdown(k);
    int mid=l+r>>1;
    if(y<=mid)modify(k<<1,l,mid,x,y,v);
    else if(x>mid)modify(k<<1|1,mid+1,r,x,y,v);
    else modify(k<<1,l,mid,x,mid,v),modify(k<<1|1,mid+1,r,mid+1,y,v);
    mn[k]=min(mn[k<<1],mn[k<<1|1]);
}

int query(int k,int l,int r,int p)
{
    if(l==r)return mn[k];
    if(tag[k]!=INF)pushdown(k);
    int mid=l+r>>1;
    if(p<=mid)return query(k<<1,l,mid,p);
    else return query(k<<1|1,mid+1,r,p);
}

void Modify(int x,int y,int v)
{
    while(top[x]!=top[y])
    {
        if(dep[top[x]]<dep[top[y]])swap(x,y);
        modify(1,1,n,pos[top[x]],pos[x],v);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])swap(x,y);
    modify(1,1,n,pos[x]+1,pos[y],v);
}

int main()
{
    //freopen("lx.in","r",stdin);
    int x,y,z,op;
    n=getint(),m=getint();
    while(m--)
    {
        x=getint(),y=getint(),z=getint(),op=getint();
        if(op)add(x,y,z),add(y,x,z);
        else bian[++cnt]=(node){x,y,z};
    }
    dfs1(1),dfs2(1,1),build(1,1,n);
    for(int i=1;i<=cnt;i++)
    {
        int x=bian[i].x,y=bian[i].y,val=dis[x]+dis[y]+bian[i].val;
        Modify(x,y,val);
    }
    for(int i=2;i<=n;i++)
    {
        int val=query(1,1,n,pos[i]);
        val==INF?printf("-1 "):printf("%d ",val-dis[i]);
    }
    return 0;
}