UVa1599 Ideal Path（双向bfs+队列判重）

最新推荐文章于 2020-10-11 17:09:31 发布

原创最新推荐文章于 2020-10-11 17:09:31 发布 · 318 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#bfs #队列

uva 专栏收录该内容

35 篇文章

订阅专栏

本文解析了一道紫书上的算法例题，通过两次广度优先搜索（BFS）寻找最短路径上的最小边权值。首次BFS记录可达节点到目标节点的距离；第二次则在满足特定距离条件下找到最小边权值。

紫书上的一道例题，题目链接

做两次bfs，第一次记录可达n的点到n的距离，到点1为止
第二次要在距离满足上一个点-1的基础上找边的最小值，这道题并不需要找到一条路径，只需要输出边的值即可，所以即便有多条边，也直接记录最小值就好了。
需要注意的一点，为了避免超时，需要加一个优化，用v数组来记录点是否被加入到队列中，即队列去重

#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define inf 0x3f3f3f3f
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rep1(i,a,b) for(int i=a;i>=b;i--)
#define rson rt<<1|1,m+1,r
#define lson rt<<1,l,m
using namespace std;
const int N=1e5+10;
int arr[N],vis[N],res[N],v[N];
struct node
{
    int b,c;
};
vector<node>G[N];
int main()
{
    ios::sync_with_stdio(false);
    int n,m;
    while(cin>>n>>m)
    {
        memset(vis,0,sizeof vis);
        memset(res,0,sizeof res);
        memset(v,0,sizeof v);
        for(int i=0;i<N;i++)
            G[i].clear();
        rep(i,0,m)
        {
            int a,b,c;
            cin>>a>>b>>c;
            G[a].pb({b,c});
            G[b].pb({a,c});
        }
        queue<int>q;
        q.push(n);
        vis[n]=1;
        while(!q.empty())
        {
            int a=q.front();
            q.pop();
            int pp=0;
            rep(i,0,G[a].size())
            {
                node y=G[a][i];
                if(!vis[y.b])
                {
                    vis[y.b]=vis[a]+1;
                    q.push(y.b);
                    if(y.b==1)
                    {pp=1;break;}
                }
            }
            if(pp) break;
        }
        while(!q.empty())
            q.pop();
        q.push(1);
        while(!q.empty())
        {
            int a=q.front();
            q.pop();
            int mi=inf,pp=0;
            if(a==n)break;
            rep(i,0,G[a].size())
            {
                node y=G[a][i];
                if(vis[y.b]==vis[a]-1)
                    mi=min(y.c,mi);
            }
            rep(i,0,G[a].size())
            {
                node y=G[a][i];
                if(!v[y.b]&&vis[y.b]==vis[a]-1&&y.c==mi)
                {
                    q.push(y.b);
                    v[y.b]=1;
                }
            }
            int index=vis[1]-vis[a];
            if(res[index]==0)res[index]=mi;
            else res[index]=min(res[index],mi);
        }
        cout<<vis[1]-1<<endl<<res[0];
        rep(i,1,vis[1]-1)
        cout<<' '<<res[i];
        cout<<endl;
    }
    return 0;
}