通过A*算法实现多节点的寻径

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了通过A*算法实现多节点的寻径，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9583字，纯文字阅读大概需要14分钟。

内容图文

             1
            /*
             2
            A star 算法的基础处理

             3
            */
             4
            #ifndef _A_STAR_BASE_H_  

             5
            #define _A_STAR_BASE_H_  
 6 #include "windows.h" 7 8 typedef struct _APoint{
 9int x; // x 坐标  10int y; // y 坐标  11int type; // 类型  12int f; // f = g + h  13int g;
14int h;
15 } APoint, *PAPoint;
1617enum APointType{
18     APT_UNKNOWN, // 未知状态  19     APT_OPENED, // 开放列表中  20     APT_CLOSED, // 关闭列表中  21     APT_STARTPOINT, // 起始点  22     APT_ENDPOINT // 结束点  23};
242526class CAStarBase{
27public:
28    CAStarBase();
29     ~CAStarBase();
30private:
31    PAPoint m_pAPointArr;
32int m_nAPointArrWidth;
33int m_nAPointArrHeight;
3435    PAPoint m_pStartPoint, m_pEndPoint, m_pCurPoint;
36char* m_pOldArr;
37public:
38     BOOL Create(char* pDateArr, int nWidth, int nHeight);
39void SetStartPoint(int x, int y);
40void SetEndPoint(int x, int y);
41void SetOpened(int x, int y);
42void SetClosed(int x, int y);
43void SetCurrent(int x, int y);
44void PrintCharArr();
4546     PAPoint CalcNextPoint(PAPoint ptCalc); // 应用迭代的办法进行查询  47};
4849#endif

              1 #include "A_Star.h"  2 #include <cstdio>
  3  4CAStarBase::CAStarBase()
  5{
  6     m_pAPointArr = NULL;
  7     m_nAPointArrWidth = 0;
  8     m_nAPointArrHeight = 0;
  9 10     m_pStartPoint = NULL;
 11     m_pEndPoint = NULL;
 12     m_pCurPoint = NULL;
 13 14}
 15 16 CAStarBase::~CAStarBase()
 17{
 18 19}
 20 21 BOOL CAStarBase::Create(char* pDateArr, int nWidth, int nHeight)
 22{
 23if (!pDateArr) return FALSE;                      //数组地址是否存在 24if (nWidth<1 || nHeight<1) return FALSE;          //判断数组的长宽是否大于一 25     m_pAPointArr = new APoint[nWidth*nHeight];
 26if (!m_pAPointArr) return FALSE;
 27     m_pOldArr = pDateArr;                             //父节点9指针形式） 28     m_nAPointArrWidth = nWidth;                       //数组的宽度 29     m_nAPointArrHeight = nHeight;                     //数组的高度
 30// 初始化数组内容   31for (int y = 0; y<m_nAPointArrHeight; y++)
 32    {
 33for (int x = 0; x<m_nAPointArrWidth; x++)
 34        {
 35             m_pAPointArr[y*m_nAPointArrWidth + x].x = x;                   //赋值形式？！ 36             m_pAPointArr[y*m_nAPointArrWidth + x].y = y;
 37             m_pAPointArr[y*m_nAPointArrWidth + x].g = 0;
 38             m_pAPointArr[y*m_nAPointArrWidth + x].f = 0;
 39             m_pAPointArr[y*m_nAPointArrWidth + x].h = 0;
 40 41if (pDateArr[y*m_nAPointArrWidth + x] == ‘0‘)
 42            {
 43                 m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_OPENED;
 44            }
 45elseif (pDateArr[y*m_nAPointArrWidth + x] == ‘1‘)
 46            {
 47                 m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_CLOSED;
 48            }
 49elseif (pDateArr[y*m_nAPointArrWidth + x] == ‘S‘)
 50            {
 51                 m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_STARTPOINT;
 52                 m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth + x;            //赋值形式？！ 53                 m_pCurPoint = m_pStartPoint;
 54            }
 55elseif (pDateArr[y*m_nAPointArrWidth + x] == ‘E‘)
 56            {
 57                 m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_ENDPOINT;
 58                 m_pEndPoint = m_pAPointArr + y*m_nAPointArrWidth + x;
 59            }
 60else{
 61                 m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_UNKNOWN;
 62            }
 63 64        }
 65    }
 66return TRUE;                          //初始化返回为真 67}
 68 69void CAStarBase::SetStartPoint(int x, int y)
 70{
 71if (m_pStartPoint && m_pAPointArr[y*m_nAPointArrWidth + x].type != APT_CLOSED)
 72    {
 73         m_pStartPoint->type = APT_OPENED;
 74// 设置新的值   75         m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth + x;
 76         m_pStartPoint->type = APT_STARTPOINT;
 77         m_pCurPoint = m_pStartPoint;
 78    }
 79}
 80 81void CAStarBase::SetEndPoint(int x, int y)
 82{
 83if (m_pStartPoint && m_pAPointArr[y*m_nAPointArrWidth + x].type != APT_CLOSED)
 84    {
 85         m_pStartPoint->type = APT_OPENED;
 86// 设置新的值   87         m_pStartPoint = m_pAPointArr + y*m_nAPointArrWidth + x;
 88         m_pStartPoint->type = APT_ENDPOINT;
 89    }
 90}
 91 92void CAStarBase::SetCurrent(int x, int y)
 93{
 94//  if ( m_pAPointArr[y*m_nAPointArrWidth+x].type==APT_OPENED )   95    {
 96         m_pCurPoint = m_pAPointArr + y*m_nAPointArrWidth + x;
 97    }
 98}
 99100void CAStarBase::SetOpened(int x, int y)                //建立“开启列表”101{
102if (m_pAPointArr[y*m_nAPointArrWidth + x].type != APT_OPENED)
103    {
104         m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_OPENED;
105    }
106}
107108void CAStarBase::SetClosed(int x, int y)                 //建立“关闭列表”109{
110if (m_pAPointArr[y*m_nAPointArrWidth + x].type != APT_CLOSED)
111    {
112         m_pAPointArr[y*m_nAPointArrWidth + x].type = APT_CLOSED;
113    }
114}
115116void CAStarBase::PrintCharArr()                     //打印终点117{
118if (m_pOldArr)                                 //是否有父节点119    {
120for (int y = 0; y<m_nAPointArrHeight; y++)
121        {
122for (int x = 0; x<m_nAPointArrWidth; x++)
123            {
124                 printf("%c ", m_pOldArr[x + m_nAPointArrWidth*y]);
125            }
126             printf("\r\n");
127        }
128         printf("\r\n");
129    }
130}
131132PAPoint CAStarBase::CalcNextPoint(PAPoint ptCalc)
133{
134if (ptCalc == NULL)
135    {
136         ptCalc = m_pStartPoint;
137    }
138int x = ptCalc->x;
139int y = ptCalc->y;
140int dx = m_pEndPoint->x;
141int dy = m_pEndPoint->y;
142int xmin = x, ymin = y, vmin = 0; // 最优步骤的坐标和值  
143// 判断是否已经到了最终的位置  144if ((x == dx && abs(y - dy) == 1) || (y == dy && abs(x - dx) == 1))     //是否在重点的周围145    {
146         printf("\r\n\n");
147        PrintCharArr();
148return m_pEndPoint;
149    }
150// 上  151if (m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].type == APT_OPENED && y>0)
152    {
153         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].g = 10;
154         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].h =
15510 * (abs(x - dx) + abs(y - 1 - dy));
156         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].f =
157             m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].g + m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].h;
158if (vmin == 0)
159        {
160             xmin = x;
161             ymin = y - 1;
162             vmin = m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].f;
163        }
164else{
165if (vmin > m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].f)
166            {
167                 xmin = x;
168                 ymin = y - 1;
169                 vmin = m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y - 1)].f;
170            }
171        }
172    }
173// 下  174if (m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].type == APT_OPENED && y<m_nAPointArrHeight)
175    {
176         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].g = 10;
177         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].h =
17810 * (abs(x - dx) + abs(y + 1 - dy));
179         m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].f =
180             m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].g + m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].h;
181if (vmin == 0)
182        {
183             xmin = x;
184             ymin = y + 1;
185             vmin = m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].f;
186        }
187else{
188if (vmin > m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].f)
189            {
190                 xmin = x;
191                 ymin = y + 1;
192                 vmin = m_pAPointArr[(x + 0) + m_nAPointArrWidth*(y + 1)].f;
193            }
194        }
195    }
196// 左  197if (m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].type == APT_OPENED && x>0)
198    {
199         m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].g = 10;
200         m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].h =
20110 * (abs(x - 1 - dx) + abs(y - dy));
202         m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].f =
203             m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].g + m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].h;
204if (vmin == 0)
205        {
206             xmin = x - 1;
207             ymin = y;
208             vmin = m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].f;
209        }
210else{
211if (vmin > m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].f)
212            {
213                 xmin = x - 1;
214                 ymin = y;
215                 vmin = m_pAPointArr[(x - 1) + m_nAPointArrWidth*y].f;
216            }
217        }
218    }
219// 右  220if (m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].type == APT_OPENED && x<m_nAPointArrWidth)
221    {
222         m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].g = 10;
223         m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].h =
22410 * (abs(x + 1 - dx) + abs(y - dy));
225         m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].f =
226             m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].g + m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].h;
227if (vmin == 0)
228        {
229             xmin = x + 1;
230             ymin = y;
231             vmin = m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].f;
232        }
233else{
234if (vmin > m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].f)
235            {
236                 xmin = x + 1;
237                 ymin = y;
238                 vmin = m_pAPointArr[(x + 1) + m_nAPointArrWidth*y].f;
239            }
240        }
241    }
242243244if (vmin)
245    {
246        SetCurrent(xmin, ymin);
247        SetClosed(xmin, ymin);
248         printf("(%d,%d)->", xmin, ymin);
249         *(m_pOldArr + xmin + m_nAPointArrWidth*ymin) = ‘-‘;         //走过的路径用‘-’表示
250//PrintCharArr();                                             //每在关闭列表中加入一个值，就输出一遍251         PAPoint pApoint = CalcNextPoint(m_pCurPoint);               // 如果有最优点则迭代，则否就返回NULL 252if (pApoint == NULL)
253        {
254            SetCurrent(x, y);
255            SetClosed(xmin, ymin);
256             *(m_pOldArr + xmin + m_nAPointArrWidth*ymin) = ‘0‘;      //不做改变257return CalcNextPoint(m_pCurPoint);
258        }
259return pApoint;
260    }
261else{
262return NULL;
263    }
264265 }

             1
            //
             AStarMath.cpp : 定义控制台应用程序的入口点。  

             2
            //
             3
             4
            //
            #include <stdafx.h>  
             5 #include "A_Star.h" 6 #include <stdio.h>
 7 8CAStarBase Astarbase;
 910int main()
11{
12char pBuff[][12] = {
13‘S‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
14‘0‘, ‘1‘, ‘1‘, ‘0‘, ‘0‘, ‘1‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
15‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘1‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
16‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
17‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
18‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
19‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
20‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
21‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
22‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘E‘,
23‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
24‘0‘, ‘0‘, ‘0‘, ‘1‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘25    };
26     Astarbase.Create(&pBuff[0][0], 12, 12);
27    Astarbase.PrintCharArr();
28     PAPoint pPoint = Astarbase.CalcNextPoint(NULL);
29if (pPoint == NULL)
30    {
31         printf("no path can arrive!\r\n");
32    }
33else{
34         printf("success arrived!\r\n");
35    }
36    getchar();
37return0;
38 }

原文：http://www.cnblogs.com/ingslh/p/4995087.html

内容总结

以上是互联网集市为您收集整理的通过A*算法实现多节点的寻径全部内容，希望文章能够帮你解决通过A*算法实现多节点的寻径所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1301020.html

来源：【匿名】

【下一篇】浅谈php实现映射的两种方法（链表和二叉树）

更多 ►

【通过A*算法实现多节点的寻径】教程文章相关的互联网学习教程文章

1/* 2A star 算法的基础处理3*/ 4#ifndef _A_STAR_BASE_H_ 5#define _A_STAR_BASE_H_ 6 #include "windows.h" 7 8 typedef struct _APoint{9int x; // x 坐标 10int y; // y 坐标 11int type; // 类型 12int f; // f = g + h 13int g; 14int h; 15 } APoint, *PAPoint; 1617enum APointType{ 18 APT_UNKNOWN, // 未知状态 19 APT_OPENED, // 开放列表中 20 APT_CLOSED, // 关闭列表中 21 APT_STARTPOINT,...

快速排序算法 java实现【代码】

1publicclass QuickRank {2publicstaticvoid main(String[] args) {3int[] original={26,58,1,24,75,69,32,45,841,25898};4 QuickRank quickRank=new QuickRank();5 quickRank.rankSimple(original,0,original.length-1);6for(int i:original)7 System.out.println(i);8}9//清晰明了10publicvoid rankSimple(int[] original,int start,int end){ 11if(end<=start) return;//递归结束条件12int standard=original[st...

008实现一个算法从一个单链表中返回倒数第n个元素（keep it up）

我们维护两个指针，它们之间的距离为n。然后。我将这两个指针同步地在这个单链表上移动，保持它们的距离为n不变。那么，当第二个指针指到空时。第一个指针即为所求。#include <iostream>struct Node {int data;Node* next; };void initList(Node* vNode) {for (int i=0; i < 20; ++i){Node* TempNode = new Node;TempNode->data = i;TempNode->next = vNode->next;vNode->next = TempNode;} }Node* getNthBackWards(const N...

python3实现二叉树的遍历与递归算法解析【代码】【图】

1、二叉树的三种遍历方式二叉树有三种遍历方式：先序遍历，中序遍历，后续遍历即：先中后指的是访问根节点的顺序 eg:先序根左右中序左根右后序左右根　　遍历总体思路：将树分成最小的子树，然后按照顺序输出　　1.1 先序遍历　　　　a 先访问根节点　　　　b 访问左节点　　　　c 访问右节点　　　　a（b ( d ( h ) )( e ( i ) )）( c ( f )( g )) -- abdheicfg 　　1.2 中序遍历　...

基于霍夫变换的形状检测算法研究与实现（java）【图】

利用Hough变换算法检测形状的检测结果如下如所示：1、检测直线 2、检测圆形源代码及论文下载地址如下：基于霍夫变换的形状检测算法研究与实现（源代码及论文）原文：http://blog.csdn.net/class_horse/article/details/40787865

POS终端MAC算法－C语言实现

POS终端MAC算法－C语言实现原文：http://www.cnblogs.com/LittleTiger/p/6388813.html

第七篇：Logistic回归分类算法原理分析与代码实现【代码】【图】

前言本文将介绍机器学习分类算法中的Logistic回归分类算法并给出伪代码，Python代码实现。 (说明：从本文开始，将接触到最优化算法相关的学习。旨在将这些最优化的算法用于训练出一个非线性的函数，以用于分类。)算法原理首先要提到的概念是回归。对于回归这个概念，在以后的文章会有系统而深入的学习。简单的说，回归就是用一条线对N多数据点进行一个拟合，这个拟合的过程就叫做回归。 Logistic...

LRU算法的简易实现【代码】【图】

LRU全称Least Recently Used，也就是最近最少使用的意思，是一种内存管理算法，该算法最早应用于 Linux操作系统。这个算法基于一种假设：长期不被使用的数据，在未来被用到的几率也不大。因此，当数据所占内存达到一定阈值时，我们要移除掉最近最少被使用的数据。 LRU算法中，使用了一种有趣的数据结构，这种数据结构叫作哈希链表。我们都知道，哈希表是由若干个Key-Value组成的。在“逻辑”上，这些 Key-Value是无所谓排列顺...

常见排序算法（PHP实现）【代码】【图】

秒懂算法1——冒泡排序，及一种小改进（C#实现）【代码】【图】

算法思路：重复走访每两个相邻元素，比较大小交换位置，直至排序完成。有兴趣电话可以看一下这个【冒泡排序踢踏舞】的视频，很形象的演示了排序过程，额呵呵~~性质：冒泡排序是一种原地排序（只有常数个元素存到数组以外的空间），最坏的时间复杂度，和平均时间复杂度都是n2。*注：冒泡排序是算法入门级别，是面试笔试时候的禁术，古往今来死在冒泡法上的应届生真可谓前仆后继...代码：int[] BubbleSort1(int[] a){int num; for (...

KNN算法java实现代码注释【代码】【图】

K近邻算法思想非常简单，总结起来就是根据某种距离度量检测未知数据与已知数据的距离，统计其中距离最近的k个已知数据的类别，以多数投票的形式确定未知数据的类别。一直想自己实现knn的java实现，但限于自己的编程水平，java刚刚入门，所以就广泛搜索网上以实现的java代码来研习。下面这个简单的knn算法的java实现是在这篇博客中找到的：http://blog.csdn.net/luowen3405/article/details/6278764 下面给出我对代码的注释，如果有...

JavaScript Base64算法的实现【代码】

js 版base 64 算法 base64.jsvar keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; //将Ansi编码的字符串进行Base64编码function encode64(input) { var output = ""; var chr1, chr2, chr3 = ""; var enc1, enc2, enc3, enc4 = ""; var i = 0; do { chr1 = input.charCodeAt(i++); chr2 = input.charCodeAt(i++); chr3 = input.charCodeAt(i++); enc1 = chr1 >> 2; enc2 = ((chr1 & 3) << 4) | (...

k-th Order Statistic算法实现（寻找第k小的数）【代码】【图】

在一组随机排列的数中找出第k小的，这个元素称为k-th Order Statistic。能想到的最直观的算法肯定是先把这些数排序然后取第k个，时间复杂度和排序算法相同，可以是Θ(nlgn)。但它也有平均情况下时间复杂度是Θ(n)的算法，将快速排序算法稍加修改就可以解决这个问题。基本思路： 1/* 从start到end之间找出第k小的元素 */ 2int order_statistic(int start, int end, int k)3{4 用partition函数把序列分成两半，中间的pivot元素是...

C均值算法实现【代码】

###总结1、np.array是没有空数组的，需要先成立一个空的list，给他添加元素，然后将它转化为np.array的格式2、直接使两个center相等，以后他们会一直相等，因为使用的是同一个指针。###源程序 import numpy as np import matplotlib.pyplot as pltdataset = np.array([[0, 0], [1, 0], [0, 1], [1, 1], [2, 1],[1, 2], [2, 2], [3, 2], [6, 6], [7, 6],[8, 6], [6, 7], [7, 7], [8, 7], [9, 7],[7, 8], [8, 8], [9, 8], [8, 9], [9...

BP算法推导python实现

def sigmoid(inX): return 1.0/(1+exp(-inX)) ‘‘‘标准bp算法每次更新都只针对单个样例，参数更新得很频繁sdataSet 训练数据集labels 训练数据集对应的标签标签采用one-hot编码(一位有效编码)，例如类别0对应标签为[1,0],类别1对应标签为[0,1]alpha 学习率num 隐层数，默认为1层eachCount 每一层隐层的神经元数目repeat 最大迭代次数算法终止条件：达到最大迭代次数或者相邻一百次迭代的累计误差的差值不超过0.001‘‘‘def bp(d...

算法 - 最热教程

浅谈SQLServer查询优化器中的JOIN算法有没那种可逆算法是密文比明文短的呢？...javascript-类似Excel里面的NORMDIST函...C++中的分治算法及常见题目汇总压缩感知重构算法综述-学习笔记 c++中内置函数qsort（快速排序）和bsea...一、fpga图像处理算法整合基于遗传算法（deap）的非线性函数寻优...集成学习-Bagging集成学习算法随机森林...机器学习笔记（九）聚类算法及实践（K-...