【BZOJ-1576】安全路径Travel Dijkstra + 并查集

1576: [Usaco2009 Jan]安全路经Travel

Time Limit: 10 Sec Memory Limit: 64 MB
Submit: 1044 Solved: 363
[Submit][Status][Discuss]

Description

Input

* 第一行: 两个空格分开的数, N和M

* 第2..M+1行: 三个空格分开的数a_i, b_i,和t_i

Output

* 第1..N-1行: 第i行包含一个数:从牛棚_1到牛棚_i+1并且避免从牛棚1到牛棚i+1最短路经上最后一条牛路的最少的时间.如果这样的路经不存在,输出-1.

Sample Input

4 5
1 2 2
1 3 2
3 4 4
3 2 1
2 4 3

输入解释:
跟题中例子相同

Sample Output

3
3
6

输出解释:

跟题中例子相同

HINT

Source

Gold

Solution

比较简单的一道题

首先我们跑一遍最短路，得到最短路树，在松弛操作的时候加一句话即可

然后我们发现对于不在最短路树上的边，如果把它加入树中，会形成一个环，它会影响这个环上除lca的其他点

样例是这样的，黑边是指最短路树上的边，加入非树红边，影响的是红点，加入非树蓝边，有影响的是蓝点

所发生的影响就是，环上点x，在加入边<u,v>会被更新成dis[u]+dis[v]+val<u,v>-dis[x]

所以要求被更新后最小，就是要求dis[u]+dis[v]+val<u,v>最小，那么我们按照这个价值对非树边排序

从权值小的开始更新。

所以这样的话，中间会更新一些重复的，我们只要保证那些重复的不被更新即可，这个显然可以利用并查集维护一下

这样时间复杂度大概是$O(nlogn+n×a(n))$

Code

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cmath>

#include<queue>

using namespace std;

int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

#define MAXN 100010

#define MAXM 200010

int N,M;

struct EdgeNode{int next,to,t,from;}edge[MAXM<<];

int head[MAXN],cnt=;

void AddEdge(int u,int v,int w) {cnt++; edge[cnt].from=u; edge[cnt].next=head[u]; head[u]=cnt; edge[cnt].to=v; edge[cnt].t=w;}

void InsertEdge(int u,int v,int w) {AddEdge(u,v,w); AddEdge(v,u,w);}

#define Pa pair<int,int>

#define INF 0x7fffffff

priority_queue<Pa,vector<Pa>,greater<Pa> >q;

int dis[MAXN],fa[MAXN];

void Dijkstra(int S)

{

    for (int i=; i<=N; i++) dis[i]=INF;

    q.push(make_pair(,S)); dis[S]=;

    while (!q.empty())

        {

            int now=q.top().second;

            int Dis=q.top().first;

            q.pop();

            if (Dis>dis[now]) continue;

            for (int i=head[now]; i; i=edge[i].next)

                if (Dis + edge[i].t < dis[edge[i].to])

                    dis[edge[i].to]=Dis+edge[i].t,

                    fa[edge[i].to]=now,

                    q.push(make_pair(dis[edge[i].to],edge[i].to));

        }

}

int f[MAXN];

int F(int x) {if (!f[x]) return x; else return f[x]=F(f[x]);}

struct RoadNode

{

    int u,v,t;

    bool operator < (const RoadNode & A) const

        {return t<A.t;}

}road[MAXM];

int tot,num;

int ans[MAXN];

void Add(RoadNode x)

{

    int u=x.u,v=x.v,t=x.t;

    while (F(u)!=F(v))

        {

            num++;

            if (dis[F(u)]<dis[F(v)]) swap(u,v);

            ans[F(u)]=min(ans[F(u)],t-dis[F(u)]);

            u=f[F(u)]=fa[F(u)];

        }

}

int main()

{

    N=read(),M=read();

    for (int x,y,z,i=; i<=M; i++) x=read(),y=read(),z=read(),InsertEdge(x,y,z);

    Dijkstra();

    for (int i=; i<=cnt; i+=)

        {

            int u=edge[i].from,v=edge[i].to;

            if (fa[u]!=v && fa[v]!=u)

                road[++tot].u=u,road[tot].v=v,road[tot].t=dis[u]+dis[v]+edge[i].t;

        }

    sort(road+,road+tot+);

//    for (int i=1; i<=tot; i++)

//        printf("%d %d %d\n",road[i].u,road[i].v,road[i].t);

//    for (int i=1; i<=N; i++) printf("%d  ",dis[i]); puts("");

    for (int i=; i<=N; i++) ans[i]=INF;

    for (int i=; i<=tot && num<N-; i++) Add(road[i]);

    for (int i=; i<=N; i++) printf("%d\n",ans[i]==INF? -:ans[i]);

    return ;

}

写完就A了....