a算法改进

Ⅰ A*算法的好处

其实A*算法也是一种最好优先的算法
只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！
我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：
f'(n) = g'(n) + h'(n)
这里，f'(n)是估价函数，g'(n)是起点到节点n的最短路径值，h'(n)是n到目标的最短路经的启发值。由于这个f'(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g'(n)，但 g(n)>=g'(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h'(n)，但h(n)<=h'(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。
举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h'(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。
再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

Ⅱ 广度优先算法的优化——A*算法问题

英文叫 a-star 中文叫a星
我以前见过用astar算法求解这类问题的论文
你在上搜索一下 “A星算法”有这方面的解释

Ⅲ A*算法如何改进

十万火急：此改进的模糊C-此函数实现遗传算法，用于模糊C－均值聚类 %% A=farm(:,Ser(1)); B=farm(:,Ser(2)); P0=unidrnd(M-1); a=[

Ⅳ 什么是 a算法a* 算法有什么特点

A*算法：A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法。估价值与实际值越接近，估价函数取得就越好
A* （A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法。
注意是最有效的直接搜索算法。之后涌现了很多预处理算法（ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。
公式表示为： f(n)=g(n)+h(n),
其中 f(n) 是从初始点经由节点n到目标点的估价函数，
g(n) 是在状态空间中从初始节点到n节点的实际代价，
h(n) 是从n到目标节点最佳路径的估计代价。
保证找到最短路径（最优解的）条件，关键在于估价函数f(n)的选取：
估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。并且如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。
如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

Ⅳ 试解释Apriori算法核心思想,算法的不足,及算法改进的途径

自己去找论文下载看看，万方都有的，你直接搜“Apriori算法”即可，一大堆，自己看着挑吧

Ⅵ pdiibq 改进A_Star算法

//程序需要一个输入文件，名称必须为 in.txt
//A_Star算法是个很有名的算法，从程序竞赛，到网络选择，到游戏设计都有很大的应用
//我将A_Star算法做了一点小小的改进（但不知道这个改进以前有没有人做过）用来算迷宫。
//主要的改动是首先判断G(n)是否足够小，如果足够小则直接放弃向前搜索，因为已经有过更短的路径穿过这个点了
//网上的算法都是使用F(n)=G(n)+H(n)来判断该选择那个方向的下一步，而没有验证G(n)是否足够小

#include <stdio.h>
#include <string.h>
#include <math.h>
const unsigned int Largest=~0; //无符号int的最大值

struct Step //步
{
unsigned int X,Y;
unsigned char ZhuBin;
};
unsigned char Detect[9]={1<<7,1<<6,1<<5,1<<4,1<<3,1<<2,1<<1,1<<0,0xFF}; //探针

char **Maze; //原始迷宫
unsigned int SizeX,SizeY; //迷宫尺寸
unsigned int StartX,StartY; //起点
unsigned int EndX,EndY; //终点

Step *WorkPath; //工作栈
char *StepKind; //表示前进的步是斜向还是横竖向，以便缩减步长
unsigned int WorkLenth,Length; //总步数与总步长

char **ResultMaze; //结果迷宫
unsigned int ResultLength; //最短步长和

unsigned int **GDistance,**HDistance; //辅助表，这个是关键

int MoveX[8]={0,1,1,1,0,-1,-1,-1},MoveY[8]={-1,-1,0,1,1,1,0,-1}; //偏移量

int Read(char pFileName[])
{
FILE *pFile;
if( (pFile=fopen(pFileName,"r")) == 0)
{
printf("不能打开文件 %s\n",pFileName);
return 0;
}

fscanf(pFile,"%d %d",&SizeX,&SizeY);
fscanf(pFile,"%d %d",&StartX,&StartY);
fscanf(pFile,"%d %d",&EndX,&EndY);

unsigned int i,j;
WorkPath=new Step[SizeX*SizeY+1];//动态一维分配工作栈
StepKind=new char[SizeX*SizeY+1];

Maze=new char *[SizeY+1]; //动态二维分配迷宫与辅助表
GDistance=new unsigned int *[SizeY+1];
HDistance=new unsigned int *[SizeY+1];
ResultMaze=new char *[SizeY+1];
for(j=1;j<=SizeY;j++)
{
Maze[j]=new char [SizeX+1];
GDistance[j]=new unsigned int [SizeX+1];
HDistance[j]=new unsigned int [SizeX+1];
ResultMaze[j]=new char [SizeX+1];
}

fgetc(pFile);
for(j=1;j<=SizeY;j++)
{
for(i=1;i<=SizeX;i++)
{
ResultMaze[j][i]=(Maze[j][i]=fgetc(pFile)-'0');
GDistance[j][i]=Largest;
HDistance[j][i]=(unsigned int)(sqrt((i-EndX)*(i-EndX)+(j-EndY)*(j-EndY))*5.0);
}
fgetc(pFile);
}
fclose(pFile);
return 1;
}

int OutTable_F(char **p,char pFileName[])
{
FILE *pFile;
if( (pFile=fopen(pFileName,"w")) == 0)
return 0;
fprintf(pFile,"迷宫程序，采用自己改进的A_Star算法。作者：朱斌 [email protected]\n");
fprintf(pFile,"\n");
unsigned int i,j;
for(i=1 ; i<=SizeX+2 ; i++)
fprintf(pFile,"■");
fprintf(pFile,"\n");
for(j=1;j<=SizeY;j++)
{
fprintf(pFile,"■");
for(i=1;i<=SizeX;i++)
{
if(p[j][i]==0)
fprintf(pFile," ");
else if(p[j][i]==1)
fprintf(pFile,"■");
else
fprintf(pFile,"⊙");
}
fprintf(pFile,"■");
fprintf(pFile,"\n");
}
for(i=1 ; i<=SizeX+2 ; i++)
fprintf(pFile,"■");
fprintf(pFile,"\n");
fclose(pFile);
return 1;
}

Ⅶ 如何利用矩阵对a*算法进行优化

如果A确实能完全存入一级缓存,那么把B按列分块,一块一块乘就行了.
一般来讲矩阵乘法并不是像你说的那样做的,而要把A,B,C都分块,对于每一级存贮器而言,应该至少分成5个部分来管理.比如说,A的某一块常驻于这一级存贮,然后余下的部分分为四块：
(1)上一步已经运算完成的C块——写入低一级存贮
(2)下一步将参与运算的B块——从低一级存贮读入
(3),正在参与运算的B和C块
(4)然后对于这一级存贮器上的小矩阵块运算C=AB仍然按照同样的管理方式递交给上一级存贮来计算.一般来讲A块选得略小一点,具体的分配方式取决于运算和I/O的速度,尽量保持计算单元忙碌.

Ⅷ 如何修改A*算法,以便得到前n个最优解

把A*算法的最优解变为最优解的小堆

Ⅸ A*算法用于路径规划，有什么缺点

缺点：A*算法通过比较当前路径栅格的8个邻居的启发式函数值F来逐步确定下一个路径栅格，当存在多个最小值时A*算法不能保证搜索的路径最优。
A*算法；A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法。估价值与实际值越接近，估价函数取得就越好。A*[1] （A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法。注意是最有效的直接搜索算法。之后涌现了很多预处理算法（ALT，CH，HL等等），在线查询效率是A*算法的数千甚至上万倍。公式表示为： f(n)=g(n)+h(n),其中 f(n) 是从初始点经由节点n到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，h(n) 是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数f(n)的选取：估价值h(n)<= n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。并且如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。如果 估价值>实际值,搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

Ⅹ 为什么a*算法会出现重复扩展节点的问题解决的方法有哪些

算法没有错。只是考虑到所有可能的情况。
如果x出现在close集中，并且新的估价小于原有估价，说明还存在另一条经过x到达目标并且更快捷路径是之前没有搜索到的。这时当然要重新把x放回open集中统一考虑。
依你所讲，大概你是在方格棋盘类的路径搜索。则上述情况不会出现，因为方格棋盘构造出的图很规则。但如果是在某一非常奇怪的图上，比如两行星之间有个虫洞，经过后可以使时间倒流时（哈哈，暂时只想到这样一个奇怪的例子），则很有可能出现上述情况。
所以，不是算法谁对谁错，而是在不同问题中做法不一样。网络给出的算法考虑情况更全面。