传送门
给一个无重边无自环的带正权无向图\(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\)
扫描二维码关注公众号，回复：
5621777 查看本文章
那么我们可以离线的去做，对子树维护一个最小值，做启发式合并，就可以处理出\(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