UVA1599 双向bfs

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

转载最新推荐文章于 2020-10-11 17:09:31 发布 · 141 阅读

ACM算法专栏收录该内容

68 篇文章

订阅专栏

本文介绍了一种解决迷宫最短路径问题的算法，通过两次广度优先搜索（BFS），首先逆向求出各点到终点的最短距离，然后从起点出发，根据颜色字典序选择最短路径。适用于大规模迷宫，如包含10万房间和20万路径的情况。

思路+题目
解题思路：先反着做一次BFS，求得所有点到终点的最短距离，然后从起点出发再做一次BFS，每过一个点判断是否该点最短距离为原点最短距离减一。遵循这个规律行走的路径一定是最短的，遇到多条则判断哪一条颜色数值最小，将结果排入队列。若同时有多个颜色数最小的则一起排入队列。注意两次BFS重复点的判定，第一次BFS需要，第二次不需要。因为用了STL可能会出现超时情况.

题目大意：对于一个n个房间m条路径的迷宫（Labyrinth）（2<=n<=100000, 1<=m<=200000），每条路径上都涂有颜色，颜色取值范围为1<=c<=10^9。求从节点1到节点n的一条路径，使得经过的边尽量少，在这样的前提下，如果有多条路径边数均为最小，则颜色的字典序最小的路径获胜。一条路径可能连接两个相同的房间，一对房间之间可能有多条路径。输入保证可以从节点1到达节点n。

Sample Input

4 6
1 2 1
1 3 2
3 4 3
2 3 1
2 4 4
3 1 1
Sample Output

2
1 3

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=2e5+5;
struct Edge
{
    int next;
    int color;
}edge[2*maxn];
int d[maxn];//该点离终点最短距离.
int ans[maxn];//记录路径上的点
int n,m;
queue<int> Q;
vector<Edge> A[maxn];
void bfs1()
{
    while(Q.empty()==false)
    {
        int x=Q.front();
        Q.pop();
        int t=Q.front();//d[x]
        Q.pop();
        for(int i=0;i<A[x].size();i++)
        {
            int nx=A[x][i].next;
            if(d[nx]!=-1) continue;
            d[nx]=t+1;
            Q.push(nx);
            Q.push(d[nx]);
        }
    }
}
void bfs2()
{
    while(Q.empty()==false)
    {
        int x=Q.front();
        Q.pop();
        if(x==n) return;
        int minn=123456789;
        for(int i=0;i<A[x].size();i++)
        {
            int x1=A[x][i].next;
            int c1=A[x][i].color;
            if(d[x]-1==d[x1]&&c1<minn)
            {
                minn=c1;
            }
        }
        if(minn<ans[d[x]]||ans[d[x]]==-1)
            ans[d[x]]=minn;
        for(int i=0;i<A[x].size();i++)
        {
            int x1=A[x][i].next;
            int c1=A[x][i].color;
            if(d[x]-1==d[x1]&&c1==minn)
                Q.push(x1);
        }
    }
}

int main()
{
    while(cin>>n>>m)
    {
        memset(d,-1,sizeof(d));
        for(int i=1;i<=m;i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            Edge t;
            t.next=b,t.color=c;
            A[a].push_back(t);
            t.next=a;
            A[b].push_back(t);
        }
        d[n]=0;
        Q.push(n);
        Q.push(d[n]);
        bfs1();
        memset(ans,-1,sizeof(ans));
        Q.push(1);
        bfs2();
        cout<<d[1]<<endl;
        for(int i=d[1];i>d[n];i--)
        {
            cout<<ans[i]<<' ';
        }
        cout<<endl;

    }
    return 0;
}