[BZOJ]4699: 树上的最短路 特殊技巧的最短路

Description

下水道的主干路由n个节点和n-l条边组成，每条边有一个通过它所需的时间Ti。换言之，这是一棵n个节点的带权树。现在，要用最快的速度赶往目标节点k。下水道有一些塌陷，这导致主干路的某一段路径可以通过该塌陷到另一条路径。对于一个塌陷，我们用(L1，R1，L2，R2，c)来描述，即对于主干路上L1到R1路径上的任意节点x，L2到R2路径上的任意节点y，都可以在c的时间内从x走到y。因为不知道自己所在的到底是哪个节点，所以要求出每个节点到目标节点K的最短距离。注意边是单向的

Solution

直接线段树优化建图显然不行，考虑发现一些性质。首先可以把一开始的树边也看作塌陷。显然对于一个塌陷，只有在dijkstra过程中第一个访问到的点才是有用的，也就是一个点用某条边更新完另一些点后这条边就废了，但是这样仍然不行，因为一个点可能被更新多次。考虑如何让每个点只被更新一次，我们可以把边也放入堆中，权值为最早到达这条边的点最短路+边权。每次取出堆顶，如果取出的是点，就用它更新边，如果取出的是边，就用来更新点。这样可以保证每条边和点都只被更新一次。如何实现呢？维护点可以用并查集，维护边可以用一个线段树+set。

Code

#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define pa pair<int,int>
const int Maxn=250010,Maxm=100010;
const int inf=2147483647;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
    return x*f;
}
int n,m,k,fa[Maxn][18],dep[Maxn],in[Maxn],out[Maxn],dfn=0;
vector<int>edge[Maxn];
void dfs(int x,int ff)
{
    fa[x][0]=ff,dep[x]=dep[ff]+1;in[x]=++dfn;
    for(int i=1;(1<<i)<=dep[x];i++)fa[x][i]=fa[fa[x][i-1]][i-1];
    for(int i=0;i<edge[x].size();i++)
    {
        int y=edge[x][i];
        if(y==ff)continue;
        dfs(y,x);
    }out[x]=dfn;
}
int LCA(int x,int y)
{
    if(dep[x]<dep[y])swap(x,y);
    for(int i=17;i>=0;i--)
    if((1<<i)<=dep[x]-dep[y])x=fa[x][i];
    if(x==y)return x;
    for(int i=17;i>=0;i--)
    if((1<<i)<=dep[x]&&fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
struct Edge
{
    int l1,r1,l2,r2,c,p1,p2;bool del;
    Edge(int _l1=0,int _r1=0,int _l2=0,int _r2=0,int _c=0)
    {l1=_l1,r1=_r1,l2=_l2,r2=_r2,c=_c;}
}e[(Maxn<<1)+Maxm];
int rt[Maxn];
int findrt(int x){return((rt[x]==x)?x:rt[x]=findrt(rt[x]));}
struct Seg{int l,r,lc,rc,mn,Fa;}tr[Maxn<<1];
int tot=0;
struct P
{
    int dep,id,o;
    P(int _dep,int _id,int _o)
    {dep=_dep,id=_id,o=_o;}
};
bool operator<(P a,P b)
{
    if(a.dep!=b.dep)return a.dep<b.dep;
    if(a.id!=b.id)return a.id<b.id;
}
set<P>S[Maxn<<1];
void up(int x)
{
    int lc=tr[x].lc,rc=tr[x].rc;
    tr[x].mn=min(tr[lc].mn,tr[rc].mn);
}
void build(int l,int r)
{
    int x=++tot;
    tr[x].l=l;tr[x].r=r;tr[x].mn=inf;
    if(l==r)return;
    int mid=l+r>>1;
    tr[x].lc=tot+1,build(l,mid);
    tr[x].rc=tot+1,build(mid+1,r);
    tr[tr[x].lc].Fa=tr[tr[x].rc].Fa=x;
}
void Insert(int x,int p,int o,int id)
{
    if(tr[x].l==tr[x].r)
    {
        S[x].insert(P(dep[e[id].p1],id,o));
        tr[x].mn=(*S[x].begin()).dep;
        return;
    }
    int mid=tr[x].l+tr[x].r>>1,lc=tr[x].lc,rc=tr[x].rc;
    if(p<=mid)Insert(lc,p,o,id);
    else Insert(rc,p,o,id);
    up(x);
}
int u[100],lu;
void get(int x,int l,int r)
{
    if(tr[x].l==l&&tr[x].r==r){u[++lu]=x;return;}
    int mid=tr[x].l+tr[x].r>>1,lc=tr[x].lc,rc=tr[x].rc;
    if(r<=mid)get(lc,l,r);
    else if(l>mid)get(rc,l,r);
    else get(lc,l,mid),get(rc,mid+1,r);
}
int ID;
void go(int x,int dep)
{
    if(tr[x].l==tr[x].r)
    {
        ID=-1;
        while(!S[x].empty())
        {
            P t=(*S[x].begin());
            if(e[t.id].del)S[x].erase(t);
            else if(t.dep>=dep)break;
            else
            {
                ID=t.id;
                S[x].erase(t);
                break;
            }
        }
        if(S[x].empty())tr[x].mn=inf;
        else tr[x].mn=(*S[x].begin()).dep;
        while(x!=1){x=tr[x].Fa;up(x);}
        return;
    }
    int lc=tr[x].lc,rc=tr[x].rc;
    if(tr[lc].mn<dep)go(lc,dep);
    else go(rc,dep);
}
LL f[Maxn],g[(Maxn<<1)+Maxm];
struct Node
{
    int x,type;LL t;
    Node(int _x,int _type,LL _t){x=_x,type=_type,t=_t;}
};
bool operator<(Node a,Node b){return a.t>b.t;}
priority_queue<Node>q;
vector<int>H[Maxn];
void dijkstra()
{
    memset(f,63,sizeof(f));f[k]=0;rt[k]=fa[k][0];
    memset(g,63,sizeof(g));
    q.push(Node(k,0,0));
    while(!q.empty())
    {
        Node t=q.top();q.pop();
        int p=t.x;
        if(t.type==0)
        {
            for(int i=0;i<H[p].size();i++)
            {
                int tmp=H[p][i];
                if(e[tmp].del)continue;
                e[tmp].del=true;
                g[tmp]=f[p]+e[tmp].c;
                q.push(Node(tmp,1,g[tmp]));
            }
            lu=0;get(1,in[p],out[p]);
            for(int i=1;i<=lu;i++)
            {
                int v=u[i];
                while(tr[v].mn<dep[p])
                {
                    go(v,dep[p]);
                    if(ID!=-1)
                    {
                        e[ID].del=true;
                        g[ID]=f[p]+e[ID].c;
                        q.push(Node(ID,1,g[ID]));
                    }
                    else if(tr[v].mn>=dep[p])break;
                }
            }
        }
        else
        {
            int x=findrt(e[p].l2);
            while(dep[x]>=dep[e[p].p2])
            {
                f[x]=g[p];
                q.push(Node(x,0,f[x]));
                rt[x]=findrt(fa[x][0]);
                x=rt[x];
            }
            x=findrt(e[p].r2);
            while(dep[x]>=dep[e[p].p2])
            {
                f[x]=g[p];
                q.push(Node(x,0,f[x]));
                rt[x]=findrt(fa[x][0]);
                x=rt[x];
            }
        }
    }
}
int main()
{
    n=read(),m=read(),k=read();
    for(int i=0;i<=n;i++)rt[i]=i;
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read(),d=read();
        edge[x].push_back(y),edge[y].push_back(x);
        e[(i<<1)-1]=Edge(x,x,y,y,d);
        e[i<<1]=Edge(y,y,x,x,d);
    }
    for(int i=1;i<=m;i++)
    {
        int l1=read(),r1=read(),l2=read(),r2=read(),c=read();
        e[((n-1)<<1)+i]=Edge(l2,r2,l1,r1,c);
    }
    dep[0]=-1;dfs(1,0);
    build(1,n);
    for(int i=1;i<=((n-1)<<1)+m;i++)
    {
        e[i].p1=LCA(e[i].l1,e[i].r1);e[i].p2=LCA(e[i].l2,e[i].r2);
        H[e[i].p1].push_back(i);
        e[i].del=false;
        if(e[i].l1!=e[i].p1)Insert(1,in[e[i].l1],1,i);
        if(e[i].r1!=e[i].p1)Insert(1,in[e[i].r1],2,i);
    }
    dijkstra();
    for(int i=1;i<=n;i++)printf("%lld\n",f[i]);
}