Bzoj 3694: 最短路 树链剖分

3694: 最短路

Time Limit: 5 Sec  Memory Limit: 256 MB
Submit: 67  Solved: 34
[Submit][Status][Discuss]

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

 

Source

题解：

首先，先处理出最短路树中每个点i距源点1的最短距离dis[i]。

 因为要求不经过最短路树的最后一条边，所以要到一个点，必须要从和这个点在同一个环中的另外一边绕过去。

例如：设我们要到u点，我们还有不在最短路树上的两个点x，y。t为LCA(x,y)。假如u点在y到t的路径上，我们既然不能从1经过t到u，那我们只有从1 -> t -> x -> y ->u。这样我们可以用dis[x]+val[x][y]+dis[y]-dis[u]来更新ans。因为dis[u]是不变的，所以我们可以最后去减去dis[u]。之前只用维护dis[x]+val[x][y]+dis[y]即可。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 4010
#define MAXM 100010
#define INF 1e9
struct node
{
    int begin,end,value,next;
}edge[MAXN*2];
struct NODE
{
    int left,right,mn,tag;
}tree[MAXN*5];
int cnt,Head[MAXN],n,size[MAXN],deep[MAXN],P[MAXN][12],dis[MAXN],pos[MAXN],belong[MAXN],s1[MAXM],s2[MAXM],s3[MAXM],SIZE;
bool vis[MAXN];
void addedge(int bb,int ee,int vv)
{
    edge[++cnt].begin=bb;edge[cnt].end=ee;edge[cnt].value=vv;edge[cnt].next=Head[bb];Head[bb]=cnt;
}
void addedge1(int bb,int ee,int vv)
{
    addedge(bb,ee,vv);addedge(ee,bb,vv);
}
int read()
{
    int s=0,fh=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')fh=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){s=s*10+(ch-'0');ch=getchar();}
    return s*fh;
}
void dfs1(int u)
{
    int i,v;
    size[u]=1;vis[u]=true;
    for(i=Head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].end;
        if(vis[v]==false)
        {
            deep[v]=deep[u]+1;
            dis[v]=dis[u]+edge[i].value;
            P[v][0]=u;
            dfs1(v);
            size[u]+=size[v];
        }
    }
}
void Ycl()
{
    int i,j;
    for(j=1;(1<<j)<=n;j++)
    {
        for(i=1;i<=n;i++)
        {
            if(P[i][j-1]!=-1)P[i][j]=P[P[i][j-1]][j-1];
        }
    }
}
void dfs2(int u,int chain)
{
    int k=0,i,v;
    pos[u]=++SIZE;belong[u]=chain;
    for(i=Head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].end;
        if(deep[v]>deep[u]&&size[v]>size[k])k=v;
    }
    if(k==0)return;
    dfs2(k,chain);
    for(i=Head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].end;
        if(deep[v]>deep[u]&&v!=k)dfs2(v,v);
    }
}
int LCA(int x,int y)
{
    int i,j;
    if(deep[x]<deep[y])swap(x,y);
    for(i=0;(1<<i)<=deep[x];i++);i--;
    for(j=i;j>=0;j--)if(deep[x]-(1<<j)>=deep[y])x=P[x][j];
    if(x==y)return x;
    for(j=i;j>=0;j--)
    {
        if(P[x][j]!=-1&&P[x][j]!=P[y][j])
        {
            x=P[x][j];
            y=P[y][j];
        }
    }
    return P[x][0];
}
void Build(int k,int l,int r)
{
    tree[k].left=l;tree[k].right=r;tree[k].tag=INF;
    if(l==r){tree[k].mn=INF;return;}
    int mid=(l+r)/2;
    Build(k*2,l,mid);
    Build(k*2+1,mid+1,r);
}
void Pushup(int k)
{
    int l=k*2,r=k*2+1;
    tree[k].mn=min(tree[l].mn,tree[r].mn);
}
void Pushdown(int k)
{
    int l=k*2,r=k*2+1;
    if(tree[k].tag!=INF)
    {
        tree[l].tag=min(tree[l].tag,tree[k].tag);
        tree[r].tag=min(tree[r].tag,tree[k].tag);
        tree[l].mn=min(tree[l].mn,tree[k].tag);
        tree[r].mn=min(tree[r].mn,tree[k].tag);
        tree[k].tag=INF;
    }
}
void Change(int k,int l,int r,int C)
{
    if(l<=tree[k].left&&tree[k].right<=r){tree[k].tag=min(tree[k].tag,C);tree[k].mn=min(tree[k].mn,C);return;}
    Pushdown(k);
    int mid=(tree[k].left+tree[k].right)/2;
    if(r<=mid)Change(k*2,l,r,C);
    else if(l>mid)Change(k*2+1,l,r,C);
    else {Change(k*2,l,mid,C);Change(k*2+1,mid+1,r,C);}
    Pushup(k);
}
void Solve_change(int x,int f,int C)
{
    while(belong[x]!=belong[f])
    {
        Change(1,pos[belong[x]],pos[x],C);
        x=P[belong[x]][0];
    }
    if(x!=f)Change(1,pos[f]+1,pos[x],C);
}
int Query(int k,int l,int r)
{
    if(l<=tree[k].left&&tree[k].right<=r)return tree[k].mn;
    Pushdown(k);
    int mid=(tree[k].left+tree[k].right)/2;
    if(r<=mid)return Query(k*2,l,r);
    else if(l>mid)return Query(k*2+1,l,r);
    else return min(Query(k*2,l,mid),Query(k*2+1,mid+1,r));
}
int Solve_query(int x,int f)
{
    int MN=INF;
    while(belong[x]!=belong[f])
    {
        MN=min(MN,Query(1,pos[belong[x]],pos[x]));
        x=P[belong[x]][0];
    }
    if(x!=f)MN=min(MN,Query(1,pos[f]+1,pos[x]));
    return MN;
}
int ask(int k,int lr)
{
    if(tree[k].left==tree[k].right)return tree[k].mn;
    Pushdown(k);
    int mid=(tree[k].left+tree[k].right)/2;
    if(lr<=mid)return ask(k*2,lr);
    else return ask(k*2+1,lr);
}
int main()
{
    int m,tot,i,a,b,l,t,lca,C;
    n=read();m=read();
    tot=0;
    memset(Head,-1,sizeof(Head));cnt=1;
    for(i=1;i<=m;i++)
    {
        a=read();b=read();l=read();t=read();
        if(t==0)
        {
            s1[++tot]=a;s2[tot]=b;s3[tot]=l;
        }
        else addedge1(a,b,l);
    }
    memset(P,-1,sizeof(P));SIZE=0;
    dfs1(1);Ycl();
    dfs2(1,1);
    Build(1,1,n);
    //for(i=1;i<=n;i++)Change(1,pos[i],pos[i],dis[i]);
    for(i=1;i<=tot;i++)
    {
        lca=LCA(s1[i],s2[i]);
        C=dis[s1[i]]+dis[s2[i]]+s3[i];
        Solve_change(s1[i],lca,C);
        Solve_change(s2[i],lca,C);
    }
    for(i=2;i<=n;i++)
    {
        //t=Solve_query(i,1);
        t=Query(1,pos[i],pos[i]);
        //t=ask(1,pos[i]);
        if(t==INF)printf("-1 ");
        else printf("%d ",t-dis[i]);
    }
    return 0;
}