【XSY3888】传送门（最短路树，可并堆，dp）

题面

题解

假设 $S$ 到 $T$ 路径上一条边 $(u,v)$ 被删掉之后最短路会如何变化。

建出以 $T$ 为根的最短路树，如果 $(u,v)$ 不在树上，那么我们直接从 $u$ 沿着最短路树走到 $T$ 即可。

否则，如果 $(u,v)$ 在最短路树上，那么 $v$ 一定是 $u$ 的父亲。那么我们需要从 $u$ 走到 $u$ 子树内的任意一个点 $x$，然后再从 $x$ 经过一条非树边跳到一个在 $u$ 子树外的点 $y$，然后再沿最短路树走到 $T$。

类似这样：

（其中黑色虚线边表示的是非树边，红叉边表示被删掉的边，蓝色表示路径）

设 $dis_u$ 表示最短路树上 $T$ 到 $u$ 的路径长。考虑如何维护上面蓝色路径的最小值。把这段路程表示出来：

$$dis_x-dis_u+w_{(x,y)}+dis_y$$

那么我们直接维护 $dis_x+w_{(x,y)}+dis_y$ 的最小值即可。

对于每一个点 $u$，用堆维护其子树内 $dis_x+w_{(x,y)}+dis_y$ 的最小值。

合并的时候用左偏树即可。

最多合并 $n-1$ 次（$n-1$ 条边），所以维护这个的过程时间不会超过 $O(n\log n)$。

不妨设 $g_u$ 表示删掉边 $(u,\textit{fa}_u)$ 之后到达 $T$ 的最小值。（$g_u$ 通过上面的过程求出）

令 $dp_u$ 表示 $S=u$ 时的答案，用 $v$ 更新 $u$ 时的转移为：

$$dp_u =\min_{(u,v)}\left(\max\left(dp_v+w_{(u, v)}, \begin{cases}g_u&v=\textit{fa}_u\\dis_u&v\neq \textit{fa}_u\end{cases}\right)\right)$$

每次找到 $dp$ 值最小的点来更新其它的点的 $dp$ 值即可，类似 dijkstra。

时间复杂度 $O((n+m)\log n)$。

代码如下：

#include<bits/stdc++.h>
 
#define N 100010
#define M 200010
#define intree(v,u) (dfn[u]<=dfn[v]&&dfn[v]<=dfn[u]+size[u]-1)//判断是否在子树内
 
using namespace std;
 
struct data
{
    int u,s;
    data(){};
    data(int a,int b){u=a,s=b;}
    bool operator < (const data &a) const
    {
        return s>a.s;
    }
};
 
struct Heap//左偏树
{
    #define lc(u) ch[u][0]
    #define rc(u) ch[u][1]
    int node,ch[M][2],to[M],dis[M],val[M];
    int top,rubbish[M];
    int newnode(int y,int v)
    {
        int now;
        if(top)
        {
            now=rubbish[top--];
            lc(now)=rc(now)=dis[now]=0;
        }
        else now=++node;
        to[now]=y,val[now]=v;
        return now;
    }
    int merge(int x,int y)
    {
        if(!x||!y) return x+y;
        if(val[x]>val[y]) swap(x,y);
        rc(x)=merge(rc(x),y);
        if(dis[rc(x)]>dis[lc(x)]) swap(lc(x),rc(x));
        dis[x]=dis[rc(x)]+1;
        return x;
    }
    int pop(int u)
    {
        rubbish[++top]=u;
        return merge(lc(u),rc(u));
    }
}heap;
 
int n,m;
int cnt,head[N],nxt[M<<1],to[M<<1],w[M<<1];
int dis[N],fa[N];
int idx,dfn[N],size[N];
int root[N];
int dp[N],g[N];
bool vis[N];
 
vector<int>e[N];
priority_queue<data>q;
 
void adde(int u,int v,int wi)
{
    to[++cnt]=v;
    w[cnt]=wi;
    nxt[cnt]=head[u];
    head[u]=cnt;
}
 
void dijkstra()
{
    memset(dis,127,sizeof(dis));
    q.push(data(n,0));
    dis[n]=0;
    while(!q.empty())
    {
        data now=q.top();
        q.pop();
        if(vis[now.u]) continue;
        vis[now.u]=1;
        for(int i=head[now.u];i;i=nxt[i])
        {
            int v=to[i];
            if(dis[now.u]+w[i]<dis[v])
            {
                dis[v]=dis[now.u]+w[i];
                fa[v]=now.u;
                q.push(data(v,dis[v]));
            }
        }
    }
}
 
void dfs(int u)
{
    dfn[u]=++idx;
    size[u]=1;
    for(int i=0,siz=e[u].size();i<siz;i++)
    {
        int v=e[u][i];
        dfs(v);
        size[u]+=size[v];
        root[u]=heap.merge(root[u],root[v]);
    }
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(v==fa[u]||intree(v,u)) continue;
        root[u]=heap.merge(root[u],heap.newnode(v,dis[u]+w[i]+dis[v]));
    }
    while(root[u]&&intree(heap.to[root[u]],u))
        root[u]=heap.pop(root[u]);
    if(root[u]) g[u]=heap.val[root[u]]-dis[u];
}
 
void DP()
{
    memset(vis,0,sizeof(vis));
    memset(dp,127,sizeof(dp));
    q.push(data(n,0));
    dp[n]=0;
    while(!q.empty())
    {
        data now=q.top();
        q.pop();
        if(vis[now.u]) continue;
        vis[now.u]=1;
        for(int i=head[now.u];i;i=nxt[i])
        {
            int v=to[i];
            if(max(dp[now.u]+w[i],now.u==fa[v]?g[v]:dis[v])<dp[v])
            {
                dp[v]=max(dp[now.u]+w[i],now.u==fa[v]?g[v]:dis[v]);
                q.push(data(v,dp[v]));
            }
        }
    }
}
 
int main()
{
    memset(g,127,sizeof(g));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        adde(u,v,w),adde(v,u,w);
    }
    dijkstra();
    for(int i=1;i<n;i++)
        e[fa[i]].push_back(i);
    dfs(n);
//  puts("I didn't MLE!!!");
//  return 0;
    DP();
    if(dp[1]!=dp[0]) printf("%d\n",dp[1]);
    else puts("-1");
    return 0;
}
/*
5 10
1 3 10
1 5 4
3 4 6
5 2 10
1 2 6
4 5 2
2 3 2
4 1 5
4 2 6
5 3 3
*/