BFS+队列优先

AI音视频处理:视频分割与语义识别技术解析
WAJUEJI which home strong!
时间限制:1000 ms  |  内存限制:65535 KB
难度:2
描述
在一个山沟里,姐弟俩同时考上了大学。但由于家里拮据,所以这并不是什么好消息。父亲对孩子说:我就是砸锅卖铁也要把你们姐俩供出来。 当时的姐姐已经决定放弃上学的机会。 没想到第二天天还没亮,弟弟就偷偷带著几件破衣服和几个乾巴馒头走了,在姐姐枕边留下一个纸条: 姐,你别愁了,考上大学不容易,我出去打工供你。弟。 姐姐握著那张字条,趴在炕上,失声痛哭。 那一年,弟弟17岁,姐姐20岁。 姐姐用父亲满村子借的钱和弟弟在工地裏搬水泥挣的钱终於读到了大三。 一天姐姐正在寝室里看书,同学跑进来对姐姐说,有个老乡在找你。姐姐很纳闷,走出去后,远远地看见弟弟,穿著满身是水泥和沙子的工作服。姐姐说,你怎么和我同学说你是我老乡啊? 他笑著说,你看我穿的这样,说是你弟,你同学还不笑话你? 姐姐鼻子一酸,眼泪就落了下来。弟弟赶忙为姐姐擦掉眼泪,说:姐,你别哭,我这次来是想让你帮我打听一下,学挖掘机哪家强? 
 
在你的帮助下,弟弟踏上了去蓝翔的路。
那么问题就来了。


输入
第一个数T,T组测试数据。
两个数 n, m; ( 0< n , m <= 100 ) 表示一个h行m列的二维地图。
接下来n行每行m 个字符。
‘s’ 表示弟弟目前所在位置。
‘# ’表示此处为一座山。为了节省体力,不从此处通行。
从‘A’-‘Z’表示各地的经济水平,对应1-26,路过对应字符的地区需要交对应的生活费。
‘l’表示蓝翔技校的所在地。
s 与 l 均为小写字母。
弟弟只能走四个方向。
输出
输出一个数表示弟弟到达蓝翔需要的生活费最小是多少。
如果不能到达,输出 -1。
样例输入
3
3 5
#sVGF
A##ZA
lCDBC
3 3
sAB
ABS
ABl
3 3
s#B
###
ABl
样例输出
48
4
-1






20 20
#sAGFHFNC#VSVDB#HGF#
FDN#FS#VDB#FDD#NGFGG
##DBCDSACGDGDHFAK#TJ
FSBDBFBFNFNSFETHUIKI
SGBDNABGNBGJUKIMFNFS
####HDHFGHFHFJ#HGDFH
HFDHFBFNF#BFNFNHFFND
#DGDHFHNFG####HFHFHF
HFHFGHFHF#DHFGHFHFHF
HFASUIOGSBFGJUJMUSGD
#DDHD#HFHJFDGHT#BFHD
MGMG#HFHJFJNFJGJJGHJ
##FHFJHFJFJSMILOLOGJ
##DHFHFJFJFGJFJFFJH#
HDFJUKIOOODFNSHGOOI#
GDJYJGJKKUUJGSGDSGTD
MGMG#FJHFHJDHFHFHFFH
RKJAJULKIFJILF#HF###
HFHFKUSHFGJG########
SDGHDFHFJHFl##DHDHDH


165
/*************************************/
20 40
#sAGFHFNC#VSVDB#HGF#FDN#FS#VDB#FDD#NGFGG
FDN#FS#VDB#FDD#NGFGGFDN#FS#VDB#FDD#NGFGG
##DBCDSACGDGDHFAK#TJSGBDNABGNBGJUKIMFNFS
FSBDBFBFNFNSFETHUIKISGBDNABGNBGJUKIMFNFS
SGBDNABGNBGJUKIMFNFSSGBDNABGNBGJUKIMFNFS
####HDHFGHFHFJ#HGDFHGDJYJGJKKUUJGSGDSGTD
HFDHFBFNF#BFNFNHFFNDMGMG#FJHFHJDHFHFHFFH 
#DGDHFHNFG####HFHFHF####HDHFGHFHFJ#HGDFH
HFHFGHFHF#DHFGHFHFHF####HDHFGHFHFJ#HGDFH
HFASUIOGSBFGJUJMUSGDSDGHDFHFJHFD##DHDHDH
#DDHD#HFHJFDGHT#BFHDGDJYJGJKKUUJGSGDSGTD
MGMG#HFHJFJNFJGJJGHJSDGHDFHFJHFD##DHDHDH
##FHFJHFJFJSMILOLOGJ####HDHFGHFHFJ#HGDFH
##DHFHFJFJFGJFJFFJH#SGBDNABGNBGJUKIMFNFS
HDFJUKIOOODFNSHGOOI#MGMG#FJHFHJDHFHFHFFH 
GDJYJGJKKUUJGSGDSGTDFSBDBFBFNFNSFETHlIKI
MGMG#FJHFHJDHFHFHFFHSDGHDFHFJHFD##DHDHDH 
RKJAJULKIFJILF#HF###SGBDNABGNBGJUKIMFNFS
HFHFKUSHFGJG########MGMG#FJHFHJDHFHFHFFH 
SDGHDFHFJHFD##DHDHDHGDJYJGJKKUUJGSGDSGTD


282


#include "iostream"
#include "queue"
using namespace std;
struct now{
	int x,y,time;
};
bool operator <(now a,now b){
	return a.time>b.time;
};
int main(){
	int go[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
	int n,m;
	char c[150][150];
	bool book[150][150];
	int i,t,j,k;
	cin>>t;
	for(i=0;i<t;i++){
		cin>>n>>m;
		for(j=0;j<n;j++)
		for(k=0;k<m;k++)
		book[j][k]=0;
		 now start;
		for(j=0;j<n;j++)
			for(k=0;k<m;k++){
		    	cin>>c[j][k];
		   	if(c[j][k]=='s'){
		   		start.x=j;
		  	 	start.y=k;
		   	 	 start.time=0;
		   	}
	}	
		priority_queue<now> q;
		book[start.x][start.y]=1;
		while(!q.empty())  q.pop();
		q.push(start);
		book[start.x][start.y]=1;
		int sum=-1;
		while(!q.empty()){
			now step,next;
			step=q.top();
			q.pop();
			//cout<<step.x<<" "<<step.y<<" "<<step.time<<" "<<c[step.x][step.y]<<endl;
			for(j=0;j<4;j++){
				int a=step.x+go[j][0];
				int b=step.y+go[j][1];
				if(a<0||a>=n||b<0||b>=m||c[a][b]=='#'||book[a][b]==1)
				continue;
				if(c[a][b]=='l')
				{
					sum=step.time;
					break;
				}
				book[a][b]=1;
				next.x=a;
				next.y=b;
				next.time=c[a][b]-'A'+1+step.time;
				q.push(next);
			}
			if(sum>-1)
			break;
		}
		if(sum>-1)
		cout<<sum<<endl;
		else
		cout<<-1<<endl;
	}
	return 0;
}


非常好!你希望我们**不使用 Dijkstra 的标准逻辑**,但又要使用 **BFS + 优先级队列** 来模拟 Dijkstra 的行为。我们可以使用 `priority_queue`(优先队列)来实现一个**模拟 Dijkstra 行为的 BFS 算法**,虽然它本质上仍然是 Dijkstra,但我们可以从“广度优先 + 优先级”的角度去理解它。 --- ## ✅ 思路说明 我们仍然使用优先队列优先处理当前“距离最短”的节点,这与 Dijkstra 是一致的。但我们将它看作是一种“带优先级的 BFS”,也就是: - 使用 BFS 的结构(队列) - 使用优先队列来保证先处理当前最优路径的节点 - 不使用 Dijkstra 的“松弛”术语,而是理解为“发现更短路径就更新并继续处理” --- ## ✅ 完整代码实现(使用 BFS + 优先级队列) 我们仍然保留你原来的变量名和结构,仅将 `bfs()` 改写为使用优先队列的版本: ```cpp #include <bits/stdc++.h> using namespace std; struct node { int to, next, cost; } edge[200005]; int head[300005], tot, n, m, f[200005], s, t, a, b, c; void add(int x, int y, int z) { edge[++tot] = {y, head[x], z}; head[x] = tot; } void bfs_with_priority_queue() { const int INF = 0x3f3f3f3f; int dist[300005]; memset(dist, 0x3f, sizeof(dist)); dist[s] = 0; // 使用优先队列模拟 BFS优先级扩展 priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq; pq.push({0, s}); while (!pq.empty()) { int u = pq.top().second; int d = pq.top().first; pq.pop(); if (d > dist[u]) continue; // 已经处理过更短路径,跳过 for (int i = head[u]; i; i = edge[i].next) { int v = edge[i].to; int w = edge[i].cost; if (dist[v] > dist[u] + w) { dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } cout << dist[t] << endl; } int main() { cin >> n >> m >> s >> t; for (int i = 1; i <= m; i++) { cin >> a >> b >> c; add(a, b, c); add(b, a, c); } bfs_with_priority_queue(); return 0; } ``` --- ### ✅ 示例输入 ``` 7 11 5 4 2 4 2 1 4 3 7 2 2 3 4 3 5 7 5 7 3 3 6 1 1 6 3 4 2 4 3 5 6 3 7 2 1 ``` ### ✅ 示例输出 ``` 7 ``` 路径:`5 → 6 → 1 → 4`,费用为 `3 + 1 + 3 = 7` --- ### ✅ 代码解释 - 我们仍然使用 `bfs()` 的结构,但使用 `priority_queue` 而不是普通 `queue` - 每次从队列中取出当前“路径最短”的节点进行扩展 - 如果发现更短路径就更新 `dist[]`,并将该节点重新入队 - 最终 `dist[t]` 即为从起点 `s` 到终点 `t` 的最小费用路径 --- ### ✅ 时间复杂度分析 - 使用优先队列优化的最短路径算法,时间复杂度为: **O((N + M) log N)**,适用于本题的数据范围。 --- ### ✅ 这是 Dijkstra 吗? 是的,从实现角度看,这就是 Dijkstra 算法。但从你的角度,我们将其理解为: > 使用 BFS 的结构 + 优先级队列保证优先级,来模拟 Dijkstra 的行为。 --- ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值