dijkstra算法加训上之分层图最短路-EW帮帮网

来几个分层图的题练习下哈

P4568 [JLOI2011] 飞行路线

P4568 [JLOI2011] 飞行路线 - 洛谷https://www.luogu.com.cn/problem/P4568

题目描述

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
说明/提示

数据规模与约定

对于 30% 的数据，2≤n≤50，1≤m≤300，k=0。

对于 50% 的数据，2≤n≤600，1≤m≤6×103，0≤k≤1。

对于 100% 的数据，2≤n≤104，1≤m≤5×104，0≤k≤10，0≤s,t,a,b<n，a=b，0≤c≤103。

另外存在一组 hack 数据。

思路

就是增加了一个考虑情况，有k个路线可以免费，嘶，这个看代码仔细思考，然后把走的每个路的情况在脑子里过，应该能想明白我语言描述不出来、

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10;
const int M=5e4+10;
using tiii=tuple<int,int,int>;
vector<pair<int,int>>graph[N];
vector<vector<int>>distance_(N,vector<int>(15,INT_MAX));
int n,m,k,s,t;
int main(){
	cin>>n>>m>>k>>s>>t;
	while(m--){
		int u,v,w;
		cin>>u>>v>>w;
		graph[u].push_back({v,w});
		graph[v].push_back({u,w});
	}
	priority_queue<tiii,vector<tiii>,greater<tiii>>pq;
	pq.push({0,s,0});//第一个是花费，中间是节点 ,第二个是花费次数
	distance_ [s][0]=0;
	while(!pq.empty()){
		int dist=get<0>(pq.top());
		int u=get<1>(pq.top());
		int num=get<2>(pq.top());
		pq.pop();
		if(u==t) {
					cout<<dist;
					return 0;
				}
		if(dist>distance_[u][num]) continue;
		
		for(auto edge:graph[u]){
			int v=edge.first;
			int w=edge.second;
			if(num<k&&dist<distance_[v][num+1]){
				distance_[v][num+1]=dist;
				pq.push({distance_[v][num+1],v,num+1});
			} 
		   if(dist+w<distance_[v][num]){
		   	distance_[v][num]=dist+w;
		   	pq.push({distance_[v][num],v,num});
		   }
		}
	}
	cout<<-1;
	return 0;
}

LCP 35. 电动车游城市

LCP 35. 电动车游城市 - 力扣（LeetCode）https://leetcode.cn/problems/DFPeFJ/description/?envType=problem-list-v2&envId=tZEK0x2Y

小明的电动车电量充满时可行驶距离为 cnt，每行驶 1 单位距离消耗 1 单位电量，且花费 1 单位时间。小明想选择电动车作为代步工具。地图上共有 N 个景点，景点编号为 0 ~ N-1。他将地图信息以 [城市 A 编号,城市 B 编号,两城市间距离] 格式整理在在二维数组 paths，表示城市 A、B 间存在双向通路。初始状态，电动车电量为 0。每个城市都设有充电桩，charge[i] 表示第 i 个城市每充 1 单位电量需要花费的单位时间。请返回小明最少需要花费多少单位时间从起点城市 start 抵达终点城市 end。

示例 1：
输入：
paths = [[1,3,3],[3,2,1],[2,1,3],[0,1,4],[3,0,5]], cnt = 6, start = 1, end = 0, charge = [2,10,4,1]
输出：
43
解释：最佳路线为：1->3->0。 在城市 1 仅充 3 单位电至城市 3，然后在城市 3 充 5 单位电，行驶至城市 0。 充电用时共 3*10 + 5*1= 35 行驶用时 3 + 5 = 8，此时总用时最短 43。
示例 2：
输入：
paths = [[0,4,2],[4,3,5],[3,0,5],[0,1,5],[3,2,4],[1,2,8]], cnt = 8, start = 0, end = 2, charge = [4,1,1,3,2]
输出：
38
解释：最佳路线为：0->4->3->2。 城市 0 充电 2 单位，行驶至城市 4 充电 8 单位，行驶至城市 3 充电 1 单位，最终行驶至城市 2。 充电用时 4*2+2*8+3*1 = 27 行驶用时 2+5+4 = 11，总用时最短 38。
提示：

1 <= paths.length <= 200

paths[i].length == 3

2 <= charge.length == n <= 100

0 <= path[i][0],path[i][1],start,end < n

1 <= cnt <= 100

1 <= path[i][2] <= cnt

1 <= charge[i] <= 100

题目保证所有城市相互可以到达

思路

分层图最短路的核心在于将节点扩展为多个状态，每个状态包含当前城市和剩余电量。通过优先队列（小根堆）进行Dijkstra算法，每次处理时间最小的状态，确保找到最优解。

状态定义：每个状态由当前城市、剩余电量和到达该状态的时间组成。

充电处理：在当前城市充电，每次增加一格电量，消耗对应充电时间。

移动处理：移动到相邻城市，消耗电量（等于路径长度），时间增加路径耗时。

其实和上面那个差不多，要仔细比对一下细节，题多给一个状态，所以我们每次进行操作时候也要判断那个状态，distance其实记录的就是状态，之前一维数组是因为只记录一个状态，现在分层图最短路，多一个状态所以要用二维，然后我们就又多了许多判断的条件，这是要注意的

class Solution {
public:
    
 struct Node{
        int x;
        int y;
        int cost;
        bool operator>(const Node& other) const{
            return cost>other.cost;//小根堆
        }
    };
int electricCarPlan(vector<vector<int>>& paths, int cnt, int start, int end, vector<int>& charge) {
    int n = charge.size();//n个城市
    //建图
    vector<vector<pair<int, int>>> graph(n);
    for (auto& path : paths) {
        graph[path[0]].emplace_back(path[1], path[2]);
        graph[path[1]].emplace_back(path[0], path[2]);//无向图所以添加两次，保证连接性
    }
    //这种题，节点不是真正的点，而是点+当前状态，在该题状态就是电量
    vector<vector<int>> distance(n, vector<int>(cnt + 1, INT_MAX));//节点+状态
    distance[start][0] = 0;
    //小根堆，
    priority_queue<Node, vector<Node>, greater<Node>> heap;
    heap.emplace(start, 0, 0);//往里面先添加当前到达位置,到达当前城市电量为0，到达当前城市花费的时间，也就是代价，小根堆也是靠这个参数来排序
    
    //接下来就是核心代码，从小根堆里得到每次走最短的路所到的城市
    while (!heap.empty()) {
        auto [u, cur_charge, t] = heap.top();//u是当前所到达的城市,cur是当前城市充电花的时间，t是到达这个城市花费的时间 
        heap.pop();
        
        if (u == end) return t;//到end一定是最短路所以直接返回t
        if (t>distance[u][cur_charge]) continue;        
        //当想走向下一个城市，我们有两条路
        //1，选择充电先充一格电
        ///2，不充电直接走向下一个城市
        for (auto& [v, cost] : graph[u]) {
            // 1充电（如果当前电量不满）
        if (cur_charge < cnt) {//当前的电只要没充满久一直一格一格的充电
            int new_charge = cur_charge + 1;//加一格电
            int new_time = t + charge[u];//到达这个城市后的时间也就也加charge[u]
            if (new_time < distance[u][new_charge]) {//如果选择充电然后判断到达这个状态是不是更小了
                distance[u][new_charge] = new_time;//冲完电后的状态
                heap.emplace(u, new_charge, new_time);//然后扔进堆里
            }
        }
            if (cur_charge >= cost) {//如果当前的电够去下一个城市就去
                int remaining = cur_charge - cost;//剩下的电
                if (t + cost < distance[v][remaining]) {//之前花的时间+这次去下一个城市的时间如果更小就更新当前状态到达下一条路的代价
                    distance[v][remaining] = t + cost;
                    heap.emplace(v, remaining, t + cost);
                }
            }
        }
    }
    return -1; // 无法到达
}
};

787. K 站中转内最便宜的航班

787. K 站中转内最便宜的航班https://leetcode.cn/problems/cheapest-flights-within-k-stops/

有 n 个城市通过一些航班连接。给你一个数组 flights ，其中 flights[i] = [fromi, toi, pricei] ，表示该航班都从城市 fromi 开始，以价格 pricei 抵达 toi。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到出一条最多经过 k 站中转的路线，使得从 src 到 dst 的 价格最便宜 ，并返回该价格。如果不存在这样的路线，则输出 -1。

示例 1：
输入: 
n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
输出: 700 
解释: 城市航班图如上
从城市 0 到城市 3 经过最多 1 站的最佳路径用红色标记，费用为 100 + 600 = 700。
请注意，通过城市 [0, 1, 2, 3] 的路径更便宜，但无效，因为它经过了 2 站。
示例 2：
输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
输出: 200
解释: 
城市航班图如上
从城市 0 到城市 2 经过最多 1 站的最佳路径标记为红色，费用为 100 + 100 = 200。
示例 3：
输入：n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
输出：500
解释：
城市航班图如上
从城市 0 到城市 2 不经过站点的最佳路径标记为红色，费用为 500。
提示：

1 <= n <= 100

0 <= flights.length <= (n * (n - 1) / 2)

flights[i].length == 3

0 <= fromi, toi < n

fromi != toi

1 <= pricei <= 104

航班没有重复，且不存在自环

0 <= src, dst, k < n

src != dst

思路

整体就是个dijkstra，但是这次相当于分层图最短路了，分层图就是现在又有个另一个限制，我们要保证在k次转飞机路线内才行，所以我们就把distance数组变成二维记录走到每个节点时已经转运了几次，还有堆里面也加上这玩意，就行了，还是很有意思的哈哈

class Solution {
public:
    using tiii=tuple<int, int, int>;
  
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        //建图 
        vector<vector<pair<int,int>>> graph(n);
        for(auto &edge:flights){
            graph[edge[0]].push_back({edge[1],edge[2]});
        }
        //建堆
        priority_queue<tiii,vector<tiii>,greater<>>pq;
        //distance_表
        vector<vector<int>> distance_(n,vector<int>(k+2,INT_MAX));
        //初始化
        distance_[src][k+1]=0;
        pq.push({0,src,k+1});
        int ans=0;
        while(!pq.empty()){
            auto [dist,u,remain]=pq.top();
            pq.pop();
            if(u==dst) return dist;
            if(remain==0) continue;
            if(dist>distance_[u][remain]) continue;   
            for(auto [v,w]:graph[u]){
                int new_remain=remain-1;
                if(dist+w<distance_[v][new_remain]){
                    distance_[v][new_remain]=dist+w;
                    pq.push({distance_[v][new_remain],v,new_remain});
                }
            }
        }
        return -1;
    }
};

864. 获取所有钥匙的最短路径

864. 获取所有钥匙的最短路径https://leetcode.cn/problems/shortest-path-to-get-all-keys/

给定一个二维网格 grid ，其中：

'.' 代表一个空房间

'#' 代表一堵墙

'@' 是起点

小写字母代表钥匙

大写字母代表锁

我们从起点开始出发，一次移动是指向四个基本方向之一行走一个单位空间。我们不能在网格外面行走，也无法穿过一堵墙。如果途经一个钥匙，我们就把它捡起来。除非我们手里有对应的钥匙，否则无法通过锁。

假设 k 为钥匙/锁的个数，且满足 1 <= k <= 6，字母表中的前 k 个字母在网格中都有自己对应的一个小写和一个大写字母。换言之，每个锁有唯一对应的钥匙，每个钥匙也有唯一对应的锁。另外，代表钥匙和锁的字母互为大小写并按字母顺序排列。

返回获取所有钥匙所需要的移动的最少次数。如果无法获取所有钥匙，返回 -1 。

示例 1：
输入：grid = ["@.a..","###.#","b.A.B"]
输出：8
解释：目标是获得所有钥匙，而不是打开所有锁。
示例 2：
输入：grid = ["@..aA","..B#.","....b"]
输出：6
示例 3:
输入: grid = ["@Aa"]
输出: -1
提示：

m == grid.length

n == grid[i].length

1 <= m, n <= 30

grid[i][j] 只含有 '.', '#', '@', 'a'-'f' 以及 'A'-'F'

钥匙的数目范围是 [1, 6]

每个钥匙都对应一个不同的字母

每个钥匙正好打开一个对应的锁

思路

这题也是很有意思的，状态就是带几把钥匙，我们可以利用位运算来代表此时状态手里有几把钥匙哈哈，这题的状态就是坐标和钥匙个数，所以我们的队列里面就要存这俩状态。虽然这题是用bfs但其实核心思路还是一样的

 class Solution {
    #define mxn 31
public:
int move[5]={-1,0,1,0,-1};
    int shortestPathAllKeys(vector<string>& grid) {
 vector<vector<vector<bool>>>visited(mxn,vector<vector<bool>>(mxn,vector<bool>(1<<6)));
    vector<vector<int>>q(mxn*mxn*(1<<6),vector<int>(3));//x，y，状态
    
    int l=0,r=0,key=0;
    int m=grid.size();
    int n=grid[0].size();
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(grid[i][j]=='@'){
                q[r][0]=i;
                q[r][1]=j;
                q[r++][2]=0;//代表还没拿到钥匙
            }
            if(grid[i][j]>='a'&&grid[i][j]<='f'){
                key|=(1<<(grid[i][j]-'a'));
            }
        }
    }
    int level=1;
    while(l<r){
        int size=r-l;
        for(int k=0,x,y,s;k<size;k++){
            x=q[l][0];
            y=q[l][1];
            s=q[l++][2];//状态
            for(int i=0,nx,ny,ns;i<4;i++){
                nx=x+move[i];
                ny=y+move[i+1];
                ns=s;
                if(nx<0||ny<0||nx==m||ny==n||grid[nx][ny]=='#')
                continue;
                if(grid[nx][ny]>='A'&&grid[nx][ny]<='F'&&!(s & (1 << (grid[nx][ny] - 'A')))){
                    continue;//遇到锁但是没有对应钥匙
                }
                if(grid[nx][ny]>='a'&&grid[nx][ny]<='f'){
                    ns|=(1<<(grid[nx][ny]-'a'));
                }//换状态
                if(ns==key)
                return level;
                if(!visited[nx][ny][ns]){
                    visited[nx][ny][ns]=true;
                    q[r][0]=nx;
                    q[r][1]=ny;
                    q[r++][2]=ns;
                }
        }
        }
        level++;
    }

return -1;
          
    }
};

总结

小总结一下哈

分层最短路思想总结

分层最短路是一种将状态和位置结合的多维搜索方法，核心思想是将传统图中的节点扩展为“位置+状态”的复合节点，通过状态的分层处理，解决带有约束条件的最短路径问题。其本质是构建一个状态空间图，通过搜索该图找到最优解。记好对每个状态都要判断此时是不是最优路

核心思想

状态分层：
- 将问题中影响路径选择的动态变量（如电量、钥匙持有状态、剩余步数等）作为“状态维度”。
- 每个节点由 (位置, 状态) 唯一标识，例如：
  - 电动车问题：(城市, 剩余电量)
  - 钥匙问题：(坐标, 已持有钥匙掩码)
状态转移：
- 在搜索过程中，状态会随着操作（移动、充电、拾取钥匙等）动态变化。
- 例如：从 (x, y, 钥匙掩码) 移动到相邻格子后，可能更新钥匙掩码或触发锁的检查。
最优性保证：
- 使用 BFS（无权图） 或 Dijkstra（带权图） 逐层扩展，确保首次到达目标状态时的路径最短。

通用步骤

1. 问题分析与状态定义

确定约束条件：找出影响路径选择的动态变量（如电量、钥匙、剩余使用次数等）。
状态表示：将约束条件编码为状态变量。例如：
- 电量：整数（0~最大容量）
- 钥匙：位掩码（如 101 表示持有钥匙 a 和 c）

2. 构建状态空间图

节点：每个节点为 (位置, 状态)，例如 (x, y, mask)。
边：
- 移动边：从 (x, y, s) 到相邻位置 (nx, ny, s)，需满足移动条件（如不撞墙、有钥匙开锁等）。
- 状态转移边：在特定位置触发状态更新（如充电、拾取钥匙）。

3. 初始化与数据结构

队列/优先队列：
- BFS：普通队列（无权图，每步代价相同）。
- Dijkstra：优先队列（按代价排序，如时间、距离）。
访问标记数组：记录 (位置, 状态) 是否已被访问，避免重复处理。

4. 搜索过程

起点入队：初始位置和初始状态（如电量0、无钥匙）。
逐层扩展：
- 取出当前节点，检查是否达到终止条件（如到达终点、收集所有钥匙）。
- 对当前节点进行状态转移（如充电、拾取钥匙）和移动操作，生成新节点。
- 若新节点未被访问过且路径更优，则更新并加入队列。
终止条件：
- 找到目标状态（如所有钥匙收集完毕）。
- 队列为空时返回无解。

关键优化点

状态压缩：
- 使用位掩码（Bitmask）表示离散状态（如钥匙），将状态空间从指数级压缩到多项式级。
- 例如：6把钥匙可用 6位二进制数（0~63）表示。
剪枝策略：
- 若 (位置, 状态) 已以更优代价访问过，跳过当前路径。
- 例如：在电动车问题中，若 到达城市u的电量5的时间 已经比当前路径更短，则无需处理当前节点。
分层队列管理：
- BFS按层扩展，天然保证最短路径；Dijkstra按代价排序，确保优先处理更优路径。

这个是ai帮我总结的，偷懒了一下，但我看他说的还是可以的，我对图这玩意实在用语言说不出，只能脑子里想象出，当然也可以画图画出来，但不太好弄就没弄，仔细看看应该就能会哈哈

dijkstra算法加训上之分层图最短路

P4568 [JLOI2011] 飞行路线

思路

LCP 35. 电动车游城市

思路

787. K 站中转内最便宜的航班

思路

864. 获取所有钥匙的最短路径

思路

总结

网站公告

今日签到

热门文章

最新发布

dijkstra算法加训上 之 分层图最短路

P4568 [JLOI2011] 飞行路线

思路

LCP 35. 电动车游城市

思路

787. K 站中转内最便宜的航班

思路

864. 获取所有钥匙的最短路径

思路

总结

网站公告

今日签到

热门文章

最新发布

dijkstra算法加训上之分层图最短路