理想路径（UVA1599 图的双向广度优先搜索）

内容来自陈小玉老师算法训练营
题目：
给一个n个点m条边（2≤n≤100000, 1≤m≤200000）的无向图，每条边上都涂有一种颜色（用1到1000000000表示）。求从结点1到结点n的一条路径，使得经过的边数尽量少，在此前提下，经过边的颜色序列的字典序最小。一对结点间可能有多条边，一条边可能连接两个相同结点。输入保证至少存在一条节点1到n的路径。

输入：输入共m+1行。第一行包含两个整数n和m。之后的m行，每行都含三个整数a_i、b_i、c_i，表示a_i、b_i之间有一条颜色为c_i的路径。

输出：输出共两行，第一行包含正整数k，表示节点1到n至少需要经过k条边，第二行包含k个由空格隔开的正整数，表示节点1到n依次经过的边的颜色。

输入样例：
4 6
1 2 1
1 3 2
3 4 3
2 3 1
2 4 4
3 1 1

输出样例
2
1 3

输出样例解释：节点1到4至少经过两条边：1->3，颜色为1（最后输入的那条边）；3->4，颜色为3。数据范围：2<=n<=10⁵,1<=m<=10⁵,1<=c_i<=10⁹，对于任意i∈[1，m]，都有1<=a_i，b_i<=n。对于两个长度为k的序列a和b，若存在i∈[1，k]使a_i<b_i，且对于任意j∈[1，i)都有a_j=b_j，则a<b。

题解：本题求节点1到n的最短距离，在此前提下，色号序最小。可以先求解最短距离，然后考察色号。因为在从节点1出发的多条边中，并不知道哪条边是最短路径上的边，所以无法确定最小色号。

算法设计：从节点n反向广度优先遍历标高，节点1的高度正好为从节点1到节点n的最短距离。（广度优先搜索，只要第一次到目的地了，就是最优的，就是最短距离）

从节点1正向广度优先遍历，沿着高度减1的方向遍历，找色号小的点，如果多个点的色号最小，则考察下一个色号那个最小，直到n点结束。

完美图解
1、根据样例创建图，然后从节点n反向广度优先遍历标高，节点1的高度为2，即节点1到n的最短距离为2，输出2。

2、从节点1正向广度优先遍历，沿着高度减1的方向遍历，找边上色号小的邻接点，节点1到2的色号为1，节点1到3的色号也为1，节点1到3的另一条道路色号为2，最小色后为1，输出1。目前无法确定选择那条边，因此将都有可能走的两个邻接点2和3都入队暂存。

3、从节点2和3出发，沿着高度减1的方向遍历，找边上色号小的邻接点，节点2到4的色号为4，节点3到4的色号为3，最小色号为3，输出3。

代码：

#include<bits/stdc++.h>
using namespace std;
const int N=100000+5,M=200000+5,inf=0x7fffffff;
int n,m,cnt;
int head[N],dis[N];
bool vis[N];
queue<int>q1,q2,q3;
struct Edge{
	int to,c,next;
}e[M];

void add(int u,int v,int c){//添加一条边 
// 	e[++cnt].to=v;
//	e[cnt].c=c;
//	e[cnt].next=head[u];
	e[++cnt]=(Edge){v,c,head[u]};
 	head[u]=cnt;
}

void bfs1(){//逆向标高求最短距离 
	int u,v;
	memset(vis,false,sizeof(vis));
	dis[n]=0;
	q1.push(n);
	vis[n]=true;
	while(!q1.empty()){
		u=q1.front();
		q1.pop();
		vis[u]=true;
		for(int i=head[u];i;i=e[i].next){
			v=e[i].to;
			if(vis[v])
				continue;
			dis[v]=dis[u]+1;
			q1.push(v);
			vis[v]=true;
		}
	}
}
/*
正向求最小色号序列
队列q1：保存节点号
队列q2：保存色号
队列q3：保存色号最小的边关联的邻接点号
*/
void bfs2(){
	int u,v,minc,c;
	bool first=true;
	memset(vis,false,sizeof(vis));
	vis[1]=true;
	for(int i=head[1];i;i=e[i].next)//1号结点所有邻接点 
		if(dis[e[i].to]==dis[1]-1){//高度减1的邻接点
			q1.push(e[i].to);
			q2.push(e[i].c);
		}
	while(!q1.empty()){
		minc=inf;
		while(!q1.empty()){
			v=q1.front();
			q1.pop();
			c=q2.front();
			q2.pop();
			if(c<minc){
				while(!q3.empty())//发现更小队列清空 
					q3.pop();
				minc=c;
			}
			if(c==minc)
				q3.push(v);
		}
		if(first)
			first=false;
		else
			cout<<" ";
		cout<<minc;
		while(!q3.empty()){//所有等于最小色号的结点 
			u=q3.front();
			q3.pop();
			if(vis[u])
				continue;
			vis[u]=true;
			for(int i=head[u];i;i=e[i].next){//扩展每一个结点 
				v=e[i].to;
				if(dis[v]==dis[u]-1){
					q1.push(v);
					q2.push(e[i].c);
				}
			}
		}		
	}
}

int main(){
	int u,v,c;
	while(cin>>n>>m){
		memset(head,0,sizeof(head));
		cnt=0;
		for(int i=1;i<=m;i++){
			cin>>u>>v>>c;
			add(u,v,c);
			add(v,u,c); 
		}
		bfs1();
		cout<<dis[1]<<endl;
		bfs2(); 
		cout<<endl;
	 } 
	return 0;
}

注：如下图所示，按邻接表顺序遍历边时，节点1到2，节点1到3色号均最小，那么q3队列暂存2、3两个节点，后来发现有比它们更小的色号（色号为2），将q3立即清空，保存节点5。