最短路径+二分算法

当我们在计算最短路时，有时会依次枚举一个值来构造新图求最终答案，但是枚举的值的规律又成片成片的一样，这时候就需要二分答案了。

例题

YbtOJ修建道路

这道题的正确做法显然是二分答案。

这道题的难点在于现代 $OI$ 集团免费给 $sub$ 修的那 $k$ 条道路。

显然，对于一条选定的道路，我们肯定要免费修这条路中前 $k$ 长的小路段。用一般的最短路径显然无法解决此问题，因为最终答案选定的那条路在免费修 $k$ 条路之前也许并不是该图中的最短路。

所以我们要逆向思维一下，如果假定答案，就是假定第 $k+1$ 条路最短的那条路径的第 $k+1$ 条路的长度是 $ans$ 的话，计算一下该图中能否找到一条路径，满足这条路径上长度大于 $ans$ 的路小于等于 $k$ 条，则 $ans$ 一定要比最终答案要大，否则 $ans$ 一定要比最终答案要小。

如何计算该图中有这么一条路呢？对于每一个 $ans$，我们构造一个新图，边和点与原图对应，如果某一条边在原图中的长度大于 $ans$，则新图中的这条边权为1，否则新图中的这条边权为0.之后我们求新图中起点与终点的最短路径的长度，如果最短路长度小于等于 $k$，则该图中存在一条路径，这条路径的第 $k+1$ 长的路的长度小于等于 $ans$。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue> 
#define MAXN 100100 
using namespace std;
inline int read()
{
	int s=0,w=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-')
			w=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		s=s*10+ch-'0';
		ch=getchar();
	}
	return s*w;
}
struct Edge{
	int nxt;
	int to;
	int dis;
}edge[MAXN];
int head[MAXN],size;
inline void add(int from,int to,int dis)
{
	edge[++size].nxt=head[from];
	edge[size].to=to;
	edge[size].dis=dis;
	head[from]=size;
}//链式前向星存图 
int n,p,k;
int u,v,w;
int dis[MAXN],vis[MAXN];
void pre()
{
	memset(dis,0x3f3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
} 
inline bool dijkstra(int x)
{
	//如果sub最多要付x元,判断是否满足题目所给条件 
	priority_queue < pair < int , int > > q;
	pre();
	q.push(make_pair(dis[1]=0,1));
	while(!q.empty()){
		int u=q.top().second;
		q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		for(int i=head[u];i;i=edge[i].nxt){
			int v=edge[i].to;
			if(dis[v]>dis[u]+(edge[i].dis>x)){
				dis[v]=dis[u]+(edge[i].dis>x);
				q.push(make_pair(-dis[v],v));
			}
		}
	}
	return dis[n]<=k;
}
int main()
{
	n=read(),p=read(),k=read();
	for(int i=1;i<=p;i++){
		u=read(),v=read(),w=read();
		add(u,v,w);
		add(v,u,w);
	}
	int l=0,r=1000010,ans=12345678;
	while(l<=r){//二分答案 
		int mid=(l+r)>>1;
		if(dijkstra(mid)){
			ans=mid;
			r=mid-1;
		}
		else
			l=mid+1;
	}
	if(ans==12345678)
		ans=-1;//判断输出 
	cout<<ans<<endl;
	return 0;
} 

洛谷上也有一道类似的题：

P1462 通往奥格瑞玛的道路

思想与上一题大体相同，值得注意的是进行特判的方法。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
#define MAXN 100100
#define INF 0x3f3f3f3f
using namespace std;
inline int read()
{
	int s=0,w=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){
		if(ch=='-') w=-1;
		ch=getchar(); 
	}
	while(ch>='0'&&ch<='9'){
		s=s*10+ch-'0';
		ch=getchar();
	}
	return s*w;
}
struct node{
	int dis;
	int to;
	int nxt;
}edge[MAXN];
int head[MAXN],size;
inline void add(int from,int to,int dis)
{
	edge[++size].nxt=head[from];
	edge[size].to=to;
	edge[size].dis=dis;
	head[from]=size; 
} 
int n,m,b;
int f[MAXN],u,v,w,a[MAXN];
int dis[MAXN];
bool vis[MAXN];
inline void pre()
{
	memset(dis,0x3f3f3f3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
}
bool SPFA(int x)
{
	pre();
	queue<int> q;
	q.push(1);
	vis[1]=1,dis[1]=0;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=head[u];i!=0;i=edge[i].nxt){
			int v=edge[i].to;
			if(dis[v]>dis[u]+edge[i].dis&&f[v]<=x){
				//过滤掉点权过大的点 
				dis[v]=dis[u]+edge[i].dis;
				if(vis[v]==0){
					vis[v]==1;
					q.push(v);
				}
			}
		}
	}
	//dis[n]即为所求 
	if(dis[n]<=b)
		return true;
	else
		return false;
}
int main()
{
	//freopen("SPFA+erfen","r",stdin);
	//freopen("SPFA+erfen","w",stdout);
	n=read(),m=read(),b=read();
	for(int i=1;i<=n;i++)
		f[i]=read(),a[i]=f[i];
	for(int i=1;i<=m;i++){
		u=read(),v=read(),w=read();
		add(u,v,w);
		add(v,u,w);
	}
	sort(a+1,a+1+n);
	if(SPFA(INF)==false){
		cout<<"AFK"<<endl;
		return 0;
	}
	//这里做一个判断：如果点权大小在不受限制的情况下，依然无法出现损血量小于b的路径，直接结束程序
	int mid,l=1,r=n;
	int ans=0;
	while(l<=r){//二分答案 
		mid=(l+r)>>1;
		if(SPFA(a[mid])==true){
			ans=a[mid];
			r=mid-1;
		}
		else
			l=mid+1;
	}
	printf("%d\n",ans); 
	//fclose(stdin);
	//fclose(stdout);
	return 0;
}