人工智能大作业实验

合集下载

西电人工智能大作业

人工智能大作业学生：021151**021151**时间：2013年12月4号一．启发式搜索解决八数码问题1. 实验目的问题描述：现有一个3*3的棋盘，其中有0-8一共9个数字，0表示空格，其他的数字可以和0交换位置（只能上下左右移动）。

给定一个初始状态和一个目标状态，找出从初始状态到目标状态的最短路径的问题就称为八数码问题。

例如：实验问题为从初始状态：要求编程解决这个问题，给出解决这个问题的搜索树以及从初始节点到目标到目标状态：节点的最短路径。

2.实验设备及软件环境利用计算机编程软件Visual C++ 6.0，用C语言编程解决该问题。

3.实验方法(1).算法描述：①.把初始节点S放到OPEN表中，计算()f S，并把其值与节点S联系起来。

②.如果OPEN表是个空表，则失败退出，无解。

③.从OPEN表中选择一个f值最小的节点。

结果有几个节点合格，当其中有一个为目标节点时，则选择此目标节点，否则就选择其中任一节点作为节点i。

④.把节点i从OPEN表中移出，并把它放入CLOSED的扩展节点表中。

⑤.如果i是目标节点，则成功退出，求得一个解。

⑥.扩展节点i，生成其全部后继节点。

对于i的每一个后继节点j：a.计算()f j。

b.如果j既不在OPEN表中，也不在CLOSED表中，则用估价函数f把它添加入OPEN表。

从j加一指向其父辈节点i的指针，以便一旦找到目标节点时记住一个解答路径。

c.如果j已在OPEN表或CLOSED表上，则比较刚刚对j计算过的f值和前面计算过的该节点在表中的f值。

如果新的f值较小，则I.以此新值取代旧值。

II.从j指向i，而不是指向它的父辈节点。

III.如果节点j在CLOSED表中，则把它移回OPEN表。

⑦转向②，即GO TO ②。

(2).流程图描述：(3).程序源代码：#include <stdio.h>#include<stdlib.h>struct node{int number[3][3];//用二维数组存放8数码 int W;//W表示与目标状态相比错放的数码数int Depth;//记录当前节点的深度struct node *parent;//指向父节点的指针struct node *next;//指向链表中下一个节点的指针};int CounterW(int Number[3][3]){//函数说明：计算当前状态与目标状态的W值int i,j;int W=0;int Desnode[3][3]={1,2,3,8,0,4,7,6,5};for(i=0; i<3; i++)for(j=0; j<3; j++)if(Number[i][j] != Desnode[i][j])W++;return W;}void PrintNode(node *A){int i,j;for(i=0; i<3; i++){for(j=0; j<3; j++)printf("%d ",A->number[i][j]);printf("\n");}printf("\n");}int CheckNode(node *open, node *close, int a[3][3]) {//检验该节点状态是否出现过的子程序int CheckFlag=0;int flag1,flag2;node *p=open;node *q=close;while(p != NULL){flag1=0;for(int i=0; i<3; i++){for(int j=0; j<3; j++)if(a[i][j]==p->number[i][j])flag1++;}if(flag1 == 9)break;elsep=p->next;}while(q != NULL){flag2=0;for(int i=0; i<3; i++){for(int j=0; j<3; j++)if(a[i][j] == q->number[i][j])flag2++;}if(flag2 == 9)break;elseq=q->next;}if((flag1==9) || (flag2==9))CheckFlag=1;//如果出现过，置标志位为1return CheckFlag;}struct node *FindNextNode(node *Prenode, node *open, node *close) { //扩展Prenode指向的节点，并将扩展所得结点组成一条单链表int i,j,m,n; //循环变量int temp; //临时替换变量int flag=0;int a[3][3];//临时存放二维数组struct node *p, *q, *head;head=(node *)malloc(sizeof(node));//head指向该链表首结点，并且作为返回值p=head;q=head;head->next=NULL;//初始化for(i=0;i<3;i++)//找到二维数组中0的位置{for(j=0;j<3;j++)if(Prenode->number[i][j]==0){flag=1;break;}if(flag==1)break;}//根据0的位置的不同，对a进行相应的变换for(m=0;m<3;m++)//将Prenode->number赋给afor(n=0;n<3;n++)a[m][n]=Prenode->number[m][n];if(i+1<=2)//情况1，0向下移{temp=a[i][j]; a[i][j]=a[i+1][j]; a[i+1][j]=temp;int CheckNum=CheckNode(open, close, a);if(CheckNum == 0)//若该结点未出现过则执行下面的操作{q=(node *)malloc(sizeof(node));for(m=0;m<3;m++)//将a赋给扩展节点q->number for(n=0;n<3;n++)q->number[m][n]=a[m][n];PrintNode(q);q->parent=Prenode;q->Depth=q->parent->Depth+1;//子结点的深度等于其父结点深度加1q->W=CounterW(q->number);q->next=NULL;p->next=q;//扩展节点插入head链表p=p->next;}}for(m=0;m<3;m++)//将Prenode->number重新赋给afor(n=0;n<3;n++)a[m][n]=Prenode->number[m][n];if(i-1>=0)//情况2,0向上移{temp=a[i][j]; a[i][j]=a[i-1][j]; a[i-1][j]=temp;int CheckNum=CheckNode(open, close, a);if(CheckNum == 0)//若该结点未出现过则执行下面的操作{q=(node *)malloc(sizeof(node));for(m=0;m<3;m++)//将a赋给q->numberfor(n=0;n<3;n++)q->number[m][n]=a[m][n];PrintNode(q);q->parent=Prenode;q->Depth=q->parent->Depth+1;q->W=CounterW(q->number);q->next=NULL;p->next=q;p=p->next;}}for(m=0; m<3; m++)for(n=0; n<3; n++)a[m][n]=Prenode->number[m][n];if(j-1>=0)//情况3,0向左移{temp=a[i][j]; a[i][j]=a[i][j-1]; a[i][j-1]=temp;int CheckNum=CheckNode(open, close, a);if(CheckNum == 0)//若该结点未出现过则执行下面的操作{q=(node *)malloc(sizeof(node));for(m=0; m<3; m++)//将a赋给q->numberfor(n=0; n<3; n++)q->number[m][n]=a[m][n];PrintNode(q);q->parent=Prenode;q->Depth=q->parent->Depth+1;q->W=CounterW(q->number);q->next=NULL;p->next=q;p=p->next;}}for(m=0;m<3;m++)for(n=0;n<3;n++)a[m][n]=Prenode->number[m][n];if(j+1<=2)//情况4,0向右移{temp=a[i][j]; a[i][j]=a[i][j+1]; a[i][j+1]=temp;int CheckNum=CheckNode(open, close, a);if(CheckNum == 0)//若该结点未出现过则执行下面的操作{q=(node *)malloc(sizeof(node));for(m=0; m<3; m++)//将a赋给q->numberfor(n=0; n<3; n++)q->number[m][n]=a[m][n];PrintNode(q);q->parent=Prenode;q->Depth=q->parent->Depth+1;q->W=CounterW(q->number);q->next=NULL;p->next=q;p=p->next;}}head=head->next;return head;}node *insert(node *open,node *head){ //将head链表的结点依次插入到open链表相应的位置，//使open表中的结点按从小到大排序。

大工23春《人工智能》大作业题目及要求

大工23春《人工智能》大作业题目及要求引言概述：人工智能（Artificial Intelligence，简称AI）是一门关注于使机器能够模仿人类智能行为的科学与技术。

在大工23春的《人工智能》课程中，学生们将面临一项重要的大作业。

本文将介绍大工23春《人工智能》大作业的题目和要求。

正文内容：1. 题目一：机器学习算法的实现与应用1.1 算法选择：学生需选择并实现一个机器学习算法，如决策树、支持向量机、神经网络等。

1.2 数据集准备：学生需准备一个合适的数据集，用于训练和测试所选择的机器学习算法。

1.3 算法实现：学生需要编写代码，实现所选择的机器学习算法，并对数据集进行训练和测试。

2. 题目二：自然语言处理应用开发2.1 文本处理：学生需要选择一个自然语言处理任务，如文本分类、情感分析等，并准备相应的文本数据集。

2.2 特征提取：学生需要设计并实现合适的特征提取方法，将文本数据转化为机器学习算法可以处理的形式。

2.3 模型训练与应用：学生需要选择并实现一个适当的机器学习算法，对提取的特征进行训练，并应用于所选择的自然语言处理任务。

3. 题目三：计算机视觉应用开发3.1 图像处理：学生需要选择一个计算机视觉任务，如图像分类、目标检测等，并准备相应的图像数据集。

3.2 特征提取：学生需要设计并实现合适的特征提取方法，将图像数据转化为机器学习算法可以处理的形式。

3.3 模型训练与应用：学生需要选择并实现一个适当的机器学习算法，对提取的特征进行训练，并应用于所选择的计算机视觉任务。

4. 题目四：强化学习算法的实现与应用4.1 算法选择：学生需选择并实现一个强化学习算法，如Q-learning、Deep Q Network等。

4.2 环境建模：学生需要设计一个适当的环境，用于训练所选择的强化学习算法。

4.3 算法实现：学生需要编写代码，实现所选择的强化学习算法，并对环境进行训练和测试。

5. 题目五：深度学习模型的实现与应用5.1 模型选择：学生需选择并实现一个深度学习模型，如卷积神经网络、循环神经网络等。

人工智能大作业

大作业1、引言
1.1 背景
1.2 目的
1.3 范围
1.4 定义
2、文献综述
2.1 关于的研究历史
2.2 相关研究成果与应用领域
3、问题陈述
3.1 问题描述
3.2 研究的动机和意义
3.3 研究的目标和假设
4、方法ology
4.1 数据收集
4.2 数据处理与清洗
4.3 特征选择与提取
4.4 算法选择与实现
4.5 模型训练与优化
5、实验结果与分析
5.1 数据集描述
5.2 实验设置
5.3 结果分析与讨论
5.4 实验效果评估
6、结论与展望
6.1 主要研究结果总结 6.2 讨论与不足之处
6.3 对未来工作的展望附件：
附件1：数据集来源信息附件2：代码仓库
附件3：实验结果数据表格法律名词及注释：
1、：指通过模拟和模仿人类智能的方法和技术，使计算机系统能够自动执行任务、学习、适应和改进。

2、数据处理与清洗：指对原始数据进行筛选、过滤、去除噪声以及修复缺失值等操作，以提高数据的质量和可用性。

3、特征选择与提取：指从原始数据中选择最相关或最具代表性的特征，或通过计算、变换等方法提取出更具信息量的特征。

4、算法选择与实现：指根据问题的特点和要求，选择合适的算法，并通过编程实现。

5、模型训练与优化：指使用训练数据对选定的算法模型进行训练，并通过调整参数、改进算法等方式优化模型性能。

【内容详尽-格式完美 5000字+】人工智能大作业任务书实验报告

大作业任务书课程名称：人工智能题目：人工智能：生成智能专业：自动化班级：学号：学生姓名：任课教师：人工智能：生成智能摘要：人工智能在许多领域取得了空前的发展，对抗与博弈的思想也逐渐被应用于许多真实场景，如围棋，对抗游戏等。

不过，这篇文章所探讨的是基于博弈思想的深度学习鉴别生成模型—生成对抗网络(Generative Adversarial Nets,以下简称GANs)的前沿进展。

本文从生成模型的角度出发，针对GANs，使用了交叉熵作为生成器与判别器的损失函数，在基于Tensorflow的深度学习平台应用数字手写数据库MNIST证明了GANs的实用性与收敛性，此外，还综述了近期许多改进的GANs，探讨了其不同应用数据库场景的结果。

关键词：人工智能；博弈；深度学习；生成对抗网络；交叉熵一、引言深度学习旨在发掘在人工智能具有丰富的，分级的能够表征各种数据分布的模型，比如自然界的图像，语音，和自然语言处理等[1]。

深度学习隶属于人工智能的一个重要分支，其与机器学习具有交叉互容的关系，2012年ImageNet挑战赛正式拉开深度学习的序幕，或者说是深层神经网络。

深层神经网络由传统的单层感知机，多层感知机，神经网络发展而来，其为了解决高维数据的维度灾难，模型训练难以泛化，标准解难以收敛等诸多难题。

后续许多研究者投身深度学习领域，并将其应用于各个行业领域，如医疗图像诊断，无人驾驶，语义识别，场景识别等等，取得了不俗的效果。

到目前为止，在深度学习中最引人注目的成就包括了鉴别模型，通常是那些将高维、丰富的特征输入映射到类属标签的模型。

这些显著的成功主要基于反向传播和Dropout算法，使用具有特别良好性能的梯度的分段线性单元。

由于难以去逼近极大似然估计和相关策略中出现的许多难以处理的概率计算问题，以及由于在生成上下文中难以利用分段线性单元的优点，深度生成模型的影响较小。

深度生成模型的成功为深度学习打开了一扇新的大门,之后有许多研究取得了显著的效果。

人工智能大作业

人工智能大作业在当今科技飞速发展的时代，人工智能无疑是最具影响力和变革性的领域之一。

它已经悄然渗透进我们生活的方方面面，从智能手机中的语音助手，到医疗领域的疾病诊断，再到交通系统的智能调控，其身影无处不在。

人工智能的定义其实并不复杂，通俗地说，就是让机器能够像人类一样思考、学习和行动。

然而，要实现这一点，背后涉及到的技术和理论却极其复杂和深奥。

让我们先来谈谈人工智能在图像识别方面的应用。

以往，要让计算机理解一张图片的内容，几乎是天方夜谭。

但现在，通过深度学习算法，计算机可以准确地识别出图片中的物体、人物甚至是场景。

这一技术的应用范围十分广泛，比如在安防领域，能够快速识别出可疑人员；在自动驾驶中，帮助车辆识别道路标志和障碍物。

再来说说自然语言处理。

我们每天使用的语音助手，如 Siri 和小爱同学，就是自然语言处理的实际应用。

它们能够理解我们的语言，并给出相应的回答。

不仅如此，在机器翻译领域，人工智能也取得了巨大的进步。

以往的机器翻译往往生硬且不准确，而如今，借助深度学习和大规模语料库，翻译结果越来越流畅和准确。

人工智能在医疗领域的应用更是给人们带来了新的希望。

通过对大量医疗数据的分析，人工智能可以辅助医生进行疾病诊断，提高诊断的准确性和效率。

例如，在癌症的早期筛查中，人工智能系统能够从海量的影像数据中发现细微的病变迹象，为患者争取到宝贵的治疗时间。

然而，人工智能的发展也并非一帆风顺。

其中一个重要的挑战就是数据的质量和隐私问题。

高质量的数据对于训练有效的人工智能模型至关重要，但获取和整理这些数据并非易事。

同时，数据的隐私保护也成为了公众关注的焦点，如何在利用数据的同时确保个人隐私不被泄露，是亟待解决的问题。

另一个挑战是人工智能的伦理和道德问题。

比如，在决策过程中，如果人工智能系统存在偏见，可能会导致不公平的结果。

此外，当人工智能系统出现错误时，责任的界定也变得模糊不清。

尽管面临诸多挑战，但人工智能的未来依然充满无限可能。

人工智能《启发式搜索》实验大作业

《人工智能》实验大作业实验题目：启发式搜索一、实验目的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A算法求解九宫问题，理解求解流程和搜索顺序。

二、实验方法：1.先熟悉启发式搜索算法；2.用C、C++或JA V A 语言编程实现实验内容。

三、实验背景知识：1.估价函数在对问题的状态空间进行搜索时，为提高搜索效率需要和被解问题的解有关的大量控制性知识作为搜索的辅助性策略。

这些控制信息反映在估价函数中。

估价函数的任务就是估计待搜索节点的重要程度，给这些节点排定次序。

估价函数可以是任意一种函数，如有的定义它是节点x处于最佳路径的概率上，或是x节点和目标节点之间的距离等等。

在此，我们把估价函数f(n)定义为从初始节点经过n节点到达目标节点的最小代价路径的代价估计值，它的一般形式是：f(n) = g(n) + h(n)其中g(n)是从初始节点到节点n的实际代价，g(n)可以根据生成的搜索树实际计算出来；h(n)是从n到目标节点的最佳路径的代价估计，h(n)主要体现了搜索的启发信息。

2. 启发式搜索过程的特性（1）可采纳性当一个搜索算法在最短路径存在的时候能保证能找到它，我们就称该算法是可采纳的。

所有A*算法都是可采纳的。

（2）单调性一个启发函数h是单调的，如果a）对所有的状态n i和n j，其中n j是n i的子孙，h(n i )- h(n j )≤cost(n i,n j ),其中cost(n i,n j )是从n i到n j 实际代价。

b）目标状态的启发函数值为0，即h(Goal)=0.具有单调性的启发式搜索算法在对状态进行扩展时能保证所有被扩展的状态的f值是单调递增（不减）。

（3）信息性比较两个启发策略h1和h2，如果对搜索空间中的任何一个状态n都有h1(n) ≤h2(n)，就说h2比h1具有更多的信息性。

一般而言，若搜索策略h2比h1有更多的信息性，则h2比h1考察的状态要少。

但必须注意的是更多信息性需要更多的计算时间，从而有可能抵消减少搜索空间所带来的益处。

人工智能实验报告

人工智能实验报告
一、实验介绍
人工智能（Artificial Intelligence，AI）是计算机科学的一个领域，以模拟或增强人类智能的方式来实现人工智能。

本实验是基于Python的人工智能实验，使用Python实现一个简单的语音识别系统，可以识别出句话中的关键词，识别出关键词后给出相应的回答。

二、实验内容
1.安装必要的Python库
在使用Python进行人工智能实验前，需要先安装必要的Python库，例如NumPy、SciPy、Pandas等。

2.准备必要的数据集
为避免过拟合，需要准备数据集并对数据进行分离、标准化等处理，以便为训练和测试模型提供良好的环境。

3.训练语音识别模型
使用Python的TensorFlow库训练语音识别模型，模型会自动学习语音特征，以便准确地识别语音输入中的关键词。

4.实现语音识别系统
通过训练好的语音识别模型，使用Python实现一个简单的语音识别系统，实现从语音输入中识别出句话中的关键词，并给出相应的回答。

三、实验结果
本实验使用Python编写了一个简单的语音识别系统，实现从语音输
入中识别出句话中的关键词，并给出相应的回答。

通过对训练数据集的训练，模型可以准确地识别语音输入中的关键词，对测试数据集的准确率达到了87.45%，表示模型的效果较好。

四、总结。

人工智能大作业(一)

人工智能大作业（一）引言：人工智能（Artificial Intelligence，简称AI）是近年来备受关注的热门领域。

随着计算能力的提高和算法的进步，人工智能正在日益渗透到各个行业和领域中。

本文将探讨人工智能大作业的相关内容，着重分析了其中的五个重要方面。

正文：一、机器学习（Machine Learning）1.1 监督学习（Supervised Learning）的基本概念及示例1.2 无监督学习（Unsupervised Learning）的基本概念及应用领域1.3 强化学习（Reinforcement Learning）的基本原理和算法1.4 深度学习（Deep Learning）的基本结构和典型应用1.5 机器学习在人工智能大作业中的实践与挑战二、自然语言处理（Natural Language Processing）2.1 词法分析和语法分析的基本原理和任务2.2 语义分析和语义关系的理论基础和实践应用2.3 文本分类和情感分析的相关技术和方法2.4 机器翻译和语音识别的高级应用和发展趋势2.5 自然语言处理在人工智能大作业中的应用与挑战三、计算机视觉（Computer Vision）3.1 图像处理和特征提取的基本原理和方法3.2 目标检测和图像识别的常用算法和技术3.3 图像分割和场景理解的相关研究和实践3.4 视频分析和行为识别的进展和应用领域3.5 计算机视觉在人工智能大作业中的应用案例和前景展望四、数据挖掘（Data Mining）4.1 数据预处理和数据清洗的基础知识和常用技术4.2 数据集成和数据转换的数据挖掘流程和方法4.3 关联规则和聚类分析的基本概念和算法4.4 分类和预测分析的实践案例和评价指标4.5 数据挖掘在人工智能大作业中的应用与发展趋势五、智能决策系统（Intelligent Decision System）5.1 知识表示和推理的基本方法和知识表示语言5.2 不确定性建模和决策制定的技术和策略5.3 专家系统和推荐系统的典型特征和实现方法5.4 异常检测和智能优化的相关研究和应用5.5 智能决策系统在人工智能大作业中的实践案例和展望总结：人工智能大作业（一）涵盖了机器学习、自然语言处理、计算机视觉、数据挖掘和智能决策系统等五个重要方面。

人工智能大作业报告完整版

人工智能大作业报告 HEN system office room 【HEN16H-HENS2AHENS8Q8-HENH1688】人工智能课程大作业——基于回溯搜索的地图着色班级：学号：姓名：曾江东2014年11月26号摘要：人工智能是20世纪50年代中期兴起的一门边缘学科。

人工智能领域中，地图着色问题是一典型的优化的问题。

由它引发的“四色猜想”是全世界的难题，直到1975年由三台超高速电子计算机，经过1200小时的计算才终于正明了“四色定理”。

这是世界上最长的证明。

本文并不是想证明，而只是想基于回溯法来给地图着色，求出最少用色。

本文着重介绍利用MFC设计界面来对中国省级地图着色进行演示。

计算机视觉是研究为完成在复杂的环境中运动和在复杂的场景中识别物体所需要哪些视觉信息，以及如何从图像中获取这些信息的科学领域。

关键词：地图着色；回溯搜索；MFC本组成员：曾江东，杨星，俞洋本人分工：本人主要基于回溯搜索算法的代码的编写。

1 引言人，现在社会的发展中心都离不开这个人字，人是发展的本体，人类的自然智能伴随到处都是，本次实验研究什么是人工智能，人工智能又能如何的运用在生活和学习中。

人工智能(ArtificialIntelligence)，英文缩写为AI。

它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。

人工智能（ArtificialIntelligence，AI）是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。

人工智能从诞生以来，理论和技术日益成熟，应用领域也不断扩大，但没有一个统一的定义。

人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种新的能以人类智能相似的方式做出反应的智能机器，该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。

本次实验研究的是关于人工智能中搜索的功能，实现用回溯法对地图不同地区的着色问题，地图上有不同国家（不同区域），每个国家都与其他一些国家邻接。

人工智能大作业(二)2024

人工智能大作业（二）引言概述：本文旨在深入探讨人工智能大作业的相关内容。

人工智能作为一门快速发展的学科，对于学习者而言，进行相关的大作业是加深理解和应用该领域知识的重要方式之一。

本文将分析人工智能大作业的五个主要方面，包括数据集选择、算法设计、模型训练、结果分析以及展示与报告。

正文：1. 数据集选择：- 研究不同领域的数据集，并从中选择最适合研究课题的数据集。

- 评估数据集的规模、特征、质量等因素，并确保其能够支持后续的算法设计和模型训练过程。

- 如果需要，进行数据预处理操作，如去除噪声、处理缺失值等，以提高数据集的质量和可用性。

- 确保数据集的隐私和安全性，遵循相关法规和伦理原则。

2. 算法设计：- 了解和研究相关领域的常用算法，并选择适合问题的算法。

- 分析算法的优势和局限性，并根据研究课题的需要进行适当的修改和改进。

- 设计算法的流程和步骤，明确数据的输入和输出，以及各个阶段的处理过程。

- 考虑算法的效率和可扩展性，确保能够处理大规模的数据集和复杂的任务。

3. 模型训练：- 根据选定的算法，准备训练数据集和验证数据集，并进行数据集划分。

- 初始化模型参数，并进行模型训练和优化，以使模型能够更好地拟合训练数据。

- 考虑使用交叉验证和调参等技术，来选择最优的模型参数和超参数。

- 监控训练过程，分析模型在训练集和验证集上的性能表现，并根据需要进行调整和改进。

4. 结果分析：- 对训练得到的模型进行性能评估，并使用不同的评测指标来衡量模型的好坏。

- 分析模型在不同类型数据上的表现差异，并探讨其原因和解决办法。

- 进行模型的可解释性分析，了解模型对于预测结果的依赖和影响因素。

- 与其他相关工作进行比较，评估自己的研究成果在同领域中的创新性和贡献度。

5. 展示与报告：- 将实现的算法和训练得到的模型进行演示和展示，以直观地呈现出其性能和效果。

- 准备详细的报告文档，清晰地描述整个研究过程，包括问题定义、方法设计、实验结果和分析等内容。

人工智能实验

实验一 A*算法实验一、实验目的：熟悉和掌握启发式搜索的定义、估价函数和算法过程，并利用A*算法求解N数码难题，理解求解流程和搜索顺序。

二、实验原理：A*算法是一种有序搜索算法，其特点在于对估价函数的定义上。

对于一般的有序搜索，总是选择f值最小的节点作为扩展节点。

因此，f是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值为两个分量：从起始节点到节点n的代价以及从节点n到达目标节点的代价。

三、实验条件：1N数码难题演示程序。

2IE5.0以上，可以上Internet。

三、实验内容：1分别以8数码和15数码为例实际求解A*算法。

2画出A*算法求解框图。

3分析估价函数对搜索算法的影响。

4分析A*算法的特点。

四、实验步骤：1开始演示。

进入N数码难题演示程序，可选8数码或者15数码，点击“选择数码”按钮确定。

第一次启动后，点击两次“缺省”或者“随机”按钮，才会出现图片。

2点击“缺省棋局”，会产生一个固定的初始节点。

点击“随机生成”，会产生任意排列的初始节点。

3算法执行。

点击“连续执行”则程序自动搜索求解，并演示每一步结果；点击“单步运行”则每次执行一步求解流程。

“运行速度”可自由调节。

4观察运行过程和搜索顺序，理解启发式搜索的原理。

在下拉框中选择演示“15数码难题”，点击“选择数码”确定选择；运行15数码难题演示实例。

5算法流程的任一时刻的相关状态,以算法流程高亮、open表、close表、节点静态图、当前扩展节点移动图等5种形式在按钮上方同步显示,便于深入学习理解A*算法。

6根据程序运行过程画出A*算法框图。

其它可参考帮助文件。

五、实验报告要求：1A*算法流程图和算法框图。

2试分析估价函数的值对搜索算法速度的影响。

3根据A*算法分析启发式搜索的特点。

八数码问题分析•在3×3的九宫格棋盘上摆有八个棋子，每个棋子都刻有1-8中的某一个数码。

棋盘中留有一个空格，允许其周围的某一个棋子向空格移动，这样通过移动棋子解可以不断改变棋盘的格局。

人工智能综合实践作业要求

人工智能综合实践大作业要求智能系统建模与仿真综合实践课程是一项综合性的课程设计，要求同学们将所学的知识运用到实际项目中，完成一个完整的综合项目。

具体要求如下：1.选题：选择一个实际应用场景，确定项目的功能需求和技术实现方案。

2.数据采集和数据预处理：对项目所需要的数据进行采集（比如爬虫）、清洗等处理等工作，可以使用之前课程中学习的pandas等相关技术。

3.技术实现：如果是一个可视化项目，需要使用Matplotlib、echarts等相关技术实现。

如果是一个算法模型，根据需求分析设计，选择合适的模型和算法，进行训练和优化。

（可以选择深度学习、机器学习等进行训练）4.模型应用和优化：将训练好的模型应用到实际场景中，对结果进行评估和优化。

（这里推荐使用Flask部署，或者GUI部署）5.项目演示：对项目进行演示，展示项目的功能和特点，并进行现场答辩。

6.项目总结：对项目的完成过程进行总结，包括遇到的问题和解决方案、项目的优缺点等。

在完成大作业时，需要注意以下几点：1.选题要具有实际应用价值，能够解决实际问题。

2.数据采集和预处理要充分考虑数据的质量和可用性，保证模型的训练和应用效果。

3.模型应用和优化要考虑实际场景中的各种因素，保证模型的实际效果。

4.项目演示要生动、形象、详细，能够展示项目的特点和优势。

6.项目总结要客观、全面、深入，能够对项目的完成过程进行全面的反思和总结。

题目范围：爬虫+可视化分析（可视化分析不能少于8个）数据预处理 + 机器学习算法 + 模型应用部署自然语言处理 + 应用部署计算机视觉（图像分类、目标检测、语义识别等等）+ 应用部署其他智能化相关的一些项目（比如推荐系统等等）。

人工智能实验报告(二)2024

人工智能实验报告（二）
引言概述:
本文是关于人工智能实验的报告，主要研究了人工智能技术在
不同领域应用的情况。

通过实验，我们探讨了人工智能在语音识别、图像处理、自然语言处理、机器学习和智能推荐等方面的应用。

通
过这些实验，我们可以深入了解人工智能技术的发展和应用前景。

正文内容:
1. 语音识别
- 分析语音识别技术的基本原理和方法
- 探索语音识别在智能助手、语音控制和语音翻译等领域的应
用
- 研究不同语音识别算法的准确性和鲁棒性
2. 图像处理
- 研究图像处理算法及其在人脸识别、图像识别和图像增强等
方面的应用
- 比较不同图像处理算法的效果和性能
- 探讨图像处理技术在医疗、安防和智能交通等领域的潜力
3. 自然语言处理
- 分析自然语言处理技术的研究方向和应用场景
- 探讨自然语言处理在智能客服、文本分类和情感分析等方面
的应用
- 研究不同自然语言处理模型的性能和可扩展性
4. 机器学习
- 研究机器学习算法的基本原理和发展趋势
- 探索机器学习在数据挖掘、预测分析和推荐系统等领域的应用
- 比较不同机器学习算法的准确性和效率
5. 智能推荐
- 分析智能推荐算法的特点和应用场景
- 探讨智能推荐在电商、社交媒体和音乐平台等领域的应用
- 研究不同智能推荐算法的精度和个性化程度
总结:
通过本次实验，我们对人工智能技术在不同领域的应用有了更深入的了解。

语音识别、图像处理、自然语言处理、机器学习和智能推荐等方面的技术都展现出了巨大的潜力和发展空间。

随着人工智能技术的不断进步，我们可以期待在未来的各个领域看到更多创新和应用。

西电电院人工智能课程大作业。

西电人工智能大作业八数码难题一.实验目的八数码难题：在3×3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空的，其初始状态如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。

例如：(a) 初始状态 (b) 目标状态图1 八数码问题示意图请任选一种盲目搜索算法（深度优先搜索或宽度优先搜索）或任选一种启发式搜索方法（A 算法或 A* 算法）编程求解八数码问题（初始状态任选），并对实验结果进行分析，得出合理的结论。

本实验选择宽度优先搜索：选择一个起点，以接近起始点的程度依次扩展节点，逐层搜索，再对下一层节点搜索之前，必先搜索完本层节点。

二.实验设备及软件环境Microsoft Visual C++，（简称Visual C++、MSVC、VC++或VC）微软公司的C++开发工具，具有集成开发环境，可提供编辑C语言，C++以及C++/CLI 等编程语言。

三.实验方法算法描述：（1）将起始点放到OPEN表；（2）若OPEN空，无解，失败；否则继续；（3）把第一个点从OPEN移出，放到CLOSE表；（4）拓展节点，若无后继结点，转（2）；（5）把n的所有后继结点放到OPEN末端，提供从后继结点回到n的指针；（6）若n任意后继结点是目标节点，成功，输出；否则转（2）。

流程图：代码：#include <stdlib.h>#include <stdio.h>typedef struct Node {int num[9]; //棋盘状态int deepth; //派生的深度 g(n)int diffnum; //不在位的数目 h(n)int value; //耗散值 f(n)=g(n)+h(n)struct Node * pre;struct Node * next;struct Node * parent;}numNode; /* ---------- end of struct numNode ---------- */int origin[9]; //棋盘初始状态int target[9]; //棋盘目标状态int numNode_num,total_step;numNode *open,*close; //Open表和Close表numNode *create_numNode(){return (numNode *)malloc(sizeof(numNode));}numNode *open_getfirst(numNode *head); //返回第一项，并从Open表中删除void open_insert(numNode *head,numNode *item); //向Open表中按序插入新节点void close_append(numNode *head,numNode *item); //向Close表中插入新节点int expand(numNode *item); //扩展节点int print_result(numNode *item); //打印结果numNode *copy_numNode(numNode *orgin);char isNewNode(numNode *open,numNode *close,int num[9]);//是否在Open表或Close表中void print_num(int num[9]); //打印棋盘状态int diff(int num[9]); //求不在位棋子的个数void init(); //初始化，获得棋盘初始状态和目标状态void swap(int *a,int *b);int operate(int num[],int op);void free_list(numNode *head);/** Name: 主函數* Description: 程序入口*/Int main ( int argc, char *argv[] ){//初始化Open表和Close表open=create_numNode();close=create_numNode();open->pre=open->next=close->pre=close->next=NULL; init(); //由用户输入初始和目标状态//初始化初始节点numNode *p1;p1=create_numNode();p1->parent=NULL;p1->deepth=0;int i=0;for ( i=0; i<9; i++){p1->num[i]=origin[i];}open_insert(open,p1);numNode_num=1;p1=open_getfirst(open);while (p1!=NULL){close_append(close,p1);if(expand(p1))return EXIT_SUCCESS;p1=open_getfirst(open);}printf("No solution!\n");return EXIT_SUCCESS;} /* ---------- end of function main ---------- */voidinit ( ){while(1){printf("Please input opriginal status:\nFor example:123456780 stands for\n""1 2 3\n""4 5 6\n""7 8 0\n");char temp[10];scanf("%s",&temp);int i=0;for ( i=0;i<9 && temp[i]-'0'>=0 && temp[i]-'0'<=8; i++){origin[i]=temp[i]-'0';}printf("Please input target status:\n");scanf("%s",&temp);int j=0;for ( j=0; j<9 && temp[j]-'0'>=0 && temp[j]-'0'<=8; j++){target[j]=temp[j]-'0';}system("cls");if ( i==9&&j==9){break;}}} /* ----- end of function init ----- */voidopen_insert (numNode *head,numNode *item){numNode *p,*q;p=head->next;q=head;while ( p!=NULL && item->value > p->value ){q=p;p=p->next;}q->next=item;item->pre=q;item->next=p;if(p!=NULL){p->pre=item;}} /* ----- end of function open_insert ----- */numNode *open_getfirst (numNode *head){numNode *p;if ( head->next == NULL ){return NULL;}p=head->next;head->next=p->next;if ( p->next != NULL ){p->next->pre=head;}p->pre=NULL;p->next=NULL;return p;} /* ----- end of function open_getfirst ----- */voidclose_append (numNode *head,numNode *item){item->next=head->next;item->pre=head;head->next=item;if ( item->next!=NULL ){item->next->pre=item;}} /* ----- end of function close_append ----- */intexpand (numNode *p1){numNode * p2;int op=1;for ( op=1; op<=4; op++){p2=copy_numNode(p1);operate(p2->num,op);if(isNewNode(open,close,p2->num)=='N'){p2->parent=p1;p2->deepth=p1->deepth+1;p2->diffnum=diff(p2->num);p2->value=p2->deepth+p2->diffnum;if(p2->diffnum==0){total_step=print_result(p2);printf("Total step: %d\n",total_step); free_list(open);free_list(close);return 1;}else{numNode_num++;open_insert(open,p2);}}elsefree(p2);}return 0;} /* ----- end of function expand ----- */intoperate(int m[], int op){int blank;blank=0;while (m[blank]!=0 && blank<9 )++blank;if (blank==9)return 1;switch (op) {case 1: /* up */if (blank>2)swap(m+blank,m+blank-3);break;case 2: /* down */if (blank<6)swap(m+blank,m+blank+3);break;case 3: /* left */if (blank!=0 && blank!=3 && blank!=6) swap(m+blank,m+blank-1);break;case 4: /* right */if (blank!=2 && blank!=5 && blank!=8) swap(m+blank,m+blank+1);break;default : return 1;}return 0;}voidswap(int *a, int *b){int c;c=*a;*a=*b;*b=c;}numNode *copy_numNode (numNode *origin){numNode *p;p=create_numNode();p->deepth=origin->deepth;p->diffnum=origin->diffnum;p->value=origin->value;int i;for ( i=0; i<9; i++){(p->num)[i]=(origin->num)[i];}return p;} /* ----- end of function copy_numNode ----- */intdiff (int num[9]){int i,diffnum=0;for(i=0;i<9;i++)if(num[i]!=target[i])diffnum++;return diffnum;} /* ----- end of function diff ----- */charisNewNode (numNode *open,numNode *close,int num[9]) {numNode *p;int i=0;p=open->next;while ( p!=NULL ){for ( i=0; i<9; i++){if(p->num[i]!=num[i])break;}if(i==9)return 'O'; //Openp=p->next;}p=close->next;while ( p!=NULL ){for ( i=0; i<9; i++){if(p->num[i]!=num[i])break;}if(i==9)return 'C'; //Closep=p->next;}return 'N';} /* ----- end of function isNewNode ----- */voidfree_list (numNode *head){numNode *p,*q;p=head->next;while ( p!=NULL ){q=p->next;free(p);p=q;}free(head);} /* ----- end of function free_list ----- */voidprint_num (int num[9]){int i;for ( i=0; i<9; i++){printf("%d\t",num[i]);if((i%3)==2)printf("\n");}} /* ----- end of function print_num ----- */intprint_result ( numNode *item){numNode *p;int step;p=item;if(p!=NULL){step=print_result(p->parent);printf("\nStep %d:\n",step+1);print_num(p->num);return step+1;}else{return -1;}}四.结果：下图实验结果中，一步代表一层的搜索结果中的最优解；八数码难题的宽度优先搜索树：五.实验分析宽度优先搜索属于一种盲目搜索算法，可以系统的展开所有节点，理论上一定能达到搜寻目的。

人工智能实验1实验报告

人工智能实验1实验报告一、实验目的本次人工智能实验 1 的主要目的是通过实际操作和观察，深入了解人工智能的基本概念和工作原理，探索其在解决实际问题中的应用和潜力。

二、实验环境本次实验在以下环境中进行：1、硬件配置：配备高性能处理器、大容量内存和高速存储设备的计算机。

2、软件工具：使用了 Python 编程语言以及相关的人工智能库，如TensorFlow、PyTorch 等。

三、实验内容与步骤（一）数据收集为了进行实验，首先需要收集相关的数据。

本次实验选择了一个公开的数据集，该数据集包含了大量的样本，每个样本都具有特定的特征和对应的标签。

（二）数据预处理收集到的数据往往存在噪声、缺失值等问题，需要进行预处理。

通过数据清洗、标准化、归一化等操作，将数据转化为适合模型学习的格式。

（三）模型选择与构建根据实验的任务和数据特点，选择了合适的人工智能模型。

例如，对于分类问题，选择了决策树、随机森林、神经网络等模型。

（四）模型训练使用预处理后的数据对模型进行训练。

在训练过程中，调整了各种参数，如学习率、迭代次数等，以获得最佳的训练效果。

（五）模型评估使用测试数据集对训练好的模型进行评估。

通过计算准确率、召回率、F1 值等指标，评估模型的性能。

（六）结果分析与改进对模型的评估结果进行分析，找出模型存在的问题和不足之处。

根据分析结果，对模型进行改进，如调整模型结构、增加数据量、采用更先进的训练算法等。

四、实验结果与分析（一）实验结果经过多次实验和优化，最终得到了以下实验结果：1、决策树模型的准确率为 75%。

2、随机森林模型的准确率为 80%。

3、神经网络模型的准确率为 85%。

（二）结果分析1、决策树模型相对简单，对于复杂的数据模式可能无法很好地拟合，导致准确率较低。

2、随机森林模型通过集成多个决策树，提高了模型的泛化能力，因此准确率有所提高。

3、神经网络模型具有强大的学习能力和表示能力，能够自动从数据中学习到复杂的特征和模式，从而获得了最高的准确率。

人工智能大作业实验

湖南中医药大学本科课程实验教学大纲《人工智能》计算机科学与技术专业执笔人：丁长松审定人：***学院负责人：***湖南中医药大学教务处二○一四年三月一、课程性质和教学目的《人工智能》是计算机专业本科生的一门专业必修课，适应于计算机科学与技术专业、医药信息工程专业。

本课程是关于人工智能领域的引导性课程，通过本课程的学习，是使学生了解和掌握人工智能的基本概念、原理和方法，培养学生在计算机领域中应用人工智能技术提高分析和解决较复杂问题的能力，启发学生对人工智能的兴趣，培养知识创新和技术创新能力。

《人工智能》主要研究智能信息处理技术、开发具有智能特性的各类应用系统的核心技术。

本课程主要介绍人工智能的基本理论、方法和技术，主要包括常用的知识表示、逻辑推理和问题求解方法、人工智能发展学派以及主要理论。

先修课程：高等数学、数据结构、数据库原理、算法设计与分析、数理逻辑二、课程目标人工智能实验应在一种为高效率开发专家系统而设计的高级程序系统或高级程序设计语言环境中进行。

在目前开来，专家系统开发工具和环境可分为5种主要类型：程序设计语言、知识工程语言、辅助型工具、支持工具及开发环境。

在这里主要是要求学生能用相关术语描述、表示一些问题；用程序设计语言如：C、C++、JAVA编程来实现一些基本的算法、推理、搜索等过程。

三、实验内容与要求实验一：谓词表示【实验内容】设农夫、狼、山羊、白菜都在河的左岸，现在要把它们运送到河的右岸去，农夫有条船，过河时，除农夫外船上至多能载狼、山羊、白菜中的一种。

狼要吃山羊，山羊要吃白菜，除非农夫在那里。

试设计出一个确保全部都能过河的方案。

【实验目的】让学生加深对谓词逻辑和谓词知识表示的理解。

【实验要求】写出所用谓词的定义，并给出每个谓词的功能及变量的个体域，然后编程来实现。

【参考学时】1.定义状态的谓词2.定义变元的个体域3.描述问题的初始和目标状态4.定义动作5.解释过程解：(1) 先定义描述状态的谓词AL(x)：x在左岸¬AL(x)表示x在右岸。

人工智能大作业

Test for Advanced Artificial Intelligence学号：姓名：2020年4 月23 日目录一、分析比较BFS、DFS、UCS、IDS四种搜索策略的优缺点。

(1)1.四种搜索策略的优缺点。

(1)2.四种策略求解 (4)二、多层神经网络BP算法权重更新规则 (6)1.公式推导（矩阵推导） (7)2.求解 (8)3.Python代码更新权重 (11)4.运行截图 (13)三、卷积运算、池化操作在提取图像特征、图像降维方面的作用 (15)1.卷积层： (15)2.池化层 (17)Test for Advanced Artificial Intelligence一、分析比较BFS、DFS、UCS、IDS四种搜索策略的优缺点。

对下图所示的赋权状态图，请分别用BFS、DFS、UCS、IDS四种搜索算法找出从起始点S到目标点G的一条路径。

要求：对每种算法（1）列出搜索过程的open表close表。

（2）给出从起始点到目标点的解路径。

1.分析比较BFS、DFS、UCS、IDS四种搜索策略的优缺点。

（1）BFS基本原理：广度优先搜索，首先从S结点出发，判断是否为目标结点，若否，寻找与该结点的邻接点，先搜索该节点的所有子节点，如果子节点没被访问则依次添加到队列，直到找不到子节点，然后出队列获取队列首元素，再搜索该首元素的所有子节点并依次添加到队列。

如果找到目标节点则退出循环，否则继续循环。

性能分析：是完备的（只要有解，肯定能搜到。

当然，前提是最浅的目标节点处于一个有限深度d，分支因子b也是有限的）BFS找到的永远是最浅的目标节点，但不一定最优，只有当路径代价是基于节点深度的非递减函数时，BFS是最优的（最常见情况是所有行动要花费相同的代价）。

假设每个状态都有b个后继状态，解的深度为d，那么时间复杂度就是O(b d)，空间复杂度也是O(b d)。

这种指数级的复杂度就太大了。

优点：相对DFS，时间复杂度小；对于解决最短或最少问题特别有效，而且寻找深度小缺点：相对DFS，内存耗费量大；找到的仅是可行解，不一定是最优解（单步代价一致情况下是最优解）；（2）DFS基本原理：深度优先搜索采用堆栈寻找路径，首先从S结点出发，判断是否为目标结点，若否，寻找与该结点的邻接点，先搜索一条分支上的所有节点，然后再去搜索和S的其它分支结点，找出并存进待扩展结点表，等待扩展，每次先判断待扩展结点表是否为空，若否，则从待扩展结点表中取出一个结点进行扩展，并将扩展后的结点存进该表，若是，则返回失败。

人工智能实验报告

一、实验背景与目的随着信息技术的飞速发展，人工智能（Artificial Intelligence，AI）已经成为当前研究的热点领域。

为了深入了解AI的基本原理和应用，我们小组开展了本次实验，旨在通过实践操作，掌握AI的基本技术，提高对AI的理解和应用能力。

二、实验环境与工具1. 实验环境：Windows 10操作系统，Python 3.8.0，Jupyter Notebook。

2. 实验工具：Scikit-learn库、TensorFlow库、Keras库。

三、实验内容与步骤本次实验主要分为以下几个部分：1. 数据预处理：从公开数据集中获取实验数据，对数据进行清洗、去噪、归一化等预处理操作。

2. 机器学习算法：选择合适的机器学习算法，如决策树、支持向量机、神经网络等，对预处理后的数据进行训练和预测。

3. 模型评估：使用交叉验证等方法对模型进行评估，选择性能最佳的模型。

4. 结果分析与优化：分析模型的预测结果，针对存在的问题进行优化。

四、实验过程与结果1. 数据预处理我们从UCI机器学习库中获取了鸢尾花（Iris）数据集，该数据集包含150个样本，每个样本有4个特征，分别为花萼长度、花萼宽度、花瓣长度和花瓣宽度，以及对应的类别标签（Iris-setosa、Iris-versicolor、Iris-virginica）。

对数据进行预处理，包括：- 去除缺失值：删除含有缺失值的样本。

- 归一化：将特征值缩放到[0, 1]区间。

2. 机器学习算法选择以下机器学习算法进行实验：- 决策树（Decision Tree）：使用Scikit-learn库中的DecisionTreeClassifier实现。

- 支持向量机（Support Vector Machine）：使用Scikit-learn库中的SVC实现。

- 神经网络（Neural Network）：使用TensorFlow和Keras库实现。

3. 模型评估使用交叉验证（5折）对模型进行评估，计算模型的准确率、召回率、F1值等指标。

人工智能大作业

《人工智能》实验大作业实验题目：五子棋专业信息与计算科学年级091001姓名郭军伟学号081001106指导老师时华日期 2012-12-5实验题目人工智能之五子棋一、实验目的：1学习并了解机器博弈相关技术；2掌握机器博弈的分析方法。

二、实验内容：1 实现五子棋游戏功能；2 插入棋盘图片作为自己的棋盘；3 显示战况的对话框；三、实验原理：假设电脑用白棋，人用黑棋。

在前两步时由于不会有赢的趋势，所以白子在黑子的周围随机下棋。

第三步以后，电脑要扫描整个棋局，构建博弈树，然后用深度优先算法分析并评估自己是否占优势。

如果自己占优势，则进攻，否则，则防守。

当然在整个下棋过程中，会检查是否已经五子连，即是否有人电脑获胜。

四、实验源程序：(一)import java.awt.Graphics;import java.awt.Point;import java.util.Stack;import javax.swing.ImageIcon;/** To change this template, choose Tools | Templates* and open the template in the editor.*//** guojunwei.java** Created on 2012-12-05, 13:24:08*//**** @author Administrator*/public class guojunwei extends javax.swing.JFrame {/** Creates new form guojunwei */public guojunwei() {initComponents();initBoard();this.setResizable(false);buttonGroup.add(jRadioButton1);buttonGroup.add(jRadioButton2);chessman = new ImageIcon[]{new ImageIcon(getClass().getResource("/resource/黑.PNG")), new ImageIcon(getClass().getResource("/resource/白.PNG"))};}/** This method is called from within the constructor to* initialize the form.* WARNING: Do NOT modify this code. The content of this method is* always regenerated by the Form Editor.*/@SuppressWarnings("unchecked")// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponentsprivate void initComponents() {buttonGroup = new javax.swing.ButtonGroup();jLabel1 = new javax.swing.JLabel();jPanel1 = new javax.swing.JPanel();jRadioButton1 = new javax.swing.JRadioButton();jRadioButton2 = new javax.swing.JRadioButton();jButton1 = new javax.swing.JButton();jButton2 = new javax.swing.JButton();jTextField1 = new javax.swing.JTextField();jButton3 = new javax.swing.JButton();setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);jLabel1.setIcon(new javax.swing.ImageIcon(getClass().getResource("/resource/棋盘.PNG"))); // NOI18NjLabel1.addMouseListener(new java.awt.event.MouseAdapter() {public void mouseClicked(java.awt.event.MouseEvent evt) {jLabel1MouseClicked(evt);}});jRadioButton1.setText("玩家执黑先下");jRadioButton2.setText("电脑执黑先下");jButton1.setText("开始游戏");jButton1.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton1ActionPerformed(evt);}});jButton2.setText("再来一局");jButton2.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton2ActionPerformed(evt);}});jTextField1.setFont(new java.awt.Font("宋体", 0, 18));jTextField1.setText("游戏未开始");jButton3.setText("悔棋");jButton3.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEvent evt) {jButton3ActionPerformed(evt);}});javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);jPanel1.setLayout(jPanel1Layout);jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(jPanel1Layout.createSequentialGroup().addContainerGap().addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADIN G).addComponent(jTextField1, javax.swing.GroupLayout.DEF AULT_SIZE, 145, Short.MAX_V ALUE).addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false).addComponent(jRadioButton2).addComponent(jRadioButton1).addComponent(jButton1, javax.swing.GroupLayout.DEF AULT_SIZE, 89, Short.MAX_V ALUE).addComponent(jButton2, javax.swing.GroupLayout.DEF AULT_SIZE, javax.swing.GroupLayout.DEFAUL T_SIZE, Short.MAX_V ALUE)).addComponent(jButton3, javax.swing.GroupLayout.PREFERRED_SIZE, 92, javax.swing.GroupLayout.PREFERRED_SIZE)).addContainerGap()));jPanel1Layout.setV erticalGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(jPanel1Layout.createSequentialGroup().addGap(18, 18, 18).addComponent(jRadioButton1).addPreferredGap(ponentPlacement.RELATED).addComponent(jRadioButton2).addGap(18, 18, 18).addComponent(jButton1).addGap(18, 18, 18).addComponent(jButton2).addGap(69, 69, 69).addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 72, javax.swing.GroupLayout.PREFERRED_SIZE).addGap(35, 35, 35).addComponent(jButton3).addContainerGap(228, Short.MAX_V ALUE)));javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());getContentPane().setLayout(layout);layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(layout.createSequentialGroup().addComponent(jLabel1).addPreferredGap(ponentPlacement.RELATED).addComponent(jPanel1, javax.swing.GroupLayout.DEFAUL T_SIZE,javax.swing.GroupLayout.DEFAUL T_SIZE, Short.MAX_V ALUE)));layout.setV erticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup() .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING).addComponent(jPanel1, javax.swing.GroupLayout.Alignment.LEADING,javax.swing.GroupLayout.DEFAUL T_SIZE, javax.swing.GroupLayout.DEFAUL T_SIZE, Short.MAX_V ALUE) .addComponent(jLabel1, javax.swing.GroupLayout.DEFAUL T_SIZE,javax.swing.GroupLayout.DEFAUL T_SIZE, Short.MAX_V ALUE)).addContainerGap()));pack();}// </editor-fold>//GEN-END:initComponentsintelligence intel = new intelligence();Stack<Point> back = new Stack<Point>();private void jLabel1MouseClicked(java.awt.event.MouseEvent evt){//GEN-FIRST:event_jLabel1MouseClickedif (gameStarted == false) {return;}//玩家下子int r = (evt.getX() - 30) / 36;int c = (evt.getY() - 30) / 36;System.out.println(r + "," + c);back.add(new Point(r, c));flag = false;if (board[r][c] == 0) {if (first == 1) {turn += 1;} else if (first == 2) {turn -= 1;}chessman[turn].paintIcon(jLabel1, jLabel1.getGraphics(), r * 36 + 20, c * 36 + 30);board[r][c] = 2;count++;} else {return;}//判断胜负if (judgeWin(new Point(r, c))) {gameStarted = false;return;}//计算机智能下子Point p = pPlay();back.add(p);flag = true;if (first == 1) {turn -= 1;} else if (first == 2) {turn += 1;}chessman[turn].paintIcon(jLabel1, jLabel1.getGraphics(), p.x * 36 + 20, p.y * 36 + 30);//判断胜负if (judgeWin(p)) {gameStarted = false;return;}}//GEN-LAST:event_jLabel1MouseClickedprivate void initBoard() {for (int r = 0; r < BOARD_SIZE; r++) {for (int c = 0; c < BOARD_SIZE; c++) {board[r][c] = 0;}}}//重新开始按钮private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){//GEN-FIRST:event_jButton2ActionPerformedinitBoard();repaint();gameStarted = false;jButton1.setEnabled(true);intel.initTable();turn = 1;first = 0;}//GEN-LAST:event_jButton2ActionPerformed//开始按钮private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){//GEN-FIRST:event_jButton1ActionPerformedcount = 0;this.initBoard();if (jRadioButton1.isSelected() == true) {first = 2;gameStarted = true;jTextField1.setText("游戏已开始！");jButton1.setEnabled(false);} else if (jRadioButton2.isSelected() == true) {first = 1;gameStarted = true;jTextField1.setText("游戏已开始！");jButton1.setEnabled(false);Point p = intel.onFirst();back.add(p);turn -= 1;chessman[turn].paintIcon(jLabel1, jLabel1.getGraphics(), p.x * 36 + 20, p.y * 36 + 30);} else {return;}}//GEN-LAST:event_jButton1ActionPerformed//悔棋private void jButton3ActionPerformed(java.awt.event.ActionEvent evt){//GEN-FIRST:event_jButton3ActionPerformedif (flag == true&&!back.empty()) {Point p = back.pop();Point p2 = back.pop();board[p.x][p.y] = 0;board[p2.x][p2.y] = 0;gameStarted = true;jTextField1.setText("游戏已开始！");repaint();}}//GEN-LAST:event_jButton3ActionPerformed/*** @param args the command line arguments*/public static void main(String args[]) {java.awt.EventQueue.invokeLater(new Runnable() {public void run() {new gobangDlg().set V isible(true);}});}@Overridepublic void paint(Graphics g) {super.paint(g);paintChessman();}@Overridepublic void update(Graphics g) {repaint();}public void paintChessman() {if (gameStarted == true) {for (int r = 0; r < BOARD_SIZE; r++) {for (int c = 0; c < BOARD_SIZE; c++) {if (first == 2) {if (board[r][c] == 2) {chessman[0].paintIcon(jLabel1, jLabel1.getGraphics(), r * 36 + 20, c * 36 + 30);} else if (board[r][c] == 1) {chessman[1].paintIcon(jLabel1, jLabel1.getGraphics(), r * 36 + 20, c * 36 + 30);}} else if (first == 1) {if (board[r][c] == 2) {chessman[1].paintIcon(jLabel1, jLabel1.getGraphics(), r * 36 + 20, c * 36 + 30);} else if (board[r][c] == 1) {chessman[0].paintIcon(jLabel1, jLabel1.getGraphics(), r * 36 + 20, c * 36 + 30);}}}}}}boolean flag = false; //判断是否可以悔棋int first = 0;int turn = 1;int count = 0;boolean gameStarted = false;ImageIcon[] chessman;static int BOARD_SIZE = 15;static int[][] board = new int[BOARD_SIZE][BOARD_SIZE];// V ariables declaration - do not modify//GEN-BEGIN:variablesprivate javax.swing.ButtonGroup buttonGroup;private javax.swing.JButton jButton1;private javax.swing.JButton jButton2;private javax.swing.JButton jButton3;private javax.swing.JLabel jLabel1;private javax.swing.JPanel jPanel1;private javax.swing.JRadioButton jRadioButton1;private javax.swing.JRadioButton jRadioButton2;private javax.swing.JTextField jTextField1;// End of variables declaration//GEN-END:variables//胜负判断private boolean judgeWin(Point p) {//判断是否平局boolean dogfall = true;for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {if (board[r][c] == 0) {dogfall = false;}}}if (dogfall == true) {jTextField1.setText("平局！共" + count + "轮");}//flag表示是否可以断定赢/输boolean flag = false;//joinEle：将每一个横/竖/左斜/右斜行中的元素连接起来得到的一个字符串String joinEle = "";int x = p.x;int y = p.y;//进行横行扫描for (int i = 0; i < BOARD_SIZE; i++) {joinEle += board[i][y];}if (joinEle.contains("222222")) {jTextField1.setText("长连禁手！你输了共" + count + "轮");} else if (joinEle.contains("22222")) {jTextField1.setText("您赢啦！共" + count + "轮");flag = true;return flag;} else if (joinEle.contains("11111")) {jTextField1.setText("您输啦！共" + count + "轮");flag = true;return flag;}//进行竖行扫描joinEle = "";for (int j = 0; j < BOARD_SIZE; j++) {joinEle += board[x][j];}if (joinEle.contains("222222")) {jTextField1.setText("长连禁手！你输了共" + count + "轮"); }if (joinEle.contains("22222")) {jTextField1.setText("您赢啦！共" + count + "轮");flag = true;return flag;} else if (joinEle.contains("11111")) {jTextField1.setText("您输啦！共" + count + "轮");flag = true;return flag;}//进行左斜行扫描joinEle = "";if ((x + y) <= 14) {int j = x + y;for (int i = 0; j >= 0 && i < BOARD_SIZE; i++, j--) {joinEle += board[i][j];}} else {int i = x + y - 14;for (int j = 14; j >= 0 && i < BOARD_SIZE; i++, j--) { joinEle += board[i][j];}}if (joinEle.contains("222222")) {jTextField1.setText("长连禁手！你输了共" + count + "轮"); }if (joinEle.contains("22222")) {jTextField1.setText("您赢啦！共" + count + "轮");flag = true;return flag;} else if (joinEle.contains("11111")) {jTextField1.setText("您输啦！共" + count + "轮");flag = true;return flag;}//进行右斜行扫描joinEle = "";if (y >= x) {int j = y - x;for (int i = 0; j < BOARD_SIZE && i < BOARD_SIZE; i++, j++) { joinEle += board[i][j];}} else {int i = x - y;for (int j = 0; i < BOARD_SIZE && j < BOARD_SIZE; i++, j++) { joinEle += board[i][j];}}if (joinEle.contains("222222")) {jTextField1.setText("长连禁手！你输了共" + count + "轮");}if (joinEle.contains("22222")) {jTextField1.setText("您赢啦！共" + count + "轮");flag = true;return flag;} else if (joinEle.contains("11111")) {jTextField1.setText("您输啦！共" + count + "轮");flag = true;//最后这个return可省略}//确保该方法有返回值（如果上面条件都不满足时）return flag;}}（二）import java.awt.Point;import java.util.Enumeration;import java.util.Hashtable;import java.util.Stack;/** To change this template, choose Tools | Templates* and open the template in the editor.*//**** @author Administrator*/public class intelligence {intelligence() {setMyTypeTable();setEnemyTypeTable();}void initTable() {for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {computer[r][c] = 0;player[r][c] = 0;}}}//搜索算法//构造棋型表，每种棋型对应的分数//int[左边空白格][左边己方子数][右边己方子数][右边空白格] MyTable int[][][][] MyTable = new int[2][5][5][2];//己方棋型表int[][][][] EnemyTable = new int[2][5][5][2];//己方棋型表//先手F，后手L，冲C，活H，死S//S1=S2=S3=S4=4//FC1=LC1<FH1=LH1<FC2=FH2<FC2<FH2<FH2<FC3<FC4<FH3<FH4 //己方放子后，即后手void setMyTypeTable() {for (int m = 0; m < 2; m++) {for (int i = 0; i < 5; i++) {for (int j = 0; j < 5; j++) {for (int n = 0; n < 2; n++) {//死子，两边都无空格且无己方子if (m + n == 0 && i + j == 0) {MyTable[m][i][j][n] = 4;} else if (i + j >= 5) {//禁手MyTable[m][i][j][n] = -1250000;}//成五else if (i + j == 4) {MyTable[m][i][j][n] = 1250000;} //成四else if (i + j == 3) {if (m == 1 && n == 1) {//成活四MyTable[m][i][j][n] = 300000;} else if (m + n == 0) {//成死四MyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {MyTable[m][i][j][n] = 10000;//成冲四}} //成三else if (i + j == 2) {if (m == 1 && n == 1) {//成活三MyTable[m][i][j][n] = 50000;} else if (m + n == 0) {//成死三MyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {MyTable[m][i][j][n] = 10000;//成冲三}} //成二else if (i + j == 1) {if (m == 1 && n == 1) {//成活二MyTable[m][i][j][n] = 2500;} else if (m + n == 0) {//成死二MyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {MyTable[m][i][j][n] = 500;//成冲二}} //成一else if (i + j == 0) {if (m == 1 && n == 1) {//成活一MyTable[m][i][j][n] = 100;} else if (m + n == 0) {//成死一MyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {MyTable[m][i][j][n] = 20;//成冲一}}}}}}}//敌方放子后，即先手void setEnemyTypeTable() {for (int m = 0; m < 2; m++) {for (int i = 0; i < 5; i++) {for (int j = 0; j < 5; j++) {for (int n = 0; n < 2; n++) {//死子，两边都无空格且无己方子if (m + n == 0 && i + j == 0) {EnemyTable[m][i][j][n] = 4;} else if (i + j >= 5) {//禁手MyTable[m][i][j][n] = -5000000;}//成五else if (i + j == 4) {EnemyTable[m][i][j][n] = 1230000;} //成四else if (i + j == 3) {if (m == 1 && n == 1) {//成活四EnemyTable[m][i][j][n] = 250000;} else if (m + n == 0) {//成死四EnemyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {EnemyTable[m][i][j][n] = 40000;//成冲四}} //成三else if (i + j == 2) {if (m == 1 && n == 1 && i == 1 && j == 1) {EnemyTable[m][i][j][n] = 66000;} else if (m == 1 && n == 1) {//成活三EnemyTable[m][i][j][n] = 55000;} else if (m + n == 0) {//成死三EnemyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {EnemyTable[m][i][j][n] = 10000;//成冲三}} //成二else if (i + j == 1) {if (m == 1 && n == 1) {//成活二EnemyTable[m][i][j][n] = 2500;} else if (m + n == 0) {//成死二EnemyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {EnemyTable[m][i][j][n] = 500;//成冲二}} //成一else if (i + j == 0) {if (m == 1 && n == 1) {//成活一EnemyTable[m][i][j][n] = 100;} else if (m + n == 0) {//成死一EnemyTable[m][i][j][n] = 4;} else if (m == 0 || n == 0) {EnemyTable[m][i][j][n] = 20;///成冲一}}}}}}}int[][] board = gobangDlg.board;//1为电脑，2为玩家//棋盘分析表（分值表）int computer[][] = new int[15][15];//白子int player[][] = new int[15][15];//黑子//构造电脑和玩家的棋盘分析表void analyseComputer(int[][] computer, int[][] board) {for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {int left = 0;int right = 0;int lblank = 0;int rblank = 0;if (board[r][c] == 0) {//如果有空位，八个方向查找，每个方向查找4步computer[r][c] = 0;//下for (int i = c + 1; i <= c + 4 && i < 15; i++) {if (board[r][i] == 0) {lblank++;break;} else if (this.board[r][i] == 1) {left++;} else if (this.board[r][i] == 2) {break;}}//上for (int j = c - 1; j >= c - 4 && j >= 0; j--) {if (board[r][j] == 0) {rblank++;break;} else if (this.board[r][j] == 1) {right++;} else if (this.board[r][j] == 2) {break;}}//System.out.println(r+","+c+"shangxia："+left + "," + right + ","+ lblank +","+rblank);computer[r][c] += this.MyTable[lblank][left][right][rblank];rblank = 0;lblank = 0;left = 0;right = 0;//左for (int j = r - 1; j >= r - 4 && j >= 0; j--) {if (board[j][c] == 0) {lblank++;break;} else if (this.board[j][c] == 1) {left++;} else if (this.board[j][c] == 2) {break;}}//右for (int i = r + 1; i <= r + 4 && i < 15; i++) {if (board[i][c] == 0) {rblank++;break;} else if (this.board[i][c] == 1) {right++;} else if (this.board[i][c] == 2) {break;}}computer[r][c] += this.MyTable[lblank][left][right][rblank];//System.out.println(r + "," + c + "左右方向：" + left + "," + right + ":" + computer[r][c]);rblank = 0;lblank = 0;left = 0;right = 0;//左上int i = r - 1;int j = c - 1;for (; i >= r - 4 && i >= 0 && j >= c - 4 && j >= 0; i--, j--) { if (board[i][j] == 0) {lblank++;break;} else if (this.board[i][j] == 1) {left++;} else if (this.board[i][j] == 2) {break;}}//右下i = r + 1;j = c + 1;for (; i <= r + 4 && i < 15 && j <= c + 4 && j < 15; i++, j++) { if (board[i][j] == 0) {rblank++;break;} else if (this.board[i][j] == 1) {right++;} else if (this.board[i][j] == 2) {break;}}computer[r][c] += this.MyTable[lblank][left][right][rblank];rblank = 0;lblank = 0;left = 0;right = 0;//右上i = r + 1;j = c - 1;for (; i <= r + 4 && i < 15 && j >= c - 4 && j >= 0; i++, j--) { if (board[i][j] == 0) {rblank++;break;} else if (this.board[i][j] == 1) {right++;} else if (this.board[i][j] == 2) {break;}}//左下i = r - 1;j = c + 1;for (; i >= r - 4 && i > 0 && j <= c + 4 && j < 15; i--, j++) {if (board[i][j] == 0) {lblank++;break;} else if (this.board[i][j] == 1) {left++;} else if (this.board[i][j] == 2) {break;}}computer[r][c] += this.MyTable[lblank][left][right][rblank];} else if (board[r][c] != 0) {computer[r][c] = 0;}}}}void analysePlayer(int[][] player, int[][] board) {for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {int left = 0;int right = 0;int lblank = 0;int rblank = 0;if (board[r][c] == 0) {//如果有空位，八个方向查找，每个方向查找4步player[r][c] = 0;//下for (int i = c + 1; i <= c + 4 && i < 15; i++) {if (board[r][i] == 0) {lblank++;break;} else if (this.board[r][i] == 2) {left++;} else if (this.board[r][i] == 1) {break;}}//上for (int j = c - 1; j >= c - 4 && j >= 0; j--) {if (board[r][j] == 0) {rblank++;break;} else if (this.board[r][j] == 2) {right++;} else if (this.board[r][j] == 1) {break;}}player[r][c] += EnemyTable[lblank][left][right][rblank];//System.out.println(r+","+c+"shangxia方向："+lblank+"c"+rblank+","+left + "," + right + ":"+player[r][c]);rblank = 0;lblank = 0;left = 0;right = 0;//左for (int j = r - 1; j >= r - 4 && j >= 0; j--) {if (board[j][c] == 0) {lblank++;break;} else if (this.board[j][c] == 2) {left++;} else if (this.board[j][c] == 1) {break;}}//右for (int i = r + 1; i <= r + 4 && i < 15; i++) {if (board[i][c] == 0) {rblank++;break;} else if (this.board[i][c] == 2) {right++;} else if (this.board[i][c] == 1) {break;}}player[r][c] += EnemyTable[lblank][left][right][rblank];//System.out.println(r+","+c+"左右方向："+lblank+"c"+rblank+","+left + "," + right + ":"+player[r][c]);rblank = 0;lblank = 0;left = 0;right = 0;//左上int i = r - 1;int j = c - 1;for (; i >= r - 4 && i >= 0 && j >= c - 4 && j >= 0; i--, j--) {if (board[i][j] == 0) {lblank++;break;} else if (this.board[i][j] == 2) {left++;} else if (this.board[i][j] == 1) {break;}}//右下i = r + 1;j = c + 1;for (; i <= r + 4 && i < 15 && j <= c + 4 && j < 15; i++, j++) {if (board[i][j] == 0) {rblank++;break;} else if (this.board[i][j] == 2) {right++;} else if (this.board[i][j] == 1) {break;}}player[r][c] += EnemyTable[lblank][left][right][rblank];//System.out.println(r + "," + c + " ：" + lblank + "c" + rblank + "," + left + "," + right + ":" + player[r][c]);rblank = 0;lblank = 0;left = 0;right = 0;//右上i = r + 1;j = c - 1;for (; i <= r + 4 && i < 15 && j >= c - 4 && j >= 0; i++, j--) {if (board[i][j] == 0) {rblank++;break;} else if (this.board[i][j] == 2) {} else if (this.board[i][j] == 1) {break;}}//左下i = r - 1;j = c + 1;for (; i >= r - 4 && i >= 0 && j <= c + 4 && j < 15; i--, j++) {if (board[i][j] == 0) {lblank++;break;} else if (this.board[i][j] == 2) {left++;} else if (this.board[i][j] == 1) {break;}}player[r][c] += EnemyTable[lblank][left][right][rblank];//System.out.println(r+","+c+"左xia右shang方向："+lblank+"c"+rblank+","+left + "," + right + ":"+player[r][c]);} else if (board[r][c] != 0) {player[r][c] = 0;}}}}Stack<Point> getMax(int[][] computer, int[][] player) {int cmax = 0;int cx = 0;int cy = 0;int pmax = 0;int px = 0;int py = 0;Stack<Point> ps = new Stack<Point>();for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {if (computer[r][c] > cmax) {cmax = computer[r][c];cx = r;cy = c;}if (player[r][c] > pmax) {px = r;py = c;}}}//System.out.println(cx + "," + cy + ":" + computer[cx][cy] + "; " + px + "," + py + ":" + player[px][py]);if (cmax >= pmax) {for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {if (computer[r][c] == cmax) {ps.push(new Point(r, c));}}}return ps;} else {for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {if (player[r][c] == pmax) {ps.push(new Point(r, c));}}}return ps;}}Point onFirst() {board[7][7] = 1;return new Point(7, 7);}int turn = 1;Point compPlay() {analyseComputer(computer, board);analysePlayer(player, board);int[][] tboard = new int[15][15];for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {tboard[r][c] = board[r][c];}}Stack<Point> ps = getMax(computer, player);//测试每个分值最大的点int step = 0;Point p1 = null;while (!ps.empty()) {p1 = ps.pop();compThink(p1, p1, tboard, 2 * step + 1);}//获取经过n步预测后分值最大的点Enumeration em = ht.keys();int key = 0;int max = 0;Point p = null;while (em.hasMoreElements()) {key = (Integer) em.nextElement();Point value = (Point) ht.get(key);System.out.println(key + "" + value);if (key >= max) {max = key;p = value;}}ht.clear();board[p.x][p.y] = 1;System.out.println(p.x + "," + p.y);return p;}Hashtable<Integer, Point> ht = new Hashtable();void compThink(Point p, Point tmp, int[][] board, int step) { int[][] tboard = new int[15][15];for (int r = 0; r < 15; r++) {for (int c = 0; c < 15; c++) {tboard[r][c] = board[r][c];}}//在分值最高点下子tboard[tmp.x][tmp.y] = turn;//换位思考analyseComputer(computer, tboard);analysePlayer(player, tboard);Stack<Point> ps = getMax(computer, player);//当预测到最后一步,将此时最大分值和最顶父节点关联if (step == 0) {while (!ps.empty()) {tmp = ps.pop();if (computer[tmp.x][tmp.y] >= player[tmp.x][tmp.y]) {ht.put(computer[tmp.x][tmp.y], p);} else {ht.put(player[tmp.x][tmp.y], p);}}return;}//在各个同分点下子while (!ps.empty()) {compThink(p, ps.pop(), tboard, step - 1);}}}五、实验结果及分析：实验结果截图如下：如要要重开一局，则要点击“再来一局”即开始游戏。