最短路问题（更新中。。。

最优乘车

题目链接：最优乘车

本道题目的难点在于如何建边，首先，对于一条公交线路来说，因为是单向边比如3->4->5->2，那么只能从3走到5，不能从5走到3，同时，因为题目要求的是最小的换乘次数，所以一条公交线路不管从3到4还是3到2，都建一条边（用一个bool 数组记录能否从 i 到 j ）最后用bfs数组循环一遍即可。

答案要求的是换乘的次数，而我们所求的d[n]是经过的车站数量，所以最后答案要减一，如果是负数，那么换乘次数归0.

#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 0x3f3f3f;
bool g[N][N];
int stop[N];
int d[N];
int n,m;

void bfs(){
	queue<int>q;
	for(int i=1;i<=n;i++)d[i]=inf;
	q.push(1);
	d[1]=0;
	while(!q.empty()){
		int x=q.front();
		q.pop();
		for(int i=1;i<=n;i++){
			if(g[x][i]&&d[i]>d[x]+1){
				d[i]=d[x]+1;
				q.push(i);
			}
		}
	}
}

int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>m>>n;
	string line;
	getline(cin,line);
	for(int k=1;k<=m;k++){
		getline(cin,line);
		stringstream ss(line);
		int p,cnt=0;
		while(ss>>p){
			stop[++cnt]=p;
		}
		for(int i=1;i<=cnt;i++){
			for(int j=i+1;j<=cnt;j++){
				g[stop[i]][stop[j]]=1;
			}
		}
	}

	bfs();

	if(d[n]==inf)cout<<"NO"<<"\n";
	else cout<<max(0,d[n]-1)<<"\n";

	return 0;
}

新年好

题目链接：新年好

思路：题目要求用最少的时间拜访完5个亲戚，那么拆开来分析，如何用最少的时间拜访2个亲戚呢？次序就是先拜访完一个再去拜访另一个，那么那个先去拜访的就成了起点，起点再求最短路到另一个亲戚。

由此可见，题目就变成了先去拜访一个亲戚，然后以这个亲戚为起点再去拜访另一个，以此类推，问题就解决了，那么目前我们要求的就是以每个亲戚为起点求它到其他亲戚点的最短路，然后跑一遍dfs判断哪种方法是路径最短的。

代码附上：

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
const int inf = 1e9;
int n,m;
struct node{
	int x,w;
	bool operator<(const node &u)const{
		return w==u.w?x>u.x:w>u.w;
	}
};
vector<node>g[N];
int d[9][N];//表示每个点到其他各个点的最短路
int a[9];
int vis[N];

void dijkstra(int st,int d[]){
	priority_queue<node>pq;
	for(int i=1;i<=n;i++)d[i]=inf;
	pq.push({st,d[st]=0});
	bitset<N>vis;
	while(!pq.empty()){
		int x=pq.top().x;
		pq.pop();
		if(vis[x])continue;
		vis[x]=1;
		for(const auto &[y,w]:g[x]){
			if(d[y]>d[x]+w){
				d[y]=d[x]+w;
				pq.push({y,d[y]});
			}
		}
	}
}

int dfs(int u,int st,int dis){
	if(u>5)return dis;
	int res=inf;
	for(int i=2;i<=6;i++){//枚举亲戚的位置
		if(vis[i])continue;
		int nex=a[i];
		vis[i]=1;
		res=min(res,dfs(u+1,i,dis+d[st][nex]));
		vis[i]=0;
	}
	return res;
}

int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m;
	a[1]=1;//自己的位置为1
	for(int i=2;i<=6;i++)cin>>a[i];

	for(int i=1;i<=m;i++){
		int x,y,w;cin>>x>>y>>w;
		g[x].push_back({y,w});
		g[y].push_back({x,w});
	}

	for(int i=1;i<=6;i++){
		dijkstra(a[i],d[i]);//计算以a[i]为起点到每个点的最短距离
	}
	memset(vis,0,sizeof(vis));
	cout<<dfs(1,1,0)<<"\n";//从自己开始dfs

	return 0;
}

通信线路

题目链接：通信线路

做法：双端队列 + 二分

思路：该问题就是求1到N中第k+1大的边的最小值为多少，因此可以采用二分的思想去解决，首先二分答案的长度，定义范围为[0~1e6+1]（后面加1是为了方便判断该路径存不存在）。

对于区间中的某一点x，求出从1走到n，最少 经过的长度大于x的边 是否小于等于k。

可以将所有边分类，如果边长大于x，则边权看成1，否则看成0.

可以用双端队列BFS来求从1到n的最短路

代码附上：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e5+5;
struct node{
	int x,w;
};
vector<node>g[N];
int n,m,k;
int d[N];

bool check(int mid){
	memset(d,0x3f3f3f,sizeof(d));
	deque<int>q;
	bitset<N>vis;
	q.push_back(1);
	d[1]=0;
	while(!q.empty()){
		int x=q.front();
		q.pop_front();
		if(vis[x])continue;
		vis[x]=1;
		for(const auto &[y,w]:g[x]){
			int v=w>mid;
			if(d[y]>d[x]+v){
				d[y]=d[x]+v;
				if(v)q.push_back(y);//如果边权为1放后面
				else q.push_front(y);
			}
		}
	}
	return d[n]<=k;//如果大于x的边小于等于k个，返回true
}

signed main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m>>k;
	for(int i=1;i<=m;i++){
		int x,y,w;cin>>x>>y>>w;
		g[x].push_back({y,w});
		g[y].push_back({x,w});
	}

	int l=0,r=1e6+1;//枚举最小的第k+1大的边
	while(l<r){
		int mid=(l+r)/2;
		if(check(mid))r=mid;
		else l=mid+1;
	}

	if(r==1e6+1)cout<<-1<<"\n";//不存在
	else cout<<r<<"\n";

	return 0;
}

选择最佳线路

题目链接：选择最佳线路

这道题目如果一个个枚举起点的话会TLE，因此可以采用建立超级源点的思想去解决，首先建一个超级源点0，然后建从0到各个起点的一条边，边权为0，那么只需要跑一遍dijkstra即可解决。

代码附上：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N =1e5+5;
const int inf =0x3f3f3f3f3f3f;
int n,m,ed,k;
struct node{
	int x,w;
	bool operator<(const node &u)const{
		return w==u.w?x>u.x:w>u.w;
	}
};
vector<node>g[N];
int d[N];

void dijkstra(int st){
	priority_queue<node>pq;
	for(int i=1;i<=n;i++)d[i]=inf;
	bitset<N>vis;
	pq.push({st,d[st]=0});
	while(!pq.empty()){
		int x=pq.top().x;pq.pop();
		if(vis[x])continue;
		vis[x]=1;
		for(const auto &[y,w]:g[x]){
			if(d[y]>d[x]+w){
				d[y]=d[x]+w;
				pq.push({y,d[y]});
			}
		}
	}
}

signed main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	while(cin>>n&&n!=0){
		cin>>m>>ed;
		for(int i=0;i<=n;i++)g[i].clear();

		for(int i=1;i<=m;i++){
			int x,y,w;cin>>x>>y>>w;
			g[x].push_back({y,w});
		}

		cin>>k;
		for(int i=1;i<=k;i++){
			int st;cin>>st;
			g[0].push_back({st,0});
		}

		dijkstra(0);
		if(d[ed]<inf/2)cout<<d[ed]<<"\n";
		else cout<<-1<<"\n";
	}

	return 0;
}