javascript A*算法 寻路算法 获取最短路径算法

  1 //A算法 自动寻路 路径
  2 class GetAutoPath{
  3
  4     constructor(id, map, sPos, ePos, mapArr){
  5         //this.type = id.type;
  6         this.id = id;
  7         this.map = map;
  8         this.sPos = sPos;
  9         this.ePos = ePos;
 10         this.mapArr = mapArr;
 11         this.maxMach = 10000;
 12         this.openArr = [];
 13         this.closeArr = [];
 14         this.minPath = [];
 15         if(!this.isPath(this.sPos.x, this.sPos.y)){this.sPos = this.getNewDot(sPos, ePos);}
 16         if(!this.isPath(this.ePos.x, this.ePos.y)){this.ePos = this.getNewDot(ePos, sPos);}
 17         //console.log(this.mapArr);
 18         return this.run();
 19     }
 20
 21     posts(txt, arr){//post消息
 22         //let id = this.id, sPos = this.sPos, ePos = this.ePos, arrs = arr || [];
 23         return {id:this.id, map:this.map, arr:arr || [], sPos:this.sPos, ePos:this.ePos, txt:txt}
 24     }
 25
 26     isPath(x, y){//isPath = true 合法路径 = isBanPath === undefined
 27         let isPath = false, ym = this.mapArr.get(y), xm; //console.log(ym);  debugger;
 28         if(ym !== undefined){
 29             xm = ym.get(x);
 30             if(xm !== undefined){
 31                 if(xm.isBanPath === undefined){isPath = true;}
 32             }
 33         }
 34         //if(this.mapArr[y] !== undefined && this.mapArr[y][x] !== undefined && this.mapArr[y][x].isPath === 1){isPath = true;}
 35         return isPath;
 36     }
 37
 38     getEqual(arr, x, y){//获取目标数组相同的坐标
 39         let isPos = false;
 40         if(arr.length === 0){
 41             isPos = false;
 42         }else{
 43             isPos = arr.some(function (o){return o.x === x && o.y === y;});
 44         }
 45         return isPos;
 46     }
 47
 48     getDot(x, y){//获取周围8个方向坐标
 49         return [{x:x-1,y:y},{x:x+1,y:y},{x:x,y:y-1},{x:x,y:y+1},{x:x-1,y:y-1},{x:x+1,y:y+1},{x:x+1,y:y-1},{x:x-1,y:y+1}]
 50     }
 51
 52     getNewDot(setPos, pos){//重定义起点或终点
 53         let dot = setPos, pointDot, k, arr = [], arrs = [], g, end, maxMachT = 0;
 54         while(!end && maxMachT < this.maxMach){
 55             maxMachT++;
 56             pointDot = this.getDot(dot.x, dot.y);
 57             for(k in pointDot){
 58                 g = Math.round(Math.sqrt(Math.abs(pointDot[k].x - pos.x) + Math.abs(pointDot[k].y - pos.y)) * 100) / 100;
 59                 if(!this.isPath(pointDot[k].x, pointDot[k].y)){//不合法
 60                     arr.push({x:pointDot[k].x, y:pointDot[k].y, g:g});
 61                     arr.sort(function(a, b){return a.g - b.g;});
 62                 }else{//合法
 63                     arrs.push({x:pointDot[k].x, y:pointDot[k].y, g:g});
 64                     arrs.sort(function(a, b){return a.g - b.g;});
 65                 }
 66                 if(arrs.length > 0){end = true;}
 67             }
 68             dot = {x:arr[0].x, y:arr[0].y, g:arr[0].g}; arr = [];
 69         }
 70         if(!arrs[0].x || !arrs[0].y){return this.posts("没有符合的坐标");}
 71         return {x:arrs[0].x, y:arrs[0].y};
 72     }
 73
 74     run(){
 75         if(this.sPos.x === undefined || this.ePos.x === undefined){return this.posts("没有符合的坐标");}
 76         let sPos = this.sPos, ePos = this.ePos, point, key, i, newPoint, ger, gers, g, h, f, maxMachT = 0;
 77         this.openArr[0] = {x : sPos.x, y : sPos.y, f : 0, p : 0, ger : 0}
 78         while(this.openArr.length > 0){
 79             maxMachT++;
 80             point = this.openArr[0]; this.closeArr.push(point); this.openArr.splice(0,1);
 81             key = this.closeArr.length - 1;//设置当前节点
 82             newPoint = this.getDot(point.x, point.y);//获取周围点
 83             for(i in newPoint){//设置周围点
 84                 ger = Math.round(Math.sqrt(Math.abs(newPoint[i].x - point.x) + Math.abs(newPoint[i].y - point.y)) * 100) / 100;//到当前节点的曼哈顿距离,保留两位小数点
 85                 gers = ger + point.ger;
 86                 g = Math.round(gers * 100) / 100;
 87                 h = Math.abs(newPoint[i].x - ePos.x) + Math.abs(newPoint[i].y - ePos.y);
 88                 f = g + h;
 89                 if(this.isPath(newPoint[i].x, newPoint[i].y) && !this.getEqual(this.openArr, newPoint[i].x, newPoint[i].y) && !this.getEqual(this.closeArr, newPoint[i].x, newPoint[i].y)){this.openArr.push({x:newPoint[i].x, y:newPoint[i].y, f:f, p:key, ger:ger});}
 90             }
 91             this.openArr.sort(function(a, b){return a.f - b.f;});//排序
 92             if(this.getEqual(this.closeArr, ePos.x, ePos.y) || this.getEqual(this.openArr, ePos.x, ePos.y)){//end
 93                 this.minPath.unshift(this.closeArr[key]);
 94                 while(this.minPath.length > 0){
 95                     if(this.minPath[0].p == 0){return this.posts(‘success‘, this.minPath);}else{this.minPath.unshift(this.closeArr[this.minPath[0].p]);}
 96                 }
 97             }else if(maxMachT === this.maxMach){
 98                 return this.posts("没有符合的坐标");
 99             }
100         }
101         return this.posts("没有符合的坐标");
102     }
103
104 }

原文地址:https://www.cnblogs.com/weihexinCode/p/12318344.html

时间: 2024-10-18 08:35:25

javascript A*算法 寻路算法 获取最短路径算法的相关文章

【算法日记】Dijkstra最短路径算法

上一篇再说广度优先搜索的适合提到了图. 狄克斯拉特算法是在图的基础上增加了 加权图的概念.就是节点和节点之间是有不同距离的 1.算法实例 用Dijkstra算法找出以A为起点的单源最短路径步骤如下 算法实现 # Dijkstra算法--通过边实现松弛 # 指定一个点到其他各顶点的路径--单源最短路径 # 初始化图参数 G = {1:{1:0, 2:1, 3:12}, 2:{2:0, 3:9, 4:3}, 3:{3:0, 5:5}, 4:{3:4, 4:0, 5:13, 6:15}, 5:{5:0

Dijkstra算法详细(单源最短路径算法)

介绍 对于dijkstra算法,很多人可能感觉熟悉而又陌生,可能大部分人比较了解bfs和dfs,而对dijkstra和floyd算法可能知道大概是图论中的某个算法,但是可能不清楚其中的作用和原理,又或许,你曾经感觉它很难,那么,这个时候正适合你重新认识它. Dijkstra能是干啥的? Dijkstra是用来求单源最短路径的 就拿上图来说,假如直到的路径和长度已知,那么可以使用dijkstra算法计算南京到图中所有节点的最短距离. 单源什么意思? 从一个顶点出发,Dijkstra算法只能求一个顶

图论之最短路径算法

简介: 求最短路径算法中最具代表性的是Dijkstra算法. Dijkstra算法的思想是基于贪心策略的. 概述其过程是通过设置顶点集合S并不断地做贪心选择来扩充集合. 贪心选择的标准是每次都选择从源节点到该节点的路径长度最短. 难点: 网络上博客中大多数人写的最短路径算法大多都是只能寻找到最短的一条路径. 但是很多时候可能存在并列最短的路径,需要找出所有同时最短的路径. 在这里我给大家分享一个时间复杂度大概是O(n2)的算法,求并列最短路径算法. 求出一条最短路径的算法步骤如下: 假设G={V

几个最短路径算法Floyd、Dijkstra、Bellman-Ford、SPFA的比较(转)

几大最短路径算法比较 几个最短路径算法的比较:Floyd        求多源.无负权边(此处错误?应该可以有负权边)的最短路.用矩阵记录图.时效性较差,时间复杂度O(V^3).       Floyd-Warshall算法(Floyd-Warshall algorithm)是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径问题. Floyd-Warshall算法的时间复杂度为O(N^3),空间复杂度为O(N^2). Floyd-Warshall的原理是动态规划:设Di,j

最短路径算法集锦

/* Name: 最短路径算法集锦 Copyright: Author: 巧若拙 Date: 12/11/14 15:32 Description: 列举了深度优先搜索的递归和非递归算法,Dijkstra最短路径算法, 基于Bellman-Fort最短路径算法的改进型广度优先搜索算法, Floyd-Warshall最短路径算法的原始版和变化版 本文是阅读<啊哈!算法>后的学习笔记,代码与教材中有些差异,若有错误请指正,谢谢! 测试数据: 5 7 0 3 2 0 4 9 4 2 1 4 1 3

Johnson 全源最短路径算法

解决单源最短路径问题(Single Source Shortest Paths Problem)的算法包括: Dijkstra 单源最短路径算法:时间复杂度为 O(E + VlogV),要求权值非负: Bellman-Ford 单源最短路径算法:时间复杂度为 O(VE),适用于带负权值情况: 对于全源最短路径问题(All-Pairs Shortest Paths Problem),可以认为是单源最短路径问题的推广,即分别以每个顶点作为源顶点并求其至其它顶点的最短距离.例如,对每个顶点应用 Bel

Floyd-Warshall 全源最短路径算法

Floyd-Warshall 算法采用动态规划方案来解决在一个有向图 G = (V, E) 上每对顶点间的最短路径问题,即全源最短路径问题(All-Pairs Shortest Paths Problem),其中图 G 允许存在权值为负的边,但不存在权值为负的回路.Floyd-Warshall 算法的运行时间为 Θ(V3). Floyd-Warshall 算法由 Robert Floyd 于 1962 年提出,但其实质上与 Bernad Roy 于 1959 年和 Stephen Warshal

SPFA算法-单源最短路径算法

1.介绍: SPFA算法:单源最短路径算法,一种高效的最短路径算法! 2.思路 (1)初始化 1>源点路径为0  :d[s]=0 ,其中s为源点 2>初始化d[N]为无穷大,即d[i]表示,源点s到i为无穷大INF 3>p[N]初始化为源点s或-1,表示没有前驱 (2)队列+松弛 1>读取队头顶点u,并将队头顶点u出队(记得消除标记): 2>将与点u相连的所有点v进行松弛操作,如果能更新估计值(即令d[v]变小),那么就更新; 3>另外,如果点v没有在队列中,那么要将点

关于智能寻路算法的研究,A-Star算法拓展,B星寻路算法

B星算法的原理图: 以下是C语言的一段源码 #ifndef __ASTARPATHFINDER_H__ #define __ASTARPATHFINDER_H__ #include "cocos2d.h" USING_NS_CC; /**  * 横向移动一格的路径评分  */ static const int COST_HORIZONTAL = 20; /**  * 竖向移动一格的路径评分  */ static const int COST_VERTICAL = 5; /**  * 斜