九宫格移动算法实现

九宫格移动算法实现
九宫格移动算法实现

用.Net实现九宫格移动算法

说明:在3*3的格子里,假设一个格子为空(在程序里是用0代表),其他格子可以移动到这个格子上,有多少种可能?答案是9的阶乘除以2=181440种,以下为程序实现,输出到d:\GridNine.txt文件中。程序共两个类Program和Mygrid。以下为代码:

Program:

--------------------------------------------------------------------------------------------using System;

using System.Collections.Generic;

using System.Windows.Forms;

using System.IO;

namespace WindowsApplication1

{

static class Program

{

static int gen = 0;

///

///应用程序的主入口点。

///

[STAThread]

static void Main()

{

//Application.EnableVisualStyles();

//Application.SetCompatibleTextRenderingDefault(false);

//Application.Run(new Form1());

List list = new List();

Mygrid iniGrid = new Mygrid('1', '2', '3', '4', '0', '5', '6', '7', '8');

list.Add(iniGrid);

iniGrid.Genaration = gen;

gen = gen + 1;

//以初始集合开始衍生

ComputeAll(null,list);

Console.WriteLine(list.Count);

string[] output = new string[list.Count];

for (int i = 0; i < list.Count; i++)

{

Mygrid single = list[i];

output[i] = single.GridToStringAll();

}

string context = string.Join(@"

", output);

using (StreamWriter savefile = new StreamWriter(@"d:\GridNine.txt"))

{

savefile.WriteLine(context);

savefile.Close();

}

MessageBox.Show(@"移动步骤保存成功!文件为:d:\GridNine.txt");

}

///

///

///

///新加入

///全部包含新加入

static void ComputeAll(List addList,List list)

{

List newList;

if (addList == null)

{

//计算当前list中变换得来的全部

newList = GetAllNew(list);

}

else

{

newList = GetAllNew(addList);

}

//比较变换的是否存在于list中,更新list,如果list被更新,返回true,否则返回false

//获得新放入的list

List resutl = IsUpdate(list, newList);

//循环调用

if (resutl.Count !=0)

{

ComputeAll(resutl,list);

}

}

static List GetAllNew(List list)

{

//新建一个list,循环放变换之后的,去掉重复的

List newList = new List();

foreach (Mygrid grid in list)

{

List changeList = grid.Change(grid);

addChangeList(newList, changeList);

}

return newList;

}

private static void addChangeList(List newList, List changeList) {

foreach (Mygrid change in changeList)

{

bool flag = false;

List tmp = new List();

foreach (Mygrid newSingel in newList)

{

if (https://www.360docs.net/doc/5e12524665.html,pareGrid(change))

{

flag = true;

break;

}

}

if (!flag)

{

newList.Add(change);

}

}

}

private static List IsUpdate(List list, List newList)

{

List result = new List();

foreach (Mygrid change in newList)

{

bool flag = false;

foreach (Mygrid oldSingle in list)

{

if (https://www.360docs.net/doc/5e12524665.html,pareGrid(change))

{

flag = true;

break;

}

}

if (!flag)

{

result.Add(change);

}

}

//统一放入

foreach (Mygrid tmpSingel in result)

{

tmpSingel.Genaration = gen;

list.Add(tmpSingel);

}

gen = gen + 1;

return result;

}

//合并两个集合,返回一个新的集合

private static List ComList(List oldlist, List newList)

{

List result = new List();

foreach (Mygrid tmp in oldlist)

{

result.Add(tmp);

}

foreach (Mygrid tmp in newList)

{

result.Add(tmp);

}

return result;

}

}

}

Mygrid:

-------------------------------------------------------------------------------------------- using System;

using System.Collections.Generic;

using System.Text;

namespace WindowsApplication1

{

class Mygrid

{

private char grid1;

private char grid2;

private char grid3;

private char grid4;

private char grid5;

private char grid6;

private char grid7;

private char grid8;

private char grid9;

private int genaration;

public int Genaration

{

get { return genaration; }

set { genaration = value; }

}

public Mygrid()

{

grid1 = ' ';

grid2 = ' ';

grid3 = ' ';

grid4 = ' ';

grid5 = ' ';

grid6 = ' ';

grid7 = ' ';

grid8 = ' ';

grid9 = ' ';

}

public Mygrid(char grid1, char grid2, char grid3, char grid4, char grid5, char grid6, char grid7, char grid8, char grid9)

{

this.grid1 = grid1;

this.grid2 = grid2;

this.grid3 = grid3;

this.grid4 = grid4;

this.grid5 = grid5;

this.grid6 = grid6;

this.grid7 = grid7;

this.grid8 = grid8;

this.grid9 = grid9;

}

//传入old获得新的

public List Change(Mygrid old)

{

List changeList = new List();

int zeroGrid=WhereZeroIs(old);

switch (zeroGrid)

{

case 1:

changeList.Add(new

Mygrid(old.grid2,old.grid1,old.grid3,old.grid4,old.grid5,old.grid6,old.grid7,old.grid8,old.g rid9));

changeList.Add(new Mygrid(old.grid4, old.grid2, old.grid3, old.grid1,

old.grid5, old.grid6, old.grid7, old.grid8, old.grid9));

return changeList;

case 2:

changeList.Add(new Mygrid(old.grid2, old.grid1, old.grid3, old.grid4,

old.grid5, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid3, old.grid2, old.grid4,

old.grid5, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid5, old.grid3, old.grid4,

old.grid2, old.grid6, old.grid7, old.grid8, old.grid9));

return changeList;

case 3:

changeList.Add(new Mygrid(old.grid1, old.grid3, old.grid2, old.grid4,

old.grid5, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid6, old.grid4,

old.grid5, old.grid3, old.grid7, old.grid8, old.grid9));

return changeList;

case 4:

changeList.Add(new Mygrid(old.grid4, old.grid2, old.grid3, old.grid1,

old.grid5, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid5,

old.grid4, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid7,

old.grid5, old.grid6, old.grid4, old.grid8, old.grid9));

return changeList;

case 5:

changeList.Add(new Mygrid(old.grid1, old.grid5, old.grid3, old.grid4,

old.grid2, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid5,

old.grid4, old.grid6, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4,

old.grid6, old.grid5, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4,

old.grid8, old.grid6, old.grid7, old.grid5, old.grid9));

return changeList;

case 6:

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid6, old.grid4,

old.grid5, old.grid3, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid6, old.grid5, old.grid7, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid9, old.grid7, old.grid8, old.grid6));

return changeList;

case 7:

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid7, old.grid5, old.grid6, old.grid4, old.grid8, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid6, old.grid8, old.grid7, old.grid9));

return changeList;

case 8:

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid8, old.grid6, old.grid7, old.grid5, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid6, old.grid8, old.grid7, old.grid9));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid6, old.grid7, old.grid9, old.grid8));

return changeList;

case 9:

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid9, old.grid7, old.grid8, old.grid6));

changeList.Add(new Mygrid(old.grid1, old.grid2, old.grid3, old.grid4, old.grid5, old.grid6, old.grid7, old.grid9, old.grid8));

return changeList;

}

return changeList;

}

public bool CompareGrid(Mygrid old)

{

if (this.GridToString().Equals(old.GridToString())) return true;

return false;

}

private int WhereZeroIs(Mygrid old)

{

if (old.grid1 == '0') return 1;

if (old.grid2 == '0') return 2;

if (old.grid3 == '0') return 3;

if (old.grid4 == '0') return 4;

if (old.grid5 == '0') return 5;

if (old.grid6 == '0') return 6;

if (old.grid7 == '0') return 7;

if (old.grid8 == '0') return 8;

return 9;

}

string GridToString()

{

StringBuilder res = new StringBuilder();

res.Append(grid1).Append(grid2).Append(grid3).Append(grid4).Append(grid5).Append(grid6).Appe nd(grid7).Append(grid8).Append(grid9);

return res.ToString();

}

public string GridToStringAll()

{

StringBuilder res = new StringBuilder();

res.Append(grid1).Append(grid2).Append(grid3).Append(grid4).Append(grid5).Append(grid6).Appe nd(grid7).Append(grid8).Append(grid9).Append(' ').Append(genaration.ToString ());

return res.ToString();

}

}

}

人工智能化(A星算法)

A*算法实验报告 实验目的 1.熟悉和掌握启发式搜索的定义、估价函数和算法过程 2. 学会利用A*算法求解N数码难题 3. 理解求解流程和搜索顺序 实验原理 A*算法是一种有序搜索算法,其特点在于对估价函数的定义上。对于一般的有序搜索,总是选择f值最小的节点作为扩展节点。因此,f是根据需要找到一条最小代价路径的观点来估算节点的,所以,可考虑每个节点n的估价函数值为两个分量:从起始节点到节点n的代价以及从节点n到达目标节点的代价。 实验条件 1.Window NT/xp/7及以上的操作系统 2.内存在512M以上 3.CPU在奔腾II以上 实验内容 1.分别以8数码和15数码为例实际求解A*算法 2.画出A*算法求解框图 3.分析估价函数对搜索算法的影响 4.分析A*算法的特点 实验分析 1. A*算法基本步骤 1)生成一个只包含开始节点n0的搜索图G,把n0放在一个叫OPEN的列表上。

2)生成一个列表CLOSED,它的初始值为空。 3)如果OPEN表为空,则失败退出。 4)选择OPEN上的第一个节点,把它从OPEN中移入CLPSED,称该节点为n。 5)如果n是目标节点,顺着G中,从n到n0的指针找到一条路径,获得解决方案,成功退出(该指针定义了一个搜索树,在第7步建立)。 6)扩展节点n,生成其后继结点集M,在G中,n的祖先不能在M中。在G中安置M的成员,使他们成为n的后继。 7)从M的每一个不在G中的成员建立一个指向n的指针(例如,既不在OPEN 中,也不在CLOSED中)。把M1的这些成员加到OPEN中。对M的每一个已在OPEN中或CLOSED中的成员m,如果到目前为止找到的到达m的最好路径通过n,就把它的指针指向n。对已在CLOSED中的M的每一个成员,重定向它在G中的每一个后继,以使它们顺着到目前为止发现的最好路径指向它们的祖先。 8)按递增f*值,重排OPEN(相同最小f*值可根据搜索树中的最深节点来解决)。 9)返回第3步。 在第7步中,如果搜索过程发现一条路径到达一个节点的代价比现存的路径代价低,就要重定向指向该节点的指针。已经在CLOSED中的节点子孙的重定向保存了后面的搜索结果,但是可能需要指数级的计算代价。 实验步骤 算法流程图

九宫格以及更高阶数的宫格算法与源程序

#include #define N 16 //这里可以修改N的值 int main() { int a[N][N],i,j,k,p,n; p=1; while(p==1) /*要求阶数为1~15的商数*/ { printf("Enter n(n=1~15):"); //可以输入小于等于N-1的整数 scanf("%d",&n); if((n!=0)&&(n<=N-1)&&(n%2!=0)) p=0; } for(i=1;i<=n;i++) /*初始化*/ for(j=1;j<=n;j++) a[i][j]=0; j=n/2+1; /*建立魔方阵*/ a[1][j]=1; for(k=2;k<=n*n;k++) { i=i-1; j=j+1; if((i<1)&&(j>n)) { i=i+2; j=j-1; } else { if(i<1) i=n; if(j>n) j=1; } if(a[i][j]==0) a[i][j]=k; else { i=i+2; j=j-1; a[i][j]=k; } } for(i=1;i<=n;i++) /*输出魔方阵*/ { for(j=1;j<=n;j++) printf("%4d",a[i][j]); printf("\n"); }

return 0; } 魔方阵算法: (1)将1放在第一行中间一列 (2)从2开始直到n*n止个数一次按下列规则存放,每一个数存放的行比前一个数的列数减1,行数加1 (3)如果上一数的行数为1,,则下一个数的行数为n (4)当上一个数的列数为n时,下一个数的列数应为1,行数减1 (5)如果按上面的规则确定的位置上已有数,或上一个数是第一行的n列时,则把下一个数放在上一个数的下面 ————————算法很难理解 #include #define MAX 20 void main() { int i,j,k,n; int a[MAX][MAX]={0}; printf("请输入魔法矩阵的行数(或列数)\n"); do{ scanf("%d",&n); if(n%2==0) printf("\n请输入一个奇数(<20)\n"); }while(n%2==0); i=0; j=n/2; a[i][j]=1; for(k=2;k<=n*n;k++) { if(a[(i-1+n)%n][(j+1)%n]==0) { i=(i-1+n)%n; j=(j+1)%n; } else i=(i+1)%n; a[i][j]=k; } printf("\n下面是%d维魔方的展示:\n",n); for(i=0;i

人工智能算法综述

人工智能算法综述 人工智能算法大概包括五大搜索技术,包括一些早期的搜索技术或用于解决比较简单问题的搜索原理和一些比较新的能够求解比较复杂问题的搜索原理,如遗传算法和模拟退火算法等。 1、盲目搜索 盲目搜索又叫做无信息搜索,一般只适用于求解比较简单的问题。包括图搜索策略,宽度优先搜索和深度优先搜素。 1、图搜索(GRAPH SERCH)策略是一种在图中寻找路径的方法。在有关图的表示方法中,节点对应于状态,而连线对应于操作符。 2、如果搜素是以接近其实节点的程度依次扩展节点的,那么这种搜素就叫做宽度优先搜素(breadth-first search 。 3、深度优先搜索属于图算法的一种,英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止,而且每个节点只能访问一次。 二、启发式搜索 盲目搜索的不足之处是效率低,耗费过多的时间和空间。启发信息是进行搜索技术所需要的一些有关具体问题的特性的信息。利用启发信息的搜索方法叫做启发式搜索方法。 启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径,提高了效率。在启发式搜索中,对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。 3、博弈树搜索 诸如下棋、打牌、竞技、战争等一类竞争性智能活动称为博弈。博弈有很多种,我们讨论最简单的"二人零和、全信息、非偶然"博弈,其特征如下: (1 对垒的MAX、MIN双方轮流采取行动,博弈的结果只有三种情况:MAX方胜,MIN方败;MIN方胜,MAX方败;和局。 (2 在对垒过程中,任何一方都了解当前的格局及过去的历史。

小学数独精通技巧

数独 数独(すうどく,)是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字,推理出所有剩余空格的数字,并满足每一行、每一列、每一个粗线宫内的数字均含1-9,不重复。每一道合格的数独谜题都有且仅有唯一答案,推理方法也以此为基础,任何无解或多解的题目都是不合格的。 既然“数独”有一个字是“数”,人们也往往会联想到数学,那就不妨从大家都知道的数学家欧拉说起,但凡想了解数独历史的玩家在网络、书籍中搜索时,共同会提到的就是欧拉的“拉丁方块()”,如下图: 拉丁方块的规则:每一行()、每一列()均含1(N即盘面的规格),不重复。这及前面提到的标准数独非常相似,但少了一个宫的规则。 其实说到这里,有些人会想到《易经》当中的洛书九宫图:

洛书九宫图 横、竖、斜方向的三数之和均是15,相信大家小学时候也都算过这个题目。所以也有人说数独的起源在中国。这点我们不得而知,但可以肯定的是,如今数独热潮已在全球蔓延。组成元素 1.九宫格() 水平方向有九横行,垂直方向有九纵列的矩形,画分八十一个小矩形,称为九宫格(),如图一所示,是数独()的作用范围。

数独元素 - 九宫格 [1] 2.单元()画分 2.1 水平方向的每一横行有九格,每一横行称为行(),编号如图二所示。 数独元素 - 单元 2.2 垂直方向的每一纵列有九格,每一纵列称为列(),编号如图三所示。

数独元素 - 列 2.3 三行及三列相交之处有九格,每一单元称为小九宫(、),简称宫,如图四用粗线标示者。(在数独中,宫往往用单词表示) 数独元素 - 宫 2.4 上述行、列、宫统称为单元() 2.5 由三个连续宫组成大区块(),分大行区块()及大列区块()。 第一大行区块:由第一宫、第二宫、第三宫组成。 第二大行区块:由第四宫、第五宫、第六宫组成。 第三大行区块:由第七宫、第八宫、第九宫组成。 第一大列区块:由第一宫、第四宫、第七宫组成。

人工智能a算法

1.启发式搜索算法A 启发式搜索算法A,一般简称为A算法,是一种典型的启发式搜索算法。其基本思想是:定义一个评价函数f,对当前的搜索状态进行评估,找出一个最有希望的节点来扩展。 评价函数的形式如下: f(n)=g(n)+h(n) 其中n是被评价的节点。 f(n)、g(n)和h(n)各自表述什么含义呢?我们先来定义下面几个函数的含义,它们与f(n)、g(n)和h(n)的差别是都带有一个"*"号。 g*(n):表示从初始节点s到节点n的最短路径的耗散值; h*(n):表示从节点n到目标节点g的最短路径的耗散值; f*(n)=g*(n)+h*(n):表示从初始节点s经过节点n到目标节点g 的最短路径的耗散值。 而f(n)、g(n)和h(n)则分别表示是对f*(n)、g*(n)和h*(n)三个函数值的的估计值。是一种预测。A算法就是利用这种预测,来达到有效搜索的目的的。它每次按照f(n)值的大小对OPEN表中的元素进行排序,f值小的节点放在前面,而f 值大的节点则被放在OPEN表的后面,这样每次扩展节点时,都是选择当前f值最小的节点来优先扩展。

利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。 过程A ①OPEN:=(s),f(s):=g(s)+h(s); ②LOOP:IF OPEN=()THEN EXIT(FAIL); ③n:=FIRST(OPEN); ④IF GOAL(n)THEN EXIT(SUCCESS); ⑤REMOVE(n,OPEN),ADD(n,CLOSED); ⑥EXPAND(n)→{mi},计算f(n,mi)=g(n,mi)+h(mi);g(n,mi)是从s通过n到mi的耗散值,f(n,mi)是从s通过n、mi到目标节点耗散值的估计。 ·ADD(mj,OPEN),标记mi到n的指针。 ·IF f(n,mk)

九宫格算法攻略

九宫格算法攻略 早上看了一个关于大盗攻略的帖子,写的很详细(不是广告),不过是比较早的,现在改了不少。我想说的是,看过发现好多亲都不会算9宫。 献个丑,帮大家想了一个简单的方法。(先说方法,后面再解释) 首先是准备工作:亲们需要把下面2组9宫格写在本本或者便利贴上面 九宫算法 好了,大盗给出的题目都是3个数字, 亲们只要把题目对照上图找好方位,依次排列9个数再消掉题目,就是我们要的答案了 (稀里糊涂拉?来举个例子吧) 例如题目为: 第一排第二个数:7 第三排第一个数:8 第三排第三个数:4 (一起来算一算吧) 回顶部 第一步:在上图中找到7,把这个【7】放到第一排第二个数的位置。 (也就是把图换个方向看看,这里就用到之前的准备工作啦)

现在我们来找找看,在图一中,三排一是【8】,那么图一就是我们这题需要的模型。

这时你会发现,图一现在的三排三,就是我们题目中的【4】。 第二步:把现在的图一9个数按顺序排列(熟练以后这一步可以省略) 6 7 2 1 5 9 8 3 4 第三步:消掉题目中给出的数字 6 2 1 5 9 3 这就是我们要的答案啦,亲们会算了吗? 下面来解释一下9宫格 第一,9宫格只有上图2种解法(事实上是一种,你会发现图二是图一的背面) 第二,9宫格的口诀:戴九履一,左三右七,二四有肩,八六为足,五居中央。 (这口诀是黄蓉说的,我就是这样记住的需要注意古代人认字是从右至左,别搞错方向拉!) 且说...9宫格的源头在河图洛书上,河图洛书也是中华文明的源头。(这个解释起来有很多要说,相信你不会希望我说太多,因为我很啰嗦) 嗯~~~这样说吧,上面的方法是我能想到的最简单直接明了的方法。 如果亲们有更好的方法算9宫,就拿出来跟大家一起分享吧 如有侵权请联系告知删除,感谢你们的配合!

《人工智能基础》实验报告-实验名称:启发式搜索算法

实验名称:启发式搜索算法 1、实验环境 Visual C++ 6.0 2、实验目的和要求 (复述问题)使用启发式算法求解8数码问题 (1)编制程序实现求解8数码问题A*算法,采用估价函数 f(n)=d(n)+p(n) 其中:d(n)是搜索树中结点n的深度;w(n)为节点n的数据库中错放的旗子个数; p(n)为结点n的数据库中每个棋子与其目标位置之间的距离总和。 (2)分析上述(1)中两种估价函数求解8数码问题的效率差别,给出一个是p(n)的上界h(n)的定义,并测试该估价函数是否使算法失去可采纳性。 实验目的:熟练掌握启发式搜索A*算法及其可采纳性。 3、解题思路、代码 3.1解题思路 八数码问题的求解算法 (1)盲目搜索 宽度优先搜索算法、深度优先搜索算法 (2)启发式搜索 启发式搜索算法的基本思想是:定义一个评价函数f,对当前的搜索状态进行评估,找出一个最有希望的节点来扩展。 先定义下面几个函数的含义: f*(n)=g*(n)+h*(n) (1) 式中g*(n)表示从初始节点s到当前节点n的最短路径的耗散值;h*(n)表示从当前节点n到目标节点g的最短路径的耗散值,f*(n)表示从初始节点s经过n到目标节点g的最短路径的耗散值。 评价函数的形式可定义如(2)式所示: f(n)=g(n)+h(n) (2) 其中n是被评价的当前节点。f(n)、g(n)和h(n)分别表示是对f*(n)、g*(n)和h*(n)3个函数值的估计值。 利用评价函数f(n)=g(n)+h(n)来排列OPEN表节点顺序的图搜索算法称为算法A。在A算法中,如果对所有的x,h(x)<=h*(x) (3)成立,则称好h(x)为h*(x)的下界,它表示某种偏于保守的估计。采用h*(x)的下界h(x)为启发函数的A算法,称为A*算法针对八数码问题启发函数设计如下: F(n)=d(n)+p(n) (4)

A-算法人工智能课程设计

人工智能(A*算法) 一、 A*算法概述 A*算法是到目前为止最快的一种计算最短路径的算法,但它一种‘较优’算法,即它一般只能找到较优解,而非最优解,但由于其高效性,使其在实时系统、人工智能等方面应用极其广泛。 A*算法结合了启发式方法(这种方法通过充分利用图给出的信息来动态地作出决定而使搜索次数大大降低)和形式化方法(这种方法不利用图给出的信息,而仅通过数学的形式分析,如Dijkstra算法)。它通过一个估价函数(Heuristic Function)f(h)来估计图中的当前点p到终点的距离(带权值),并由此决定它的搜索方向,当这条路径失败时,它会尝试其它路径。 因而我们可以发现,A*算法成功与否的关键在于估价函数的正确选择,从理论上说,一个完全正确的估价函数是可以非常迅速地得到问题的正确解答,但一般完全正确的估价函数是得不到的,因而A*算法不能保证它每次都得到正确解答。一个不理想的估价函数可能会使它工作得很慢,甚至会给出错误的解答。 为了提高解答的正确性,我们可以适当地降低估价函数的值,从而使之进行更多的搜索,但这是以降低它的速度为代价的,因而我们可以根据实际对解答的速度和正确性的要求而设计出不同的方案,使之更具弹性。 二、 A*算法分析 众所周知,对图的表示可以采用数组或链表,而且这些表示法也各也优缺点,数组可以方便地实现对其中某个元素的存取,但插入和删除操作却很困难,而链表则利于插入和删除,但对某个特定元素的定位却需借助于搜索。而A*算法则需要快速插入和删除所求得的最优值以及可以对当前结点以下结点的操作,因而数组或链表都显得太通用了,用来实现A*算法会使速度有所降低。要实现这些,可以通过二分树、跳转表等数据结构来实现,我采用的是简单而高效的带优先权的堆栈,经实验表明,一个1000个结点的图,插入而且移动一个排序的链表平均需500次比较和2次移动;未排序的链表平均需1000次比较和2次移动;而堆仅需10次比较和10次移动。需要指出的是,当结点数n大于10,000时,堆将不再是正确的选择,但这足已满足我们一般的要求。

AI人工智能的几种常用算法概念

一、粒子群算法 粒子群算法,也称粒子群优化算法(Particle Swarm Optimization),缩写为PSO,是近年来发展起来的一种新的进化算法((Evolu2tionary Algorithm - EA)。PSO 算法属于进化算法的一种,和遗传算法相似,它也是从随机解出发,通过迭代寻找最优解,它也是通过适应度来评价解的品质,但它比遗传算法规则更为简单,它没有遗传算法的交叉(Crossover) 和变异(Mutation) 操作,它通过追随当前搜索到的最优值来寻找全局最优。这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视,并且在解决实际问题中展示了其优越性。 优化问题是工业设计中经常遇到的问题,许多问题最后都可以归结为优化问题.为了解决各种各样的优化问题,人们提出了许多优化算法,比较著名的有爬山法、遗传算法等.优化问题有两个主要问题:一是要求寻找全局最小点,二是要求有较高的收敛速度.爬山法精度较高,但是易于陷入局部极小.遗传算法属于进化算法(EvolutionaryAlgorithms)的一种,它通过模仿自然界的选择与遗传的机理来寻找最优解.遗传算法有三个基本算子:选择、交叉和变异.但是遗传算法的编程实现比较复杂,首先需要对问题进行编码,找到最优解之后还需要对问题进行解码,另外三个算子的实现也有许多参数,如交叉率和变异率,并且这些参数的选择严重影响解的品质,而目前这些参数的选择大部分是依靠经验.1995年Eberhart博士和kennedy博士提出了一种新的算法;粒子群优化(ParticalSwarmOptimization-PSO)算法.这种算法以其实现容易、精度高、收敛快等优点引起了学术界的重视,并且在解决实际问题中展示了其优越性. 粒子群优化(ParticalSwarmOptimization-PSO)算法是近年来发展起来的一种新的进化算法(Evolu2tionaryAlgorithm-EA).PSO算法属于进化算法的一种,和遗传算法相似,它也是从随机解出发,通过迭代寻找最优解,它也是通过适应度来评价

人工智能算法在图像处理中的应用

人工智能算法在图像处理中的应用 人工智能算法在图像处理中的应用人工智能算法包括遗传算法、蚁群算法、模拟退火算法和粒子群算法等,在图像边缘检测、图像分割、图像识别、图像匹配、图像分类等领域有广泛应用。本文首先介绍常用人工智能算法的的原理和特点,然后将其在图像处理方面的应用进行综述,最后对应用前景做出展望。【关键词】人工智能算法图像处理人工智能算法是人类受自然界各种事物规律(如人脑神经元、蚂蚁觅食等)的启发,模仿其工作原理求解某些问题的算法。随着计算机技术的发展,人工智能算法在图像处理方面得到广泛应用。当前流行的人工智能算法包括人工神经网络、遗传算法、蚁群算法、模拟退火算法、粒子群算法等。 1 人工神经网络人工神经网络是一种模拟动物神经网络行为特征,进行分布式并行信息处理的算法数学模型,通过调整内部大量节点之间相互连接的关系,达到处理信息的目的,具有自组织、自学习、自推理和自适应等优点。神经网络可用于图像压缩,将图像输入层和输出层设置较多节点,中间传输层设置较少节点,学习后的网络可以较少的节点表示图像,用于存储和传输环节,节约了存储空间,提高的传输效率,最后在输出层将图像还原。学者Blanz和Gish 提出一个三层的前馈神经网络图像分割模型,Babaguchi提出多层BP网络获取图像的分割阈值,Ghosh使用神经网络

对大噪声的图像进行分割。J.Cao使用PCA神经网络提取图像特征来对图像进行分类,B.Lerner用神经网络对人类染色体图像进行分类。神经网络还可与小波变换相结合(MCNN)对手写体数字进行多分辨率识别。 2 遗传算法遗传算法(Genetic Algorithm,GA)是模拟生物进化论的自然选择和遗传学进化过程的计算模型,是一种通过模拟自然进化过程随机搜索最优解的方法,体现了适者生存、优胜劣汰的进化原则,其主要特点是直接对结构对象进行操作,不存在求导和函数连续性的限定,具有并行性和较强的全局寻优能力。遗传算法把问题的解表示成染色体,求解步骤如下: (1)编码:定义问题的解空间到染色体编码空间的映射,一个候选解(个体)用一串符号表示。(2)初始化种群:在一定的限制条件下初始化种群,该种群是解空间的一个子空间。(3)设计适应度函数:将种群中的每个染色体解码成适于适应度函数的形式,计算其数值。(4)选择:根据适应度大小选择优秀个体繁殖下一代,适应度越高,选择概率越大。(5)交叉:随机选择两个用于繁殖下一代的个体的相同位置,在选中的位置实行交换。(6)变异:对某个串中的基因按突变概率进行翻转。(7)从步骤4开始重复进行,直到满足某一性能指标或规定的遗传代数。GA在图像分割领域应用最为成熟,只要有两种应用,一是在多种分割结果中搜索最佳分割结果,二是搜索图像分割算法的最优参数,如用来确定图

九宫格实现算法

实验目的:通过visual c++进行算法编辑,准确掌握算法运行方式及流程。 通过程序实现类似九宫格的拼图效果,也叫做八方块。用最快的时间实现最后的 效果:1 2 3 4 5 6 7 8 0 实验原理:先实现一个三行三列数组,再依次比较第一个数与上下左右数值的大小,进行移动,最后实现效果图。计算出一共移动的步数和每移一步的效果。 实验内容: 程序代码如下: // 8block.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #define GOAL 123804765//表示我们要找得目标状态 struct Node { short state[9];//存放结点的状态 short pos;//空格所在的位置,在数组中用0代表空格 struct Node *up;//空格上移后的状态 struct Node *down;//空格下移后的状态 struct Node *left;//空格左移后的状态 struct Node *right;//空格右移后的状态 struct Node *parent;//它是从哪一状态变换而来的 struct Node *next;//表示在队列中的下一个状态 } ; struct Tree { short key;//表示当前结点的数值 short * state;//表示当前状态的整个数组,当整颗树生成完毕后这一数组将被释 放 short index;//表示当前数值在数组中的位置 bool visited;//对于叶子结点而言,表示这一结点是否被访问过 struct Tree * next;//指向它的(下一个)兄弟结点,表示这一位置的下一个数 struct Tree *down;//指向它的第一个孩子结点,表示下一位置的第一个数}; struct Queue//定义一个队列用于广度优先遍历 { struct Node * front; struct Node * rear; };

2019年人工智能考试题答案

1.在高血压诊断标准的变迁史上,()将高血压的诊断标准定为120/80mmHg以下更受益。( 2.0分) A.1949年 B.1984年 C.1993年 D.2016年 2.我国在语音语义识别领域的领军企业是()。(2.0分) A.科大讯 飞 B.图谱科 技 C.阿里巴 巴 D.华为 3.中国人工智能产业初步呈现集聚态势,人工智能企业主要集聚在经济发达的一二线城市及沿海地区,排名第一的城市是()。(2.0分) A. B.北京 C. D. 4.MIT教授Tomaso Poggio明确指出,过去15年人工智能取得的成功,主要是因为()。(2.0分) A.计算机视 觉 B.语音识别 C.博弈论 D.机器学习 5.1997年,Hochreiter&Schmidhuber提出()。(2.0分)

A.反向传播算法 B.深度学习 C.博弈论 D.长短期记忆模型 6.(),中共中央政治局就人工智能发展现状和趋势举行第九次集体学习。(2.0分) A.2018年3月15日 B.2018年10月31日 C.2018年12月31日 D.2019年1月31日 7.()是指能够自己找出问题、思考问题、解决问题的人工智能。(2.0分) A.超人工智 能 B.强人工智 能 C.弱人工智 能 D.人工智能 8.据清华原副校长施一公教授研究,中国每年有265万人死于(),占死亡人数的28%。(2.0分) A.癌症 B.心脑血管疾病 C.神经退行性疾 病 D.交通事故 9.2005年,美国一份癌症统计报告表明:在所有死亡原因中,癌症占()。(2.0分) A.1/4

B.1/3 C.2/3 D.3/4 10.()是自然语言处理的重要应用,也可以说是最基础的应用。(2.0分) A.文本识别 B.机器翻译 C.文本分类 D.问答系统 11.()是人以自然语言同计算机进行交互的综合性技术,结合了语言学、心理学、工程、计算机技术等领域的知识。(2.0分) A.语音交互 B.情感交互 C.体感交互 D.脑机交互 12.下列对人工智能芯片的表述,不正确的是()。(2.0分) A.一种专门用于处理人工智能应用中大量计算任务的芯片 B.能够更好地适应人工智能中大量矩阵运算 C.目前处于成熟高速发展阶段 D.相对于传统的CPU处理器,智能芯片具有很好的并行计算性能 13.()是指能够按照人的要求,在某一个领域完成一项工作或者一类工作的人工智能。(2.0分) A.超人工智 能 B.强人工智 能 C.弱人工智 能 D.人工智能

人工智能算法实现

人工智能算法实现:[1]A*算法c语言 ? 分步阅读 A*算法,A*(A-Star)算法是一种静态路网中求解最短路最有效的方法。估价值与实际值越接近,估价函数取得就越好。 A*[1](A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为:f(n)=g(n)+h(n), 其中f(n) 是从初始点经由节点n到目标点的估价函数, g(n) 是在状态空间中从初始节点到n节点的实际代价, h(n) 是从n到目标节点最佳路径的估计代价。 保证找到最短路径(最优解的)条件,关键在于估价函数h(n)的选取: 估价值h(n)<= n到目标节点的距离实际值,这种情况下,搜索的点数多,搜索范围大,效率低。但能得到最优解。 如果估价值>实际值,搜索的点数少,搜索范围小,效率高,但不能保证得到最优解。 工具/原料 ?DEVC++或VC 6.0 方法/步骤 1.估价值与实际值越接近,估价函数取得就越好 例如对于几何路网来说,可以取两节点间欧几理德距离(直线距离)做为估价值,即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny));这样估价函数f在g值一定的情况下,会或多或少的受估价值h的制约,节点距目标点近,h值小,f 值相对就小,能保证最短路的搜索向终点的方向进行。明显优于Dijkstra算法的毫无方向的向四周搜索。 conditions of heuristic

Optimistic (must be less than or equal to the real cost) As close to the real cost as possible 详细内容: 创建两个表,OPEN表保存所有已生成而未考察的节点,CLOSED表中记录已访问过的节点。 算起点的估价值; 将起点放入OPEN表; 2. A star算法在静态路网中的应用,以在地图中找从开始点s 到e点的最短 行走路径为例: 首先定义数据结构 #define MAPMAXSIZE 100 //地图面积最大为100x100 #define MAXINT 8192 //定义一个最大整数, 地图上任意两点距离不会超过它#define STACKSIZE 65536 //保存搜索节点的堆栈大小 #define tile_num(x,y) ((y)*map_w+(x)) //将x,y 坐标转换为地图上块的编号#define tile_x(n) ((n)%map_w) //由块编号得出x,y 坐标 #define tile_y(n) ((n)/map_w) // 树结构, 比较特殊, 是从叶节点向根节点反向链接

基于人工智能的路径查找优化算法【精品毕业设计】(完整版)

毕业设计[论文] 题目:基于人工智能的路径查找优化算法 学生姓名: Weston 学号:090171021XXX 学部(系):信息科学与技术学部 专业年级:计算机应用技术 指导教师:XXX 职称或学位: XX 2012 年 5 月 18 日

目录 摘要............................................................... II ABSTRACT ........................................................... III KEY WORDS .......................................................... III 1.前言 (1) 2.概述 (2) 2.1遗传算法优缺点 (2) 2.2遗传算法应用领域 (3) 2.3遗传算法基本流程 (3) 3.传统遗传算法解决旅行商问题 (5) 3.1常用概念 (5) 3.2基本过程 (5) 3.3关键步骤 (5) 3.4总结 (8) 4.改进后的遗传算法 (9) 4.1编码、设计遗传算子 (9) 4.2种群初始化 (9) 4.3评价 (10) 4.4选择复制 (10) 4.5交叉 (11) 4.6变异 (12) 4.7终结 (13) 5.系统设计与实现 (14) 5.1系统设计 (14) 5.2系统实现 (17) 5.3结果分析 (20) 6.总结 (21) 参考文献 (22) 致谢 (23)

基于人工智能的路径查找优化算法 摘要 旅行商是一个古老且有趣的问题它可以描述为:给定n个城市以及它们之间的距离(城市i到城市j的距离),求解从其中一个城市出发对每个城市访问,且仅访问一d ij 次,最后回到出发的城市,应当选取怎样的路线才能使其访问完所有的城市后回到初始的城市且走过的路程最短。 旅行商问题已被证明是属优化组合领域的NP难题,而且在现实中的许多问题都可以转化为旅行商问题来加以解决。解决旅行商问题最一般的方法就是枚举出所有可能的路线然后对每一条进行评估最后选取出路程最短的一条即为所求解。 解决旅行商问题的各种优化算法都是通过牺牲解的精确性来换取较少的耗时,其他一些启发式的搜索算法则依赖于特定的问题域,缺乏通用性,相比较而言遗传算法是一种通用性很好的全局搜索算法。 遗传算法GA( genetic algorithm) 最早由美国密歇根大学的John Holland 提出。具有自组织、自适应、自学习和群体进化功能有很强的解决问题的能,在许多领域都得到了应用。 遗传算法以其广泛的适应性渗透到研究与工程的各个领域,已有专门的遗传算法国际会议,每两年召开一次,如今已开了数次,发表了数千篇论文,对其基本的理论、方法和技巧做了充分的研究。今天,遗传算法的研究已成为国际学术界跨学科的热门话题之一。 关键词:人工智能;遗传算法;TSP;旅行商问题

生命密码算法大全[1]

一、先计算天赋数与生命数(阳历出生日) 1974年7月3日 1+9+7+4+7+3=31 (3,1是天赋数) 3+1=4 (4是生命数) 1974年7月29日 1+9+7+4+7+2+9=39 (3,9是天赋数) 3+9=12 1+2=3 (3是生命数) 0是加强,比如天赋数 1,0 表示决对的天生领导人,生命数为1 那么连起来是101可查卓越数 二、按两个天赋数字及数字上的圈数查天赋表,按生命数字查生命表,按圈数查身体状况 天赋数: 1、独立、主见、天生领袖、个性较急 圈多:主观意识强,很想成功(不能指挥他) 无圈:无个人主意 2、信任别人、双重性格、在分析、色彩造型、艺术鉴赏、文学方面有优秀表现。圈多:依赖、有生活品味 无圈:不擅长合作,待他人比待自己好,容易受伤 3、创意、艺术表达力,多愁善感型 圈多:不能批评,理想坚持度高,有创意 无圈:沟通能力不好,还原改变 4、组织能力强、稳定 圈多:稳定性高,不易受影响 无圈:易受影响,改变太多 5、爱好自由、口才好、美食家、旅行家、个性开朗 圈多:主动性强,自由,不断变化,爱旅游,爱唱歌,口才好,爱吃 无圈:主动性差,要别人指导与督促,较内向,对爱情缺乏安全感 6、负责、天生有治疗别人的能力,喜欢交朋友 圈多:照顾人群、责任心强 无圈:对他人需求迟钝,要直接讲明白,不太愿意承担责任 7、好奇心,求知欲强、追求真理 圈多:好奇、质疑、专横 无圈:爱热闹,心胸开放,易相信别人 8、生意、公关、人际开发能力强,最讨厌别人懒惰 圈多:商业头脑、权力欲及公关能力强 无圈:不在乎权势,对钱没概念,不善理财 9、慈悲家、梦想家、与宗教有缘份 圈多:服务高手(不能批评)

人工智能启发式图搜索算法

启发式图搜索算法 摘要:启发式搜索策略概述和有序搜索。启发式搜索弥补盲目搜索的不足,提高搜索效率。一种方法用于排列待扩展节点的顺序,即选择最有希望的节点加以扩展,那么,搜索效率将会大为提高。进行搜索技术一般需要某些有关具体问题领域的特性的信息。 关键词:启发式搜索;估价函数;有序搜索;A*算法; 正文: 启发式图搜索的意义因为无信息图搜索算法的效率低,耗费过多的计算空间与时间,这是组合爆炸的一种表现形式。所以引入了启发式图搜索算法。 启发式图搜索算法就是进行搜索技术一般需要某些有关具体问题领域的特性的信息,把此种信息叫做启发信息。利用启发信息的搜索方法叫做启发式搜索方法。关于图搜索的启发式搜索算法就叫做启发式图搜索算法。 启发式图搜索策略:假设初始状态、算符和目标状态的定义都是完全确定的,然后决定一个搜索空间。因此,问题就在于如何有效地搜索这个给定空间。 启发信息按其用途可分为下列3种: (1) 用于决定要扩展的下一个节点,以免像在宽度优先或深度优先搜索中那样盲目地扩展。 (2) 在扩展一个节点的过程中,用于决定要生成哪一个或哪几个后继节点,以免盲目地同时生成所有可能的节点。 (3) 用于决定某些应该从搜索树中抛弃或修剪的节点。 启发信息的状态空间搜索算法,即决定哪个是下一步要扩展的节点。这种搜索总是选择“最有希望”的节点作为下一个被扩展的节点。这种搜索叫做有序搜索(ordered search)。有关具体问题领域的信息常常可以用来简化搜索。一个比较灵活(但代价也较大)的利用启发信息的方法是应用某些准则来重新排列每一步OPEN表中所有节点的顺序。然后,搜索就可能沿着某个被认为是最有希望的边缘区段向外扩展。应用这种排序过程,需要某些估算节点“希望”的量度,这种量度叫做估价函数(evalution function)。所谓的估价函数就是为获得某些节点“希望”的启发信息,提供一个评定侯选扩展节点的方法,以便确定哪个节点最有可能在通向目标的最佳路径上。f(n)——表示节点n的估价函数值建立估价函数的一般方法:试图确定一个处在最佳路径上的节点的概率;提出任意节点与目标集之间的距离量度或差别量度;或者在棋盘式的博弈和难题中根据棋局的某些特点来决定棋局的得分数。这些特点被认为与向目标节点前进一步的希望程度有关。 有序搜索应用某个算法(例如等代价算法)选择OPEN表上具有最小f值的节点作为下一个要扩展的节点。这种搜索方法叫做有序搜索(ordered search)或最佳优先搜索 (best-first search),而其算法就叫做有序搜索算法或最佳优先算法。尼尔逊曾提出一个有序搜索的基本算法。估价函数f是这样确定的:一个节点的希望程序越大,其f值就越小。被选为扩展的节点,是估价函数最小的节点。选择OPEN表上具有最小f值的节点作为下一个要扩展的节点,即总是选择最有希望的节点作为下一个要扩展的节点。 有序状态空间搜索算法 (1) 把起始节点S放到OPEN表中,计算f(S)并把其值与节点S联系起来。 (2) 如果OPEN是个空表,则失败退出,无解。 (3) 从OPEN表中选择一个f值最小的节点i。结果有几个节点合格,当其中有一个为目标节点时,则选择此目标节点,否则就选择其中任一个节点作为节点i。

人工智能期末试题及答案完整版(最新)

一单项选择题(每小题2分,共10分) 1.首次提出“人工智能”是在(D )年 A.1946 B.1960 C.1916 D.1956 2. 人工智能应用研究的两个最重要最广泛领域为:B A.专家系统、自动规划 B. 专家系统、机器学习 C. 机器学习、智能控制 D. 机器学习、自然语言理解 3. 下列不是知识表示法的是 A 。 A:计算机表示法B:“与/或”图表示法 C:状态空间表示法D:产生式规则表示法 4. 下列关于不确定性知识描述错误的是 C 。 A:不确定性知识是不可以精确表示的 B:专家知识通常属于不确定性知识 C:不确定性知识是经过处理过的知识 D:不确定性知识的事实与结论的关系不是简单的“是”或“不是”。 5. 下图是一个迷宫,S0是入口,S g是出口,把入口作为初始节点,出口作为目标节点,通道作为分支,画出从入口S0出发,寻找出口Sg的状态树。根据深度优先搜索方法搜索的路径是 C 。 A:s0-s4-s5-s6-s9-sg B:s0-s4-s1-s2-s3-s6-s9-sg C:s0-s4-s1-s2-s3-s5-s6-s8-s9-sg D:s0-s4-s7-s5-s6-s9-sg 二填空题(每空2分,共20分) 1.目前人工智能的主要学派有三家:符号主义、进化主义和连接主义。 2. 问题的状态空间包含三种说明的集合,初始状态集合S 、操作符集合F以及目标状态集合G 。 3、启发式搜索中,利用一些线索来帮助足迹选择搜索方向,这些线索称为启发式(Heuristic)信息。 4、计算智能是人工智能研究的新内容,涉及神经计算、模糊计算和进化计算等。 5、不确定性推理主要有两种不确定性,即关于结论的不确定性和关于证据的不确 定性。

数据结构课程设计之九宫格

#include #include #include #include #include"Basic_Operation.h" #define U 56//up #define D 57//down #define L 58//left #define R 59//right typedef struct LNode{ int data;//用一个各位不相等的9位数来表示当前状态,9表示空格 int flag;//0表示由初始状态生成,1表示由末状态生成 int fangxaing;//表示双亲结点生成此结点时空格的移动方向 char *path;//存放路径的数组下标,比实际值小1 struct LNode *next,*next1;//next用于队列中,next1用于链表 }LNode,*Linklist; typedef struct { Linklist front,rear; }LinkQueue,*Queue; void gotoxy(int x, int y) { int xx=0x0b; HANDLE hOutput; COORD loc; loc.X=x; loc.Y=y; hOutput = GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleCursorPosition(hOutput, loc); return; } void HideCursor() { CONSOLE_CURSOR_INFO cursor_info = {1, 0}; SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info); } int InitQueue(Queue Q) { Q->front=(Linklist)malloc(sizeof(LNode)); Q->rear=Q->front; return 1; } int EnQueue(Queue Q,Linklist tem) {

人工智能A星算法解决八数码难题程序代码

#include "Stdio.h" #include "Conio.h" #include "stdlib.h" #include "math.h" void Copy_node(struct node *p1,struct node *p2); void Calculate_f(int deepth,struct node *p); void Add_to_open(struct node *p); void Add_to_closed(struct node *p); void Remove_p(struct node *name,struct node *p); int Test_A_B(struct node *p1,struct node *p2); struct node * Search_A(struct node *name,struct node *temp); void Print_result(struct node *p); struct node // 定义8数码的节点状态 { int s[3][3]; //当前8数码的状态 int i_0; //当前空格所在行号 int j_0; //当前空格所在列号 int f; //当前代价值 int d; //当前节点深度 int h; //启发信息,采用数码"不在位"距离和 struct node *father; //指向解路径上该节点的父节点 struct node *next; //指向所在open或closed表中的下一个元素 } ; struct node s_0={{2,8,3,1,6,4,7,0,5},2,1,0,0,0,NULL,NULL}; //定义初始状态 struct node s_g={{1,2,3,8,0,4,7,6,5},1,1,0,0,0,NULL,NULL}; //定义目标状态 struct node *open=NULL; //建立open表指针struct node *closed=NULL; //建立closed表指针int sum_node=0; //用于记录扩展节点总数 //*********************************************************** //********************** ********************** //********************** 主函数开始********************** //********************** ********************** //*********************************************************** void main() {

相关文档
最新文档