最短路树,启发式合并,dp



传送门

给一个无重边无自环的带正权无向图\(G\)和点\(s,t\)，已知\(G\)中某边断掉了，但只有走到边两端点处才知道边是否断掉，采取最优策略，求\(s\)到\(t\)的最短路的最坏情况

考虑一下最优策略咋做出来

这个就和九省联考2018一双木棋有点类似，考虑从终止态逆推，因为靠后的状态我们很容易知道它的最优策略，比如直接相连T的点的最优策略就很显然。

然后我们发现，对每个点到\(t\)的最优策略都是可以通过它出边的点转移过来的。

但是还有一个问题，转移的方向，会不会成一个环？

注意到是一个正权图的转移，显然一个点转移到另一个点，权值不会变小，所以按照dijkstra那样转移就是对的

那么具体到底怎么转移呢？

考虑\(u\)到\(v\)的转移


\[dp_v=\min_u \{\max (dp_u+E_{u,v},g_{u,v})\}\]


\(g_{u,v}\)表示\(u\)到\(v\)这个边不能走以后的\(u\)到\(t\)的最短路，现在只需要求出这个\(g\)就可以了

考虑建出\(T\)的最短路树

那么如果\(u\)不是\(v\)树上的儿子，那么走树边上去就可以了

否则先走到\(u\)子树上一点\(v\)，然后通过一个非树边从\(v\)走到子树外\(w\)，然后再走树边上去，设到根t的距离为\(dis_i\)，那么这个需要最小化\(dis_v+E(v,w)+dis_w-dis_u\)

那么我们可以离线的去做，对子树维护一个最小值，做启发式合并，就可以处理出\(g\)了

总复杂度\(O(n\log n)\)

Code:

#include <cstdio>
#include <cstring>
#include <cctype>
#include <queue>
#include <algorithm>
#include <vector>
#define ll long long
using std::max;
const int N=4e5+10;
const ll inf=1e16;
template <class T>
void read(T &x)
{
    x=0;char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=x*10+c-'0',c=getchar();
}
int head[N],to[N<<1],Next[N<<1],cnt=1;ll edge[N<<1];
void add(int u,int v,ll w)
{
    to[++cnt]=v,edge[cnt]=w,Next[cnt]=head[u],head[u]=cnt;
}
int n,m,s,t;
struct node
{
    int v;ll w;
    node(){}
    node(int V,ll W){v=V,w=W;}
    bool friend operator <(node a,node b){return a.w>b.w;}
};
std::priority_queue <node> q;
int vis[N],pre[N];
ll dis[N];
void dijs()
{
    for(int i=1;i<=n;i++) dis[i]=inf;
    q.push(node(t,dis[t]=0));
    while(!q.empty())
    {
        int now=q.top().v;
        q.pop();
        if(vis[now]) continue;
        vis[now]=1;
        for(int v,i=head[now];i;i=Next[i])
            if(dis[v=to[i]]>dis[now]+edge[i])
            {
                dis[v]=dis[now]+edge[i];
                pre[v]=i;
                q.push(node(v,dis[v]));
            }
    }
}
std::vector<int> E[N];
int dfn[N],low[N],par[N],dfsclock;
void dfs0(int now)
{
    dfn[now]=++dfsclock;
    for(int i=0;i<E[now].size();i++)
        par[E[now][i]]=now,dfs0(E[now][i]);
    low[now]=dfsclock;
}
int root[N<<1],dep[N<<1],ch[N<<1][2],num[N<<1],tot;
ll dat[N],Del[N];
#define ls ch[x][0]
#define rs ch[x][1]
int Merge(int x,int y)
{
    if(!x||!y) return x^y;
    if(dat[x]>dat[y]) std::swap(x,y);
    rs=Merge(rs,y);
    if(dep[ls]<dep[rs]) std::swap(ls,rs);
    dep[x]=dep[rs]+1;
    return x;
}
void dfs(int now)
{
    for(int v,i=head[now];i;i=Next[i])
    {
        v=to[i];
        if((dfn[now]<=dfn[v]&&dfn[v]<=low[now])||v==par[now]) continue;
        dat[++tot]=dis[now]+dis[v]+edge[i];
        num[tot]=dfn[v];
        root[now]=Merge(root[now],tot);
    }
    for(int v,i=0;i<E[now].size();i++)
    {
        dfs(v=E[now][i]);
        root[now]=Merge(root[now],root[v]);
    }
    while(root[now]&&dfn[now]<=num[root[now]]&&num[root[now]]<=low[now])
        root[now]=Merge(ch[root[now]][0],ch[root[now]][1]);
    if(root[now]) Del[now]=dat[root[now]]-dis[now];
    else Del[now]=inf;
}
ll dp[N];
int main()
{
    freopen("door.in","r",stdin);
    freopen("door.out","w",stdout);
    read(n),read(m),read(s),read(t);
    for(int u,v,w,i=1;i<=m;i++)
    {
        read(u),read(v),read(w);
        add(u,v,1ll*w),add(v,u,1ll*w);
    }
    dijs();
    for(int i=1;i<=n;i++)
        if(pre[i])
            E[to[pre[i]^1]].push_back(i);
    dfs0(t);
    dfs(t);
    memset(vis,0,sizeof vis);
    for(int i=1;i<=n;i++) dp[i]=inf;
    q.push(node(t,dp[t]=0));
    while(!q.empty())
    {
        int now=q.top().v;
        q.pop();
        if(vis[now]) continue;
        vis[now]=1;
        for(int v,i=head[now];i;i=Next[i])
        {
            v=to[i];
            ll yuy=max(dp[now]+edge[i],now==par[v]?Del[v]:dis[v]);
            if(yuy<dp[v]) q.push(node(v,dp[v]=yuy));
        }
    }
    if(dp[s]==inf) puts("-1");
    else printf("%lld\n",dp[s]);
    return 0;
}

2019.3.22