程序什么叫1:1路径不单调ⅹ方向怎样排除

程序什么叫1:1路径不单调ⅹ方向怎样排除,第1张

1:1路径单调ⅹ方向指的是,在一个给定的路径上,沿着某一方向移动时,路径的斜率不能保持一致,而是会发生变化。要排除这种情况,可以采用以下方法:

1 对路径上的每一个点进行检查,确保它们的斜率都是一致的;

2 将路径上的每一个点进行拟合,确保它们的斜率都是一致的;

3 将路径上的每一个点进行拟合,确保它们的斜率都是一致的,并且拟合出的曲线是单调的;

4 将路径上的每一个点进行拟合,确保它们的斜率都是一致的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,并且拟合出的曲线是单调的,

HelloGitHub 分享 GitHub 上有趣、入门级的开源项目。

这里有实战项目、入门教程、黑 科技 、开源书籍、大厂开源项目等,涵盖多种编程语言 Python、Java、Go、C/C++、Swift让你在短时间内感受到开源的魅力,对编程产生兴趣!

1、 toybox :该项目将 200 多个常用的 Linux 命令行工具,做成一个可执行文件。从而可以让 Android 这种原本不支持 Linux 命令的系统,也得以用上 ls、find、ps 等命令。还可以用于快速构建最小的 Linux 环境

2、 the_silver_searcher :比 ack 更快的命令行搜索工具。速度快、功能强大、使用简单,支持 Linux、Windows、macOS *** 作系统,还能够整合进 Vim 和 Emacs 等编辑器

3、 WindTerm :支持 SSH/Telnet/Serial/Shell/Sftp 的终端工具。虽然该软件完全免费,但部分代码尚未完全开源,对安全敏感的同学可以再观望下

4、 wavefunctioncollapse :基于波函数坍缩 (WFC) 算法,实现的无限城市示例。城市里有房子、楼梯、树木、连接房屋的通道,你可以在城市中自由移动、跳跃、飞行,但不论你怎么移动都找不到尽头,因为这座城市会无限延伸

5、 NETworkManager :管理和解决网络问题的工具。它集成了 IP 和端口扫描、WiFi 分析器、跟踪路由、DNS 查询等工具

6、 ppsspp :能够运行在 Android 和 PC 上的开源 PSP 模拟器

7、 leocad :用来创建虚拟乐高模型的 CAD 工具。适用于 Windows、Linux 和 macOS 系统

8、 csshake :用 CSS 实现抖动效果

9、 MangoDB :真正开源的 MongoDB 替代品。它底层采用 PostgreSQL 作为存储引擎,用 Go 语言实现了 MongoDB 协议,所以几乎兼容所有的 MongoDB 库,迁移起来毫无负担。如果你用不到 MongoDB 的高级功能,还受限于它的开源协议,那么这个项目可作为 MongoDB 的开源替代方案。它才刚刚起步,建议观望一段时间或做足测试再用于生产环境

10、 caddy :用 Go 编写的轻量级 Web 服务器。它相较于 Apache、Nginx 这些知名 Web 服务器,独特点在于提供了编译好的可执行文件,实现了真正的开箱即用。无需任何配置即可拥有免费的 >

蚁群算法用于路径规划时的优点:

1、采用正反馈机制,使得搜索过程不断收敛,最终逼近最优秀路线。

2、每个个体可以通过释放信息素来改变周围的环境,且每个个体能够感知周围环境的实时变化,个体间通过环境进行间接地通讯。

3、搜索过程采用分布式计算方式,多个个体同时进行并行计算,大大提高了算法的计算能力和运行效率。

4、启发式的概率搜索方式不容易陷入局部最优,易于寻找到全局最优秀线路。

蚁群算法用于路径规划时的缺点:

如果多样性过剩,系统过于活跃,会导致过多的随机运动,陷入混沌状态。如果多样性不够,正反馈过强,会导致僵化,当环境变化时蚁群不能相应调整。

定义Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等。Dijkstra一般的表述通常有两种方式,一种用永久和临时标号方式,一种是用OPEN,

CLOSE表的方式,这里均采用永久和临时标号的方式。注意该算法要求图中不存在负权边。

问题描述在无向图

G=(V,E) 中,假设每条边 E[i] 的长度为 w[i],找到由顶点 V0 到其余各点的最短路径。(单源最短路径)

编辑本段迪杰斯特拉算法迪杰斯特拉(Dijkstra)算法思想

按路径长度递增次序产生最短路径算法:

把V分成两组:

(1)S:已求出最短路径的顶点的集合

(2)V-S=T:尚未确定最短路径的顶点集合

将T中顶点按最短路径递增的次序加入到S中,

保证:(1)从源点V0到S中各顶点的最短路径长度都不大于

从V0到T中任何顶点的最短路径长度

(2)每个顶点对应一个距离值

S中顶点:从V0到此顶点的最短路径长度

T中顶点:从V0到此顶点的只包括S中顶点作中间

顶点的最短路径长度

依据:可以证明V0到T中顶点Vk的最短路径,或是从V0到Vk的

直接路径的权值;或是从V0经S中顶点到Vk的路径权值之和

(反证法可证)

求最短路径步骤

算法步骤如下:

1 初使时令 S={V0},T={其余顶点},T中顶点对应的距离值

若存在<V0,Vi>,d(V0,Vi)为<V0,Vi>弧上的权值

若不存在<V0,Vi>,d(V0,Vi)为∝

2 从T中选取一个其距离值为最小的顶点W且不在S中,加入S

3 对S中顶点的距离值进行修改:若加进W作中间顶点,从V0到Vi的

距离值缩短,则修改此距离值

重复上述步骤2、3,直到S中包含所有顶点,即W=Vi为止

编辑本段迪杰斯特拉算法的原理首先,引进一个辅助向量D,它的每个分量D表示当前所找到的从始点v到每个终点vi的最短路径的长度。如D[3]=2表示从始点v到终点3的路径相对最小长度为2。这里强调相对就是说在算法过程中D的值是在不断逼近最终结果但在过程中不一定就等于最短路径长度。它的初始状态为:若从v到vi有弧,则D为弧上的权值;否则置D为∞。显然,长度为

D[j]=Min{D | vi∈V} 的路径就是从v出发的长度最短的一条最短路径。此路径为(v,vj)。

那么,下一条长度次短的最短路径是哪一条呢?假设该次短路径的终点是vk,则可想而知,这条路径或者是(v,vk),或者是(v,vj,vk)。它的长度或者是从v到vk的弧上的权值,或者是D[j]和从vj到vk的弧上的权值之和。

一般情况下,假设S为已求得最短路径的终点的集合,则可证明:下一条最短路径(设其终点为X)或者是弧(v,x),或者是中间只经过S中的顶点而最后到达顶点X的路径。因此,下一条长度次短的最短路径的长度必是D[j]=Min{D

| vi∈V-S} 其中,D或者是弧(v,vi)上的权值,或者是D[k](vk∈S)和弧(vk,vi)上的权值之和。 迪杰斯特拉算法描述如下:

1)arcs表示弧上的权值。若不存在,则置arcs为∞(在本程序中为MAXCOST)。S为已找到从v出发的最短路径的终点的集合,初始状态为空集。那么,从v出发到图上其余各顶点vi可能达到的最短路径长度的初值为D=arcs[Locate

Vex(G,v),i] vi∈V 2)选择vj,使得D[j]=Min{D | vi∈V-S} 3)修改从v出发到集合V-S上任一顶点vk可达的最短路径长度。

编辑本段迪杰斯特拉算法C#程序public class Edge

{

public string StartNodeID ;

public string EndNodeID ;

public double Weight ; //权值,代价

} 节点则抽象成Node类,一个节点上挂着以此节点作为起点的“出边”表。

public class Node

{

private string iD ;

private ArrayList edgeList ;//Edge的集合--出边表

public Node(string id )

{

thisiD = id ;

thisedgeList = new ArrayList() ;

}

property#region property

public string ID

{

get

{

return thisiD ;

}

}

public ArrayList EdgeList

{

get

{

return thisedgeList ;

}

}

#endregion

}

在计算的过程中,我们需要记录到达每一个节点权值最小的路径,这个抽象可以用PassedPath类来表示:

/// <summary>

/// PassedPath 用于缓存计算过程中的到达某个节点的权值最小的路径

/// </summary>

public class PassedPath

{

private string curNodeID ;

private bool beProcessed ; //是否已被处理

private double weight ; //累积的权值

private ArrayList passedIDList ; //路径

public PassedPath(string ID)

{

thiscurNodeID = ID ;

thisweight = doubleMaxValue ;

thispassedIDList = new ArrayList() ;

thisbeProcessed = false ;

}

#region property

public bool BeProcessed

{

get

{

return thisbeProcessed ;

}

set

{

thisbeProcessed = value ;

}

}

public string CurNodeID

{

get

{

return thiscurNodeID ;

}

}

public double Weight

{

get

{

return thisweight ;

}

set

{

thisweight = value ;

}

}

public ArrayList PassedIDList

{

get

{

return thispassedIDList ;

}

}

#endregion

}

另外,还需要一个表PlanCourse来记录规划的中间结果,即它管理了每一个节点的PassedPath。

/// <summary>

/// PlanCourse 缓存从源节点到其它任一节点的最小权值路径=》路径表

/// </summary>

public class PlanCourse

{

private Hashtable htPassedPath ;

#region ctor

public PlanCourse(ArrayList nodeList ,string originID)

{

thishtPassedPath = new Hashtable() ;

Node originNode = null ;

foreach(Node node in nodeList)

{

if(nodeID == originID)

{

originNode = node ;

}

else

{

PassedPath pPath = new PassedPath(nodeID) ;

thishtPassedPathAdd(nodeID ,pPath) ;

}

}

if(originNode == null)

{

throw new Exception("The origin node is not exist !")

;

}

thisInitializeWeight(originNode) ;

}

private void InitializeWeight(Node originNode)

{

if((originNodeEdgeList == null)

||(originNodeEdgeListCount == 0))

{

return ;

}

foreach(Edge edge in originNodeEdgeList)

{

PassedPath pPath = this[edgeEndNodeID] ;

if(pPath == null)

{

continue ;

}

pPathPassedIDListAdd(originNodeID) ;

pPathWeight = edgeWeight ;

}

}

#endregion

public PassedPath this[string nodeID]

{

get

{

return (PassedPath)thishtPassedPath[nodeID] ;

}

}

}

在所有的基础构建好后,路径规划算法就很容易实施了,该算法主要步骤如下:

(1)用一张表(PlanCourse)记录源点到任何其它一节点的最小权值,初始化这张表时,如果源点能直通某节点,则权值设为对应的边的权,否则设为doubleMaxValue。

(2)选取没有被处理并且当前累积权值最小的节点TargetNode,用其边的可达性来更新到达其它节点的路径和权值(如果其它节点

经此节点后权值变小则更新,否则不更新),然后标记TargetNode为已处理。

(3)重复(2),直至所有的可达节点都被处理一遍。

(4)从PlanCourse表中获取目的点的PassedPath,即为结果。

下面就来看上述步骤的实现,该实现被封装在RoutePlanner类中:

/// <summary>

/// RoutePlanner 提供图算法中常用的路径规划功能。

/// 20050906

/// </summary>

public class RoutePlanner

{

public RoutePlanner()

{

}

#region Paln

//获取权值最小的路径

public RoutePlanResult Paln(ArrayList nodeList ,string

originID ,string destID)

{

PlanCourse planCourse = new PlanCourse(nodeList

,originID) ;

Node curNode = thisGetMinWeightRudeNode(planCourse

,nodeList ,originID) ;

#region 计算过程

while(curNode != null)

{

PassedPath curPath = planCourse[curNodeID] ;

foreach(Edge edge in curNodeEdgeList)

{

PassedPath targetPath = planCourse[edgeEndNodeID] ;

double tempWeight = curPathWeight + edgeWeight ;

if(tempWeight < targetPathWeight)

{

targetPathWeight = tempWeight ;

targetPathPassedIDListClear() ;

for(int i=0 ;i<curPathPassedIDListCount ;i++)

{

targetPathPassedIDListAdd(curPathPassedIDListToString())

;

}

targetPathPassedIDListAdd(curNodeID) ;

}

}

//标志为已处理

planCourse[curNodeID]BeProcessed = true ;

//获取下一个未处理节点

curNode = thisGetMinWeightRudeNode(planCourse

,nodeList ,originID) ;

}

#endregion

//表示规划结束

return thisGetResult(planCourse ,destID) ;

}

#endregion

#region private method

#region GetResult

//从PlanCourse表中取出目标节点的PassedPath,这个PassedPath即是规划结果

private RoutePlanResult GetResult(PlanCourse

planCourse ,string destID)

{

PassedPath pPath = planCourse[destID] ;

if(pPathWeight == intMaxValue)

{

RoutePlanResult result1 = new RoutePlanResult(null

,intMaxValue) ;

return result1 ;

}

string[] passedNodeIDs = new

string[pPathPassedIDListCount] ;

for(int i=0 ;i<passedNodeIDsLength ;i++)

{

passedNodeIDs = pPathPassedIDListToString() ;

}

RoutePlanResult result = new

RoutePlanResult(passedNodeIDs ,pPathWeight) ;

return result ;

}

#endregion

#region GetMinWeightRudeNode

//从PlanCourse取出一个当前累积权值最小,并且没有被处理过的节点

private Node GetMinWeightRudeNode(PlanCourse

planCourse ,ArrayList nodeList ,string originID)

{

double weight = doubleMaxValue ;

Node destNode = null ;

foreach(Node node in nodeList)

{

if(nodeID == originID)

{

continue ;

}

PassedPath pPath = planCourse[nodeID] ;

if(pPathBeProcessed)

{

continue ;

}

if(pPathWeight < weight)

{

weight = pPathWeight ;

destNode = node ;

}

}

return destNode ;

}

#endregion

#endregion

}

编辑本段迪杰斯特拉算法pascal程序type bool=array[110]of

boolean;

arr=array[010]of integer;

var a:array[110,110]of integer;

//存储图的邻接数组,无边为10000

c,d,e:arr; //c为最短路径数值,d为各点前趋,

t:bool; //e:路径,t为辅助数组

i,j,n,m:integer;

inf,outf:text;

////////////////////////////////////////////////////////////////////////////////

procedure init; //不同题目邻接数组建立方式不一样

begin

assign(inf,'dijkstrain');

assign(outf,'dijkstraout');

reset(inf); rewrite(outf);

read(inf,n);

for i:=1 to n do

for j:=1 to n do

begin

read(inf,a[i,j]);

if a[i,j]=0 then a[i,j]:=10000;

end;

end;

////////////////////////////////////////////////////////////////////////////////

procedure dijkstra(qi:integer; t:bool; var c{,d}:arr);

//qi起点,{}中为求路径部

var i,j,k,min:integer; //分,不需求路径时可以不要

begin //t数组一般在调用前初始

t[qi]:=true; //化成false,也可将部分点

{for i:=1 to n do d[i]:=qi; d[qi]:=0; }

//初始化成true以回避这些点

for i:=1 to n do c[i]:=a[qi,i];

for i:=1 to n-1 do

begin

min:=10001;

for j:=1 to n do

if (c[j]<min)and(not(t[j])) then begin k:=j;

min:=c[j];end;

t[k]:=true;

for j:=1 to n do

if (c[k]+a[k,j]<c[j])and(not(t[j])) then

begin

c[j]:=c[k]+a[k,j]; {d[j]:=k;}

end;

end;

end;

////////////////////////////////////////////////////////////////////////////////

procedure make(zh:integer; d:arr; var e:arr);

//生成路径,e[0]保存路径

var i,j,k:integer; //上的节点个数

begin

i:=0;

while d[zh]<>0 do

begin

inc(i);e[i]:=zh;zh:=d[zh];

end;

inc(i);e[i]:=qi; e[0]:=I;

end;

主程序调用:求最短路径长度:初始化t,然后dijkstra(qi,t,c,d)

求路径:make(m,d,e) ,m是终点

编辑本段Dijkstra算法的堆优化(PASCAL实现)一、思考

我们可以发现,在实现步骤时,效率较低(需要O(n),使总复杂度达到O(n^2)。对此可以考虑用堆这种数据结构进行优化,使此步骤复杂度降为O(log(n))(总复杂度降为O(n

log(n))。

二、实现

1 将与源点相连的点加入堆,并调整堆。

2 选出堆顶元素u(即代价最小的元素),从堆中删除,并对堆进行调整。

3 处理与u相邻的,未被访问过的,满足三角不等式的顶点

1):若该点在堆里,更新距离,并调整该元素在堆中的位置。

2):若该点不在堆里,加入堆,更新堆。

4 若取到的u为终点,结束算法;否则重复步骤2、3。

三、代码

procedure Dijkstra;

var

u,v,e,i:longint;

begin

fillchar(dis,sizeof(dis),$7e); //距离

fillchar(Inh,sizeof(Inh),false); //是否在堆中

fillchar(visit,sizeof(visit),false); //是否访问过

size:=0;

e:=last[s];

while e<>0 do //步骤1

begin

u:=other[e];

if not(Inh[u]) then //不在堆里

begin

inc(size);

heap[size]:=u;

dis[u]:=cost[e];

Loc[u]:=size; //Loc数组记录元素在堆中的位置

Inh[u]:=true;

Shift_up(Loc[u]); //上浮

end

else

if cost[e]<dis[u] then //在堆里

begin

dis[u]:=cost[e];

Shift_up(Loc[u]);

Shift_down(Loc[u]);

end;

e:=pre[e];

end;

visit[s]:=true;

while true do

begin

u:=heap[1]; //步骤2

if u=t then break; //步骤4

visit[u]:=true;

heap[1]:=heap[size];

dec(size);

Shift_down(1);

e:=last[u];

while e<>0 do //步骤3

begin

v:=other[e];

if Not(visit[v]) and (dis[u]+cost[e]<dis[v]) then

//与u相邻的,未被访问过的,满足三角不等式的顶点

if Inh[v] then //在堆中

begin

dis[v]:=dis[u]+cost[e];

Shift_up(Loc[v]);

Shift_Down(Loc[v]);

end

else //不再堆中

begin

inc(size);

heap[size]:=v;

dis[v]:=dis[u]+cost[e];

Loc[v]:=size;

Inh[v]:=true;

Shift_up(Loc[v]);

end;

e:=pre[e];

end;

end;

writeln(dis[t]);

end;

>

路径规划其实分为两种情况,一个是已知地图的,一个是未知地图的。

对于已知地图的,路径规划就变成了一个全局优化问题,用神经网络、遗传算法有一些。

对于未知地图的,主要就靠模糊逻辑或者可变势场法。

对于未知环境能自己构建地图的,也就是各种方法的结合了。

以上就是关于程序什么叫1:1路径不单调ⅹ方向怎样排除全部的内容,包括:程序什么叫1:1路径不单调ⅹ方向怎样排除、程序员的开源月刊《HelloGitHub》第 68 期、蚁群算法用于路径规划时的优缺点等相关内容解答,如果想了解更多相关内容,可以关注我们,你们的支持是我们更新的动力!

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zz/9363182.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023-04-27
下一篇 2023-04-27

发表评论

登录后才能评论

评论列表(0条)

保存