传送门 解题报告

传送门

给一个无重边无自环的带正权无向图(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(nlog 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
",dp[s]);
    return 0;
}

---

2019.3.22