图论学习笔记 - 分层图最短路问题（以飞行路线为例）

定义

分层图最短路是指在可以进行分层图的图上解决最短路问题。

分层图：可以理解为有多个平行的图。

一般模型是：在一个正常的图上可以进行 k 次决策，对于每次决策，不影响图的结构，只影响目前的状态或代价。一般将决策前的状态和决策后的状态之间连接一条权值为决策代价的边，表示付出该代价后就可以转换状态了。

简单说就是：在图上，有 k 次机会可以直接通过一条边，问起点与终点之间的最短路径。

有两种方法解决分层图最短路问题：

1、建图时直接建成 k+1 层
2、多开一维记录机会信息

具体选哪种依题目数据范围而定

第一种方法

我们建 k+1 层图。然后有边的两个点，多建一条到下一层边权为 0 的单向边，如果走了这条边就表示用了一次机会。

有 N 个点时，1~n 表示第一层，（1+n）~（n+n）代表第二层，（1+2 * n）~（n+2 * n）代表第三层 ......（1+i * n）~（n+i * n）代表第 i+1 层。因为要建 K+1 层图，数组要开到 n * (k + 1)，点的个数也为n * (k + 1 ) 。

举个例子：

n=4 m=3 k=2

1 2 1

2 3 1

3 4 1

第二种方法

我们把 dis 数组和 vis 数组多开一维记录k次机会的信息。

• dis[i][j] 代表到达 i 用了 j 次免费机会的最小花费
• vis[i][j] 代表到达 i 用了 j 次免费机会的情况是否出现过

更新的时候先更新同层之间（即花费免费机会相同）的最短路，然后更新从该层到下一层（即再花费一次免费机会）的最短路。

• 不使用机会 dis[v][c] = min(min，dis[now][c] + edge[i].w)
• 使用机会 dis[v][c+1] = min(dis[v][c+1]，dis[now][c])

再举个例子：

n=4 m=3 k=2

0 1 1

1 2 1

2 3 1

来看一个例题：

飞行路线题解

洛谷 P4568 [JLOI2011]飞行路线

题目描述

Alice 和 Bob 现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在 n 个城市设有业务，设这些城市分别标记为 0 到 n−1，一共有 m 种航线，每种航线连接两个城市，并且航线有一定的价格。

Alice 和 Bob 现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多 k 种航线上搭乘飞机。那么 Alice 和 Bob 这次出行最少花费多少？

输入格式

第一行三个整数 n,m,k，分别表示城市数，航线数和免费乘坐次数。

接下来一行两个整数 s,t，分别表示他们出行的起点城市编号和终点城市编号。

接下来 m 行，每行三个整数 a,b,c，表示存在一种航线，能从城市 a 到达城市 b，或从城市 b 到达城市 a，价格为 c。

输出格式

输出一行一个整数，为最少花费。

输入输出样例

输入 #1

5 6 1

0 4

0 1 5

1 2 5

2 3 5

3 4 5

2 3 3

0 2 100

输出 #1

8

第一种方法

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int maxn=2000010;
int n,m,k;
int s,t;
int tot;
int ans=0x3f3f3f3f;
int dis[maxn];
int head[maxn];
bool vis[maxn];

struct edge{
	int to;
	int nxt;
	int from;
	int val;
}e[2*maxn];

void add(int x,int y,int w){
	tot++;
	e[tot].to=y;
	e[tot].from=x;
	e[tot].val=w;
	e[tot].nxt=head[x];
	head[x]=tot;
}

void dij(){
	memset(dis,0x3f3f3f,sizeof(dis));
	priority_queue< pair<int,int> > q;
	dis[s]=0;
	q.push(make_pair(-dis[s],s));
	while(!q.empty()){
		int x=q.top().second;
		q.pop();
		if(vis[x]) continue;
		vis[x]=1;
		for(int i=head[x];i!=-1;i=e[i].nxt){
			int y=e[i].to;
			if(!vis[y]&&dis[y]>dis[x]+e[i].val){
				dis[y]=dis[x]+e[i].val;
				q.push(make_pair(-dis[y],y));
			}
		}
	}
}

int main(){
	cin>>n>>m>>k;
	cin>>s>>t;
	int x,y,z;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++){
		cin>>x>>y>>z;
		for(int j=0;j<=k;j++){
			add(x+j*n,y+j*n,z);
			add(y+j*n,x+j*n,z);
			if(j!=k){
				add(x+j*n,y+(j+1)*n,0);
				add(y+j*n,x+(j+1)*n,0);
			}	
		}
	}
	dij();
	for(int i=0;i<=k;i++) ans=min(ans,dis[t+i*n]);
	cout<<ans<<endl;
	return 0;
}

第二种方法

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int maxn=100100;
int n,m,k;
int s,t;
int tot;
int head[maxn];
int dis[maxn][20];
bool vis[maxn][20];
int ans=0x3f3f3f3f;

struct edge{
	int to;
	int from;
	int nxt;
	int val;
}e[2*maxn];

void add(int x,int y,int w){
	tot++;
	e[tot].to=y;
	e[tot].from=x;
	e[tot].val=w;
	e[tot].nxt=head[x];
	head[x]=tot;
}

struct node{
	int u,d,used;
	bool operator <(const node&a) const{
		return d>a.d;
	}
};

void dij(){
	memset(dis,0x3f3f,sizeof(dis));
	dis[s][0]=0;
	priority_queue<node> q;
	q.push((node){s,0,0});
	while(!q.empty()){
		int u=q.top().u;
		int now=q.top().used;
		q.pop();
		if(vis[u][now]) continue;
		vis[u][now]=1;
		for(int i=head[u];i!=-1;i=e[i].nxt){
			if(now<k && !vis[e[i].to][now+1] && dis[e[i].to][now+1]>dis[u][now]){
				dis[e[i].to][now+1]=dis[u][now];
				q.push((node){e[i].to,dis[e[i].to][now+1],now+1});
			}
			if(!vis[e[i].to][now] && dis[e[i].to][now]>dis[u][now]+e[i].val){
				dis[e[i].to][now]=dis[u][now]+e[i].val;
				q.push((node){e[i].to,dis[e[i].to][now],now});
			}
		}
	}
}

int main(){
	cin>>n>>m>>k;
	cin>>s>>t;
	int x,y,z;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++){
		cin>>x>>y>>z;
		add(x,y,z);
		add(y,x,z);
	}	
	dij();
	for(int i=0;i<=k;i++) ans=min(ans,dis[t][i]);
	cout<<ans<<endl;
	return 0;
}