P2934 [USACO09JAN]安全出行

图论瞎搞......

solution：

按例化简：给定一个无向图，保证单源最短路唯一，求每个点到1号点的最短路最后一条边被封锁的情况下的最短路

乍一看，应该是次短路，但是稍微用脚趾头想想都能发现不是次短路.....

然后就乱搞了一发。秉承着我们的口号

暴力碾标算，n方过百万

我试着搞了一发暴力：先求出最短路径树（很重要），然后对于每一个点的父亲（前一个节点）进行dij拓展，不走被封的边，然后遇到目标点就退出（思路来源：旅行者）

然后我发现，不仅仅会T，甚至这个思路就是错的！！！

1、为什么会T：旅行者那题相当于只找一个最短边权当做最短路，因此dij的拓展过程可以认为是O（1）的；

2、为什么会wa：来看样例：

我弄出来的最短路径树是这样的：

根据以上思路，只需要求出dis（最短路），还有从父亲节点拓展的dis，加起来即可。

但是，当走到2，拓展4的时候：拓展的非树边和之前的最短路加起来，变成了7！？

但是，如果换一条路走，答案应该是6......

所以，这个思路到此终结（我170+lines的代码啊！！！！）

正解：（对，没错，这里才开始正解）

首先，最短路径树的思路要保留，这里有一个比较玄学的式子：

min(dis(u,v)（边权）+dis（u）-dis（v）+dis（v)）；

要求根到f的路径径，只需要知道根到u的最短路-根到f的最短路（也就是f到u的一条路径）加上根到v的最短路，再加上u到v的边权，这样就完成了一次拓展。

于是，就维护这个式子，用并查集维护联通（据机房大佬说这是并查集缩变233）

• 把所有非树边 记录下来
• 枚举点
• 更新式子
• 维护连通
• 进行n-1次

就是这样....据说spfa会被卡？本人专门卡各种卡spfa.....

注意一下，要判断无解.....

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+10;
int n,m;
inline int read()
{
    int x=0,f=1;char s=getchar();
    while(s>‘9‘||s<‘0‘){if(s==‘-‘)f=-1;s=getchar();}
    while(s<=‘9‘&&s>=‘0‘){x=x*10+s-‘0‘;s=getchar();}
    return f*x;
}
struct edge
{
    int to,next,dis;
}e[maxn];
int cnt,head[maxn];
inline void addedge(int from,int to,int dis)
{
    e[++cnt].next=head[from];
    e[cnt].to=to;
    e[cnt].dis=dis;
    head[from]=cnt;
}
int fa[maxn];
int dis[maxn];
struct cmp
{
    bool operator ()(int a,int b)
    {
        return dis[a]>dis[b];
    }
};
priority_queue <int,vector<int>,cmp> q;
int vis[maxn];
inline void spfa(int s)
{
    for(int i=1;i<=n;i++)
    {
        dis[i]=0x7fffffff;
        vis[i]=0;
    }
    vis[s]=1;
    dis[s]=0;
    q.push(s);
    while(!q.empty())
    {
        int u=q.top();
        q.pop();
        vis[u]=0;
        for(register int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].dis)
            {
                dis[v]=dis[u]+e[i].dis;
                fa[v]=u;
                if(vis[v]==0)
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}

struct tree
{
    int u,v,w;
}a[maxn];
bool cmp(tree a,tree b)
{
    return a.w<b.w;
}
int f[maxn],ans[maxn];
int num;
int find(int x)
{
    if(f[x]==x)
    return x;
    return f[x]=find(f[x]);
}
void solve(tree x)
{
    int u=x.u,v=x.v,t=x.w;
    while(find(u)!=find(v))
    {
        num++;
        if(dis[find(u)]<dis[find(v)])
        swap(u,v);
        ans[find(u)]=min(ans[find(u)],t-dis[find(u)]);
        u=f[find(u)]=fa[find(u)];
    }
}
int tot;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        x=read();y=read();z=read();//scanf("%d%d%d",&x,&y,&z);
        addedge(x,y,z);
        addedge(y,x,z);
    }
    spfa(1);
    for(int i=2;i<=cnt;i+=2)
    {
        int u=e[i].to;
        int v=e[i-1].to;;
        if(u!=fa[v]&&v!=fa[u])
        {
            a[++tot].u=u;
            a[tot].v=v;
            a[tot].w=e[i].dis+dis[u]+dis[v];
        }
    }

    sort(a+1,a+1+tot,cmp);
    for(int i=1;i<=n;i++)
    {
        f[i]=i;
        ans[i]=2147483647;
    }
    for(int i=1;i<=tot&&num<n-1;i++)
    {
        solve(a[i]);
    }
    for(int i=2;i<=n;i++)
    {
        if(ans[i]!=2147483647)
        printf("%d\n",ans[i]);
        else
        printf("-1\n");
    }
    return 0;
}

原文地址：https://www.cnblogs.com/ajmddzp/p/11441776.html