RPG游戏的寻路算法——从绯月讲起

Applcu

  L+ g( K/ j* H# @
最近正在玩个游戏，也算是国产之光绯月仙行录，这个游戏哪里都好就是bug太多，并且作者过于摆烂，以至于有很多玩家都认为这个游戏就是故意拖着吃赞助的（bushi）
言归正传，在游玩这个游戏的过程中，我在一个评论区里看到这样一段话：自从玩了绯月之后，对于其他RPG游戏都看不上眼了，因为这个游戏独创了自动寻路的功能，可以说是RPG类游戏的里程碑式壮举。
9 e! B. [1 ^0 U+ t+ V! U9 R. ?, [我对此感到好奇，因为从前从来没有游玩RPG类游戏的经验，但我学过一点点算法，于是我打算用一些浅显易懂的方式说说自动寻路这样一个功能的实现。

主流的寻路算法：深度优先，广度优先，Dijkstra，A* 等，我这里主要讲讲后两种。
4 o. @2 s+ O  ]" z% @
# N0 A5 X1 f7 e- gDijkstra算法：这个算法是目前很多地图软件都在使用的算法，采用OPEN,CLOSE表的方式实现寻路功能。
    创建两个表，OPEN, CLOSE。
OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。
/ T6 o0 L- ]6 u/ c$ z3 r, O/ q2 W3 H1． 访问路网中里起始点最近且没有被检查过的点，把这个点放入OPEN组中等待检查。
2． 从OPEN表中找出距起始点最近的点，找出这个点的所有子节点，把这个点放到CLOSE表中。
5 V2 G! u: {: \2 D! V& K6 r& r" F: g3． 遍历考察这个点的子节点。求出这些子节点距起始点的距离值，放子节点到OPEN表中。
4． 重复2，3，步。直到OPEN表为空，或找到目标点。

实际写代码还是比较占行数的，直接给出链接如下。
6 }* l5 R! [/ @- A/ ?参考：https://blog.csdn.net/YiYeZhiNian/article/details/122217450

/ a, ]8 U# R2 G用这个算法，我写过一个课程作业，具体就是对于各个城市的地铁最短路径规划，大致还是比较成功的。先说说个人对于Dijkstra算法设计地铁线路规划：
- B( C& y5 c* _# Q1.首先用爬虫爬到该城市的地铁网络，包含站点名称，该站点经纬度和线路图，并生成excel表格。用该excel表格生成pickle文件，方便直接调用。
2.注册高德地图开发者账号（该功能需要实名），得到一个key用于调用api（每日上限100次，超过付费，我调试到后面不让我调试了...）
3.输入始发地和目的地，并通过api返回两个位置的经纬度坐标。
7 A% ?2 n% T, V9 a, j4.比较两地理位置之间的最近地铁站，并根据Dijkstra算法实现路径规划。
5.Dijkstra算法的本质就是不断选择新顶点并更新已处理表，并将他和邻居节点进行比对，当所有节点都被处理后即为最短路径
% D# _% b6 y3 S/ }$ b! ]5 q至此，已初步完成具体工作流程。

1. def get_nearest_subway(data,longitude1,latitude1):
   . d5 ]. I7 m$ V
2.   #找最近的地铁站
   ( i. Q1 ~# V- q* X/ x! e) F
3.   longitude1=float(longitude1)
   8 t' Z- u4 L' `3 Z4 _' V. v
4.   latitude1=float(latitude1)
   8 T$ S' _0 ]: L
5.   distance=float('inf')
   
6.   nearest_subway=None
   6 g4 h$ M8 S+ {8 |1 G
7.   for i in range(data.shape[0]):
   
8.     site1=data.iloc[i]['name']   
   
9.     longitude=float(data.iloc[i]['longitude'])
   1 o2 r0 ~( Q. d% Q9 R
10.     latitude=float(data.iloc[i]['latitude'])    #分别将经纬度代入，计算与目标之间的欧氏距离
    
11.     temp=geodesic((latitude1,longitude1), (latitude,longitude)).m   #temp对其遍历即可，这里对比各个地铁站的欧氏距离
    / l. R7 T, F3 I3 R" F
12.     if temp<distance:
    
13.      distance=temp
    # Y3 H' V' d4 l: G/ g2 x+ |
14.      nearest_subway=site1
    
15.      return nearest_subway  

复制代码

1. def subway_line(start,end):    #创建点之间的距离
   
2.   file=open('graph.pkl','rb')
   
3.   graph=pickle.load(file)   #现在我们有了各个地铁站之间的距离存储在graph
   * f; h: T  a' V
4.   costs={}    #创建节点的开销表，cost是指从start到该节点的距离
   ; J- E( a. ~) ?
5.   parents={}
   
6.   parents[end]=None
   9 Q6 C* r& B5 D' S' L' V
7.   for node in graph[start].keys():
   
8.     costs[node]=float(graph[start][node])
   & ^. f% F  P5 v4 b3 ^
9.     parents[node]=start
   3 v$ O1 v/ S- ^2 w" ^0 G" Y; h
10.     costs[end]=float('inf')    #终点到起始点距离为无穷大
    ) i. |" Y/ ~# h- M) U9 A3 V- V
11.     processed=[]      #记录处理过的节点list
    
12.     shortest_path=dijkstra(start,end,graph,costs,processed,parents)
    & ]9 L$ J" I$ J  s3 y7 e1 J
13.     return shortest_path

复制代码

1. #计算图中从start到end的最短路径
   0 B! ]. ]& h; \' d6 W
2. def dijkstra(start,end,graph,costs,processed,parents):
   
3.     #查询到目前开销最小的节点
   3 b4 S* x  u6 Y3 S! m
4.     node=find_lowest_cost_node(costs,processed)
   3 h, F, a! u. `2 K, y9 Z& L
5.     #使用找到的开销最小节点，计算它的邻居是否可以通过它进行更新
   
6.     #如果所有的节点都在processed里面 就结束
   
7.     while node is not None:
   
8.     #获取节点的cost
   
9.       cost=costs[node]  #cost 是从node 到start的距离
   
10.       #获取节点的邻居
    
11.       neighbors=graph[node]
    
12.       #遍历所有的邻居，看是否可以通过它进行更新
    
13.       for neighbor in neighbors.keys():
    ' e2 G2 u4 ?! t0 t1 [7 J
14.       #计算邻居到当前节点+当前节点的开销
    4 N( r1 t! w& D2 @/ j
15.         new_cost=cost+float(neighbors[neighbor])
    
16.         if neighbor not in costs or new_cost<costs[neighbor]:
    
17.         costs[neighbor]=new_cost
    # c+ B& m6 e+ v% f
18.         #经过node到邻居的节点，cost最少
    
19.         parents[neighbor]=node
    
20.         #将当前节点标记为已处理
    
21.   processed.append(node)
    
22.   #下一步继续找U中最短距离的节点  costs=U,processed=S
    . C2 p6 X: w# A- g7 [4 @# H
23.   node=find_lowest_cost_node(costs,processed)

复制代码

1. def find_lowest_cost_node(costs,processed):
   - }$ r! s' y( L+ h% w1 {
2.     #初始化数据
   
3.   lowest_cost=float('inf') #初始化最小值为无穷大
     z& n) f( M6 J1 U4 k! K* j& ?
4.   lowest_cost_node=None
   ! p5 ^" l+ L0 T) c3 z
5.     #遍历所有节点
   
6.   for node in costs:
   
7.     #如果该节点没有被处理
   6 p9 t0 J+ G3 @. [9 u) N6 U
8.     if not node in processed:
   
9.       #如果当前的节点的开销比已经存在的开销小，那么更新该节点为最小开销的节点
   
10.       if costs[node]<lowest_cost:
    $ ]" X, h, y2 ]9 l! Y7 x. q
11.       lowest_cost=costs[node]
    % l6 ^4 H2 k. d% f. h
12.       lowest_cost_node=node
    
13.     return lowest_cost_node

复制代码

上面这段基本上搬运的，主要是他代码已经写的很好了，注释也写的不错，但我写的时候爬虫调不出来（反爬虫技术可以的），最后是我手动去地图里找经纬度得到的结果。
$ d6 Q4 z2 I2 M! ^引用：https://blog.csdn.net/fengdu78/article/details/111570695
6 z. C8 @# F8 ^& ]
( o, i4 R9 P4 `' k% v

A*算法：这个算法也是非常著名的算法，与Dijkstra算法相比，增加了启发式函数 ---- 启发函数的好坏直接决定了算法的效率和结果。由此衍生的D*（动态A算法）算法也被广泛运用于各类游戏中。D*的搜索效率高的原因就在于，当计划路径上某点被阻碍，因为是反向指针，可以定位到被堵节点的上一节点。也就是说只需重新搜索很小的一部分，其余部分仍然使用初始规划出的路径，大大提高了重规划的效率。

! f1 r# L! `0 {- k" {. G
! t0 _  ?$ _1 X. Z7 Q额外补充-dfs&bfs逻辑
5 Q4 O6 P2 Q& e# J* u+ \深度搜索（dfs）和广度搜索（bfs）的算法逻辑可以说是最具有代表性的，基本任何有关于寻路的算法都没法绕开他俩。我担心可能没了解这2个算法直接去看Djkta和A*会有些懵逼

* F5 F" T9 w* F% r深度搜索（dfs）
, e9 ^* z# w. U! K
. E1 x3 U& P' S6 H! t" ~" @dfs就和它字面意思一样，是往更深的地方找（deepfound）
它的核心思想很简单：
一直往前走，走不通就回头
  w2 K1 o, _7 n5 w( K5 r! L3 `
3 }3 Z; E! |: T, J6 T! b顺序？当然是长幼啦，有长立长无长立幼 （1会先找2而非6，在2时会先找4而非5 ，直到4发现3 发现无路可走再back回去）
; Z9 T/ S8 u% R" R大致伪代码如下

1. input 地图
   
2. create 已经过点
   
3. create 结果存储
   0 ^' w5 ^* g, c" z. H# Y5 T
4. 
   9 v% z2 W* F  j! d+ h
5. type node{
   , O: X# D8 D+ u( l5 T; t/ o
6. node nextNode[];//下一节点们
   2 V5 l, y3 {5 J- _% N) S1 h1 P2 c
7. nodeval;//节点标记物
   4 U+ F" C/ k8 @4 E- L
8. }
   
9. 
   $ j$ d" W+ R. k8 i" f% `( o
10. 
    7 f0 ~$ w5 B6 `" |
11. //这里开始是函数
    4 X" _4 f7 c9 ]9 p
12. fun dfs（node* nowPoint）
    : k. x9 T1 R) k; Y
13. {
    2 }" \8 Z$ x  v0 u# x$ I
14. define u 为 nextNode[] size
    
15. int  key;
    6 w" W' _, E: [/ ]
16. 
    
17. for i in u {
    ( y. o: w- W0 f! }5 T$ S, _1 @  ^
18.       if (nowPoint.noteval == target)
    
19.         {
    
20.             结果存储[0] = nowPoint.noteval；
    * g+ o* F* x! `" R: e8 ^2 p$ [# i5 _
21.             return 0 ；
    
22.         }  
    
23.       else if( key = (dfs(nowPoint->nextNode[i])) != -1 ) //如果dfs这次没有返回负1（即 找到终点了）
    
24.             {
    
25.                 结果存储[key] = nowPoint.noteval；
    
26.                 return key+1；         
    % \6 a# v2 s* o$ O& q" q
27.             }   
    
28.         else
    
29.             {
    ( ]1 n/ F2 r! i  Z) |) s# t% z% n* r
30.                 /********************/
    
31.                 /**        nothing          **/
    1 A1 E  C7 Q( A4 }
32.                 /********************/
    1 F: T" o' y/ ~
33.             }   
    
34. 
    2 p% @4 b( j- J$ i
35.         
    . o8 e% t/ o; Q4 M5 v: v' _
36.    }   
    ) D- ?: t8 G: D0 W) B- w
37.     return -1；
      u, `. ?3 P8 B6 w8 F* U
38. }
    

复制代码

就那么短，你只需要确定是不是就行了
是不是很简单：p 但是这就是一个比较原始的寻路算法的模样-顺其自然流
: _" w. L# d$ |
在dfs算法中，你需要做的就是 询问+上抛
7 A8 x$ k8 l( U  O/ K/ K+ ]5 @当然，dfs算法唯一能保证的就是‘找得到路’，这也是为什么纯粹的dfs算法不常用于生产环境中
" T0 C: d( u* y6 ]% v, F5 W% U
, c$ d& ^' |- |1 X4 r* K
广度搜索（bfs）
% T% u, g0 j" r# N, ^  O! u: H知道深度，广度就很容易联想了 先找周围嘛 无论如何，先找周围
+ a. l$ D. c* @5 v; g4 c
. ?6 D' I: t: x2 j. ~+ ?这里不进行代码补充了，只简单地说一下逻辑

这个算法分以下几步：
0，准备一个队列（就是那个queue），然后丢入我们的起点 命运的齿轮开始拨动

1，询问当前节点是否终点？
, C0 L  L% {. p2，将自己的nextNode 塞入队列中（除了访问过的）
3，从队列里output一个节点，作为下一个‘当前节点’

! l, _. d. H2 e. {  \然后就是循环1~3
) n4 p) q# G' t) o" b5 D& j( K* k
是不是很简单？

这2个算法都属于随性流，一个适合终点远一个适合终点近。但无论如何这俩都暂时没有比较最优的功能
: ~' o1 x' U5 N" J# \因为他们刚~满~十~八~岁~的审敛条件就只是找得到路

2 A9 ~- C3 S3 c% z6 ?7 _: z但你可以发现哦？如果将dfs的‘长幼判断’换成‘最优判断’，将呆值传递换为矩阵存储 就是dj算法了诶（a*也是类似的）
而bfs作为‘扩散式搜索’显然地在进行多点寻路时效用更加明显
如果觉得寻路算法很难的话，不妨先从dfs&bfs开始了解
1 y6 y8 v  f! K1 G% f5 ]' j. F
6 U5 O0 X2 Q' e
! D8 t& \  I8 X. y

1 R3 l6 B9 |$ k. ]- e% k" [

navebayes

Applcu 发表于 2023-12-25 20:19
  T/ d; M% {5 ]7 o' ]我在想怎么算说明运作逻辑.....真贴上去么？这个编辑器到底怎么用啊
...

有一个代码框功能，可以用那个。主要编辑的话建议用正八经的md编辑器（我用的是国产的typora）

昔有佳人公孙氏

navebayes 发表于 2023-12-25 20:11
申请失败，原因：对算法本身描述过少，请更具体地说明算法的运作逻辑和方式，如果可以最好给出部分低代码

...

9 X: J6 p9 ~; d啊这。不如解释一下单源最短路径问题中对于负权值和负权值回路为什么不能使用上述算法
7 a7 [# m  u* v7 R# @) D
这玩意考试考得头昏脑涨，我tm 深度生成树画错了，越想越气 怎么会这么蠢

Applcu

昔有佳人公孙氏 发表于 2023-12-25 23:08
& b- E" K6 w3 u% ?5 p# F3 U0 D其实目前，本科生能接触到的寻路算法 无外乎迪杰斯特拉和弗洛伊德 一个不吃负值 一个不吃负环
但其实寻找最 ...

黏菌那个早有耳闻，确实是大自然的力量。我之后还想写点加密算法，比如ＡＥＳ，ＲＳＡ，ＥＣＣ之类的，其实这个地铁的算法也是我的一个课设，我大概花了两天就搞完了，我的主专业课是自控／单片机／数电／模电／嵌入式之类的，更偏自动化这个方向，算法我研究的不深。这个当毕业论文可能还是有一些勉强的，个人感觉工科是要做出一点实物的东西，当然不同学校可能要求不尽相同。

" ], i" q  H1 l0 r9 Q' }
; r5 e4 O' j6 F; C

Applcu

先说说个人对于Dijkstra算法设计地铁线路规划：
' @+ r# t- f6 Y7 D& A  T7 \, B1.首先用爬虫爬到该城市的地铁网络，包含站点名称，该站点经纬度和线路图，并生成excel表格。用该excel表格生成pickle文件，方便直接调用。
0 R% y0 n$ r) K1 P# g2.注册高德地图开发者账号（该功能需要实名），得到一个key用于调用api（每日上限100次，超过付费，我调试到后面不让我调试了...）
# H9 }8 u9 W  J: j2 r' i  l3.输入始发地和目的地，并通过api返回两个位置的经纬度坐标。
3 G' V2 O9 i9 A9 C5 ]4.比较两地理位置之间的最近地铁站，并根据Dijkstra算法实现路径规划。
5.Dijkstra算法的本质就是不断选择新顶点并更新已处理表，并将他和邻居节点进行比对，当所有节点都被处理后即为最短路径
至此，已初步完成具体工作流程。
5 s$ t* D7 Y9 f: H* k) K2 a

1. def get_nearest_subway(data,longitude1,latitude1):
   
2.     #找最近的地铁站
   ' F% p' M5 a/ c/ j
3.     longitude1=float(longitude1)
   0 _! m% b6 U. a
4.     latitude1=float(latitude1)
   
5.     distance=float('inf')
   8 Q+ e3 b" V5 F. t4 U$ p" _+ Z- ~
6.     nearest_subway=None
   
7.     for i in range(data.shape[0]):
   4 W" {4 C2 G- S7 N* \+ A0 r# X
8.   site1=data.iloc[i]['name']   
   
9.   longitude=float(data.iloc[i]['longitude'])
   1 r+ N* D. k9 L# s! _
10.   latitude=float(data.iloc[i]['latitude'])    #分别将经纬度代入，计算与目标之间的欧氏距离
    
11.   temp=geodesic((latitude1,longitude1), (latitude,longitude)).m   #temp对其遍历即可，这里对比各个地铁站的欧氏距离
    
12.   if temp<distance:
    5 M! T9 F, v5 U! R1 G" p$ g
13.     distance=temp
    5 Y# T* `4 U& c6 X, a, l# o* C) k9 G
14.     nearest_subway=site1
    . X- X$ U. j" R- G/ H' V
15.     return nearest_subway  

复制代码

1. def subway_line(start,end):    #创建点之间的距离
   
2.     file=open('graph.pkl','rb')
   
3.     graph=pickle.load(file)   #现在我们有了各个地铁站之间的距离存储在graph
   
4.     costs={}    #创建节点的开销表，cost是指从start到该节点的距离
   3 y! A3 m: ]6 @8 t1 \
5.     parents={}
   
6.     parents[end]=None
   % b5 I6 A4 K  V: i9 o, F- o' l" O
7.     for node in graph[start].keys():
   - m: I( k) \- C
8.   costs[node]=float(graph[start][node])
   - m; \+ L4 N4 M- D- v5 A/ ^! u5 T
9.   parents[node]=start
   / ]# a' n' L% u0 L  k: e: @8 Y" G7 O
10.     costs[end]=float('inf')    #终点到起始点距离为无穷大
    
11.     processed=[]      #记录处理过的节点list
    ! e- E0 b6 z2 b$ d# M) d7 u: y
12.     shortest_path=dijkstra(start,end,graph,costs,processed,parents)
    * s3 g$ |# {; D9 S
13.     return shortest_path

复制代码

1. #计算图中从start到end的最短路径
   
2. def dijkstra(start,end,graph,costs,processed,parents):
   9 |* z. g8 X7 S& K6 q- D
3.     #查询到目前开销最小的节点
   4 v0 u! H: h1 }8 p7 t5 B" @
4.     node=find_lowest_cost_node(costs,processed)
   6 y6 C' ?% O- i1 Z0 \
5.     #使用找到的开销最小节点，计算它的邻居是否可以通过它进行更新
   
6.     #如果所有的节点都在processed里面 就结束
   
7.     while node is not None:
   
8.   #获取节点的cost
   8 |* L1 w6 S! i( i6 l- U
9.   cost=costs[node]  #cost 是从node 到start的距离
   6 s& G7 Q. {5 W6 V. I! @$ [
10.   #获取节点的邻居
    4 {* d* ~3 m4 b* H& f# S) K/ F8 X
11.   neighbors=graph[node]
    . Q1 W+ t' u, n8 V5 _& I" k
12.   #遍历所有的邻居，看是否可以通过它进行更新
    0 u" Z  j, B, ]  ~* E' K
13.   for neighbor in neighbors.keys():
    - d& F3 z) @2 ~+ a' M. w: ?- c
14.     #计算邻居到当前节点+当前节点的开销
    
15.     new_cost=cost+float(neighbors[neighbor])
    ) v3 S3 r2 {, H7 }! f5 ]
16.     if neighbor not in costs or new_cost<costs[neighbor]:
    " h: L* e5 _' M6 P* `  \& k/ Z& a& [
17.       costs[neighbor]=new_cost
    & G6 L4 H+ c$ T! C  O
18.       #经过node到邻居的节点，cost最少
    
19.       parents[neighbor]=node
    . o3 X' A* T/ K1 M4 t
20.   #将当前节点标记为已处理
    
21.   processed.append(node)
    
22.   #下一步继续找U中最短距离的节点  costs=U,processed=S
    4 J( ?. P2 z; h6 n0 T
23.   node=find_lowest_cost_node(costs,processed)

复制代码

  Q8 F; ]) C8 V- z. K3 ^

1. def find_lowest_cost_node(costs,processed):
   - A  c- |1 e( X4 r( B" ]! U
2.     #初始化数据
   ) h: u; W" u, T* U( B5 n
3.     lowest_cost=float('inf') #初始化最小值为无穷大
   * W$ @* d) k- }4 |  Q4 q2 e
4.     lowest_cost_node=None
   
5.     #遍历所有节点
   
6.     for node in costs:
   
7.   #如果该节点没有被处理
   
8.   if not node in processed:
   
9.     #如果当前的节点的开销比已经存在的开销小，那么更新该节点为最小开销的节点
   ; e! G7 [: n5 V% c( y
10.     if costs[node]<lowest_cost:
    4 W) e1 b. |- i: M9 S( u% ]3 e
11.       lowest_cost=costs[node]
    4 e& ~$ V$ D# S, M) V
12.       lowest_cost_node=node
    
13.     return lowest_cost_node

复制代码

上面这段基本上搬运的，主要是他代码已经写的很好了，注释也写的不错，但我写的时候爬虫调不出来（反爬虫技术可以的），最后是我手动去地图里找经纬度得到的结果。
! ~2 C$ _1 }" f2 u( O, o, |8 a' E3 K* ~引用：https://blog.csdn.net/fengdu78/article/details/111570695

navebayes

- L" M/ G, I$ {. y. p. |) \
申请失败，原因：对算法本身描述过少，请更具体地说明算法的运作逻辑和方式，如果可以最好给出部分低代码

( Z3 R6 n* w7 ^; U5 j) aps：只要做滴好，王爷有赏啊

Applcu

navebayes 发表于 2023-12-25 20:11
* U7 `  j% s/ `# F, F申请失败，原因：对算法本身描述过少，请更具体地说明算法的运作逻辑和方式，如果可以最好给出部分低代码
  v: `' m  ]5 a5 Z3 L1 K, X. @& g
...

3 x4 E0 F$ g' B4 @& i4 N* S我在想怎么算说明运作逻辑.....真贴上去么？这个编辑器到底怎么用啊
( x7 F3 I, U! x& {6 u5 c

navebayes

昔有佳人公孙氏 发表于 2023-12-25 20:25
啊这。不如解释一下单源最短路径问题中对于负权值和负权值回路为什么不能使用上述算法

这玩意考试考得头 ...

8 D% O) c9 c6 V  y看作者本人嘛，我不想干涉思路..
（程序：哥们这可不是什么负权圈，这是时空之门啊啊啊啊啊（然后获得了每过一年减一岁的黄金体验））

Applcu

昔有佳人公孙氏 发表于 2023-12-25 20:25
啊这。不如解释一下单源最短路径问题中对于负权值和负权值回路为什么不能使用上述算法

9 h5 z7 p2 q# A& F8 |这玩意考试考得头 ...

  ]+ e1 g; t& k% i3 U, f这应该是考专业课考破防了
: j! ~' a* D8 @

Applcu

昔有佳人公孙氏 发表于 2023-12-25 20:25
啊这。不如解释一下单源最短路径问题中对于负权值和负权值回路为什么不能使用上述算法

这玩意考试考得头 ...

3 e4 K' O. J6 M$ U/ W  b3 _  a负权不就卡bug了么，越来越低就成环了

navebayes

Applcu 发表于 2023-12-25 20:48
% o- L7 P5 j9 {  Q. U3 l负权不就卡bug了么，越来越低就成环了

' c. z9 N2 x& c# G) ?宝宝，把剩下的内容补上嘛

Applcu

navebayes 发表于 2023-12-25 20:56
! k: K$ O8 K' {2 x2 @宝宝，把剩下的内容补上嘛

$ H3 P4 y9 D% e+ G' X5 K) ^8 k5 f* A5 r真是男童啊.....
9 a7 w6 y+ X" r+ s4 W4 c' V' [+ _

navebayes

Applcu 发表于 2023-12-25 21:15
真是男童啊.....

' _: b; W, ^$ B# i) p4 x诽谤管理封七天

navebayes

Applcu 发表于 2023-12-25 21:58
先说说个人对于Dijkstra算法设计地铁线路规划：
" e3 X. ~' J+ T! G4 J: }1.首先用爬虫爬到该城市的地铁网络，包含站点名称，该站点 ...

& y. _% @9 n: A* c5 X9 m4 x  v+ }可以加入正文喵
( U( m4 a" Q9 O% }# M: G/ M* g0 A

Applcu

昔有佳人公孙氏 发表于 2023-12-25 20:25
啊这。不如解释一下单源最短路径问题中对于负权值和负权值回路为什么不能使用上述算法

3 S5 {2 W: i% ]这玩意考试考得头 ...

& U: V" @- q3 I/ d' Y+ K我也头大了.....但本质还是因为Dijkstra算法认为，如果有一条最短路线可以直达目的地，那么从旁边走另外的路将会直接不考虑，但在负权边这里，反而会减小cost，所以Dijkstra算法失效了，因为无法发现这条最短的路径
- a9 O. L2 }! ?7 p) ^

Applcu

navebayes 发表于 2023-12-25 22:34
可以加入正文喵

6 C4 a7 y" P' I5 {- i加了加了
+ S* o) b" u7 A( B# d6 i6 x/ Q

navebayes

Applcu 发表于 2023-12-25 22:51
8 b" V+ x! z' e6 ~加了加了

- r* V3 Y7 E/ B; D介意让我改一下吗https://pic.imgdb.cn/item/6589996fc458853aef070f38.gif

昔有佳人公孙氏

其实目前，本科生能接触到的寻路算法 无外乎迪杰斯特拉和弗洛伊德 一个不吃负值 一个不吃负环
* j) @0 n- @& N$ W( N但其实寻找最短路径的算法里还有很知名的黏菌算法。
有兴趣的可以去B站搜搜黏菌走迷宫，看看在大自然顶级的算法编辑下的单源最短路径问题的解法
不是说将奖励放置位置对应于日本的各大城市，两天内的黏菌路线就基本和目前日本的城市规划大致相似了吗，当然不太严谨是真的
9 b; w' t2 T2 P' A& x6 i. e就好像楼主说的做了地铁最短路径规划， 这玩意我舍友和你类似，她做的事全国铁路路径规划，涉及到价格，时间，反正做到最后是你输入起始地址和目的地，就能得出花费最少，时间最少，转站最少的路线，C++课设 我记得很清楚，我记得老师说的评价是，如果再加上运筹学的内容，说不定可以当毕业论文了，不出意外她拿了满分。

Applcu

navebayes 发表于 2023-12-25 23:02
介意让我改一下吗

/ `; I' [! Z9 Y7 m7 K' {可以可以

navebayes

Applcu 发表于 2023-12-25 23:30
) _3 _) e" _  L& P1 W可以可以

排版改了下喵，东西加好了喵