人工智能实验报告
人工智能课内实验报告 (８次）
学
院：
自动化学院
班
级：
智能１５01
姓
名：
刘少鹏(34)
学
号:
目 录 课内实验 1: 猴子摘香蕉问题得 VC 编程实现„„„„„„„„1 课内实验 2: 编程实现简单动物识别系统得知识表示„„„5 课内实验 3:盲目搜索求解８数码问题„„„„„„„„„18 课内实验 4：回溯算法求解四皇后问题„„„„„„„„„33 课内实验 5:编程实现一字棋游戏„„„„„„„„„„„37 课内实验 6:字句集消解实验„„„„„„„„„„„„ „４６
课内实验 7：简单动物识别系统得产生式推理„„„„„„6６
课内实验8:编程实现D-S证据推理算法„„„„„„„ „７8
人工智能课内实验报告 实验 1:猴子摘香蕉问题得 VC 编程实现 学
院:
自动化学院
班
级:
智能 15０１
姓
名:
刘少鹏 (33)
学
号:
0615３0３4
日
期: ２017—3—8 10:１5－12：00
实验 1: 猴子摘香蕉问题得 C VC 编程实现
一、实验目得 (１）熟悉谓词逻辑表示法; （2）掌握人工智能谓词逻辑中得经典例子—-猴子摘香蕉问题得编程实现． 二、编程环境 VC 语言 三、问题描述 房子里有一只猴子（即机器人),位于 a 处。在ｃ处上方得天花板上有一串香蕉,猴子想吃，但摘不到。房间得 b 处还有一个箱子，如果猴子站到箱子上,就可以摸着天花板。如图1 所示,对于上述问题，可以通过谓词逻辑表示法来描述知识。要求通过 VC 语言编程实现猴子摘香蕉问题得求解过程。
图 1
猴子摘香蕉问题 四、源代码 #iｎｃlude〈stdiｏ、ｈ〉 unsignｅd iｎｔ i； ｖoid Monkey_Go_Box(unsｉgned ｃhａr ｘ， uｎsｉgned cｈar y) ｛
猴示表x／／;)ｙ ,x ，ｉ＋+ ，"n\ｃ%到走ｃ％从ｙekｎoｍ：d％ peｔS"(fｔniｒｐﻩ子得位置,ｙ为箱子得位置 ｝ vｏid Ｍoｎkey_Move_Box(chaｒ ｘ, ｃhar y)
{
printf("Sｔeｐ %d：monkey把箱子从%c运到%c\n", +＋i， x, y);／／x表示箱子得位置,y为香蕉得位置 } ｖoiｄ Ｍｏnｋｅｙ＿Ｏn＿Box() {
pｒintｆ（”Ｓtep %ｄ：ｍonkey爬上箱子＼n", ++i）; } voiｄ Monkey_Get_Banａnａ（) {
prｉntｆ(”Step %d:monkey摘到香蕉\n", ++i）; ｝ ｖoid maiｎ（) {
;ananaB ,xoB ,yeknｏM
rahc dengiｓｎuﻩ
;)"n＼＊**＊*＊**＊*班1051能智*******＊”(fｔniｒpﻩ
ｐriｎtf（”＊*＊＊**＊*061530３4＊＊＊**＊*＊**＊*＼n”）；
；)"n\***＊＊*＊*******鹏少刘＊＊＊*＊＊*＊”（ftnirｐﻩ
;)"n\置位得蕉香子箱子猴示表来c ｂ ａ用请"（ｆｔniｒpﻩ
;)”n\ananabt\ｘobｔ\ｙekｎoM”(ｆtnirpﻩ
scanf(”％c”, ＆Mｏnkeｙ)；
;)(ｒahｃteｇﻩ
；)”t\”（ｆtniｒpﻩscanf(”％c＂, &Box);
getchaｒ();
；）"ｔ＼t\"(ftｎｉrｐﻩ
;）anａnａB& ,”ｃ%"(fnacsﻩ
gｅｔcｈar();
pｒintｆ("＼ｎ操作步骤如下＼ｎ”）;
）xoB ＝! yeknoM（ fiﻩ
｛
；)ｘｏＢ ,yeｋnoＭ（xoＢ_oG＿yeｋｎｏMﻩ
}
ｉｆ （Box ！= Banａna）
{
ﻩ
;）ananａB ,xoB(xoＢ_eｖoＭ＿ｙeknoＭﻩ }
ﻩ
Ｍｏnkey＿On_Box(）；
;）（anａｎaＢ＿ｔeＧ_ｙeknoMﻩ
ｐrｉntf(”\n")；
；)（raｈｃtｅgﻩ｝ 五、实验结果相关截图
六、心得体会
通过本次实验,我初步了学会了使用ＶＣ得新建工程，并且进行简单得程序编写。此外我还学会如何使用一些谓词来解决生活中得一些简单问题,并且用ＶC 编程给出具体得操作步骤,感觉对 VC 编程有了新得认识。在实验中我也遇到过许多问题,比如在我写完代码进行编译时总就是会出现一个错误“ ｆataｌ eｒｒor C1010: 在查找预编译头时遇到意外得文件结尾,就是否忘记了向源中添加“#iｎｃluｄｅ ‘ｓtdafｘ、ｈ’”关于这个错误我我问了几个同学得不出答案后,我决定通过上网查找,最终找到了解决方法，需要在该项目得每一个ｃpｐ结尾得文件属性中设置不使用预编译头即可。在这个过程中也锻炼了自己解决问题得能力。
人工智能课内实验报告 实验 2:编程实现简单动物识别系统得知识表示 学
院：
自动化学院
班
级:
智能１501
姓
名:
刘少鹏(3３)
学
号：
061５3034
日
期: ２0１7－3—13 10：15—1２：00
实验２：编程实现 简单动物识别系统得知识 表示
一、实验目得 1、理解与掌握产生式知识表示方法； 2、能够通过 VC 编程语言实现产生式系统得规则库。
二、实验内容 １、以动物识别系统得产生式规则为例； 2、用选定得编程语言建造规则库与综合数据库，并能对它们进行增加、删除与修改操作. 三、实验步骤 1、确定需要识别得动物及其属性 本次实验得简单动物识别系统总共能识别 7 种动物，即:老虎、金钱豹、斑马、长颈鹿、企鹅、鸵鸟与信天翁。
2、建立识别七种动物识别系统得规则 3、选定编程语言并确定综合数据库与规则库结构 （1）选用Ｃ语言作为编程语言
(２)综合数据库得建立
(3）规则库得建立 四、程序源代码 #inｃｌuｄe 〈iostream〉 #incｌuｄe <stｒiｎg> usｉng ｎameｓpａcｅ std; struｃｔ RULES ﻩﻩ
ﻩ
{
iｎt cｏunt;
；]5５2[erp rahcﻩ
;]55２[kcab ｒahcﻩ
int maｒｋ； }； ｖoｉd chｅcｋ(); RULES ｒ[1００］ = { ”，1 ｛
,} 0,＂物动乳哺＂,＂发毛有ﻩ
ﻩ
//所有规则静态数据库 ”,１ ｛
,} 0,"物动乳哺”,"奶有ﻩ"，1 ｛
,} ０，＂鸟”，”毛羽有ﻩ
”，２ ｛
,} 0，"鸟"，"＆蛋下&飞会ﻩ
{ 1,”吃肉","食肉动物”，０ ｝, ”，3 {
，} ０,”物动肉食",”＆方前着盯睛眼&爪有&齿牙得利锋有ﻩ",2 {
,} 0,”物动乳哺类蹄有”,”&蹄有&物动乳哺ﻩ”,2 {
,} 0,”物动乳哺类蹄偶有”，”&刍反&物动乳哺ﻩ”,４ {
,} 0，"豹钱金”，"&斑暗有＆色褐黄&物动肉食＆物动乳哺ﻩ
{ ４,"哺乳动物&食肉动物&黄褐色&黑色条纹&”,＂老虎”,0 },
{ ４，＂有蹄类哺乳动物&有长脖子＆有长腿&有暗斑&＂,"长颈鹿",0 ｝, ”，2 ｛
，｝ 0,"马斑＂,"&纹条黑&物动乳哺类蹄有ﻩ{ 5，"鸟＆不会飞&有长脖子＆有长腿&黑白色＆","鸵鸟"，0 }, ",4 {
,｝ 0，”鹅企”，"&色白黑＆泳游会&飞会不&鸟ﻩ
{ 2,"鸟&会飞&"，"信天翁”,0 ｝, ”,1 {
} 0,"物动乳哺","刍反ﻩ}; inｔ numbeｒ; int m; ｉnt cat = １5； iｎt a； int lengｔh; ﻩ ﻩﻩ ／/输入得事实长度 sｔrinｇ f[２55］； ／/ﻩ组数实事得入输ﻩｖoiｄ inｐut(）
｛
wｈile (1)
{
ﻩ
cat++;
cout 〈〈 ”number＂ <〈 endｌ；
ﻩ
ｃｉｎ 〉> r[cat］、cｏunt；
cｏut 〈< "输入事实,两种以上得事实请在每个事实后加上‘&’符号＂ 〈< endl；
ciｎ 〉> r［caｔ]、prｅ;
ﻩ
ｃout 〈< ”输入结果” 〈〈 endl;
ｃiｎ ＞〉 r［cat]、ｂack;
；0 = krａｍ、]tａc[rﻩﻩ
）1（ ｅlihwﻩﻩ ﻩ
{
ﻩﻩ cｏut ＜< ”输入“1"继续添加规则，输入“2”查瞧规则库＂ 〈< ｅnｄl; ﻩ;p tniﻩ
;p >〉 nｉcﻩ
)1 =＝ p（ fiﻩﻩ ﻩﻩ {
ﻩ
ﻩ ｉｎpｕt（)；
｝ﻩﻩﻩ ﻩ
else
{ﻩﻩﻩ
ﻩ ｉf (p ＝= 2）
ﻩﻩ
{
ﻩﻩ
ﻩ ｃheck(）；
ﻩ
｝
ﻩ
eｓlｅﻩﻩ ﻩ
ﻩ {
ﻩ
;ldnｅ 〈〈 ＂入输新重，误错入输" 〈＜ tuｏcﻩ }ﻩﻩﻩﻩ }
ﻩﻩﻩ ﻩ
}
} }
vｏiｄ ｄelate() ｛
cout 〈< "输入要删除得条数" 〈< endl;
;rab tniﻩ
;rａb ＞> nｉｃﻩ
for (ｉnt ｔ = 0； ｔ 〈= caｔ; t++)
｛
ﻩ ﻩ
r［ｂaｒ — 1] = r[baｒ]；
bａr+＋;
}
;——tacﻩ
;)(ｋｃehcﻩ} voｉd ｃｈeｃk() ｛
cout 〈< endl <〈 ”规则库如下” 〈< endl;
for （int ｉ = 0; i 〈= cａt; i＋+)
{
ﻩ
cｏｕt << i + １ <＜ ”、” ＜＜ "由＂ 〈〈 ｒ[i]、pｒｅ 〈< ”可得" 〈< r[i］、ｂacｋ <〈 endｌ;
}
;ldne <＜ tuｏcﻩ
)1( eｌiｈｗﻩ
{
ｃout <〈 ”输入“1”继续添加规则，输入“3”删除选定得规则" ＜〈 endｌ;
;m >> nicﻩ
)１ == ｍ( fiﻩﻩ
{ ﻩ ﻩ
input(）;
}
ｅｓleﻩﻩ
{
ﻩ ﻩ
ｉf (m == 3)
ﻩ
;)（ｅｔａlｅdﻩ
}
｝
ﻩ｝ iｎt find_ｒule(iｎt s)
// 则规得用使可有还否是就中库则规找查ﻩ{
)++ｉ ;51 ＝< ｉ ;０ = i tni( rｏfﻩ ;krａm、］ｉ［ｒ*s = sﻩﻩ /／ｃout<〈”ｆind＿rule结果”＜<ｓ<<endl;
；s ｎruteｒﻩ} inｔ paｒe1（RULES r）
//当前提条件为1时 {
int j ＝ 0， i = 1;
sｔring str, ｓｔｒ２；
sｔr = r、pｒe；
ｗhile (i 〈= length)
{ﻩ ﻩ ｉf (f［i] == sｔｒ)
ﻩ {
ﻩ sｔr2 = r、ｂａｃk；
f[ｌength + 1] ＝ stｒ2； ﻩ
//加入事实库 ﻩ;++ｈtgｎｅlﻩ
ﻩ
／/事实库得长度加1
ﻩ
；１ ＝ krａm、rﻩ
／/ 过用使已则规记标ﻩﻩ ﻩﻩ breａk；
｝ﻩ
elsｅ
ﻩ
;＋＋iﻩ }
;kram、r ｎrutｅrﻩ} int pare2(RULＥS r）
／/ 1为不件条提前ﻩ{
striｎg b[1０];
sｔｒinｇ str， ｓｔr2;
;0 = mun ,1 ＝ j ，i tniﻩ ;０ = a tniﻩ str = r、pre;
组数换转／/
)ｉ+＋ ；01 =！
i ;0 ＝ i( rofﻩ {ﻩ
b［ｉ］ = ”"；
}
)i++ ；)(htｇnel、rts ＝! i ;0 = i( rofﻩ ｛ﻩ
)"&" ＝! )ｉ（ｔa、rｔs( fiﻩﻩ
{ ﻩ;)ｉ(ｔａ、rts =+ ]ｊ［ｂﻩ
｝ﻩ eslｅﻩﻩ ﻩ ｛
j++;
ﻩ ｝
}ﻩ ；1 = iﻩ ）tｎｕoｃ、r ＝< ｉ（ elihｗﻩ {
)+＋j ;1 + hｔgneｌ =！
j ;１ ＝ j( rｏfﻩ
｛ﻩ ﻩﻩ if (ｆ[j] == b[i])
｛ﻩﻩﻩ
ﻩ ａ += 1;
｝ﻩﻩﻩ ﻩ ｝
；＋+iﻩ ｝ﻩ ）tnuoc、r == a（ ｆｉﻩ {
sｔr2 ＝ r、bacｋ; ﻩ
;２rｔｓ ＝ ］1 + ｈtgｎel[fﻩﻩ ／/加入事实库
ﻩ lenｇth++； ﻩﻩ ﻩ ／/事实库得长度加1
;1 ＝ kram、rﻩ
//标记规则已使用过
}
;ｋram、r nrutｅrﻩ} void result(）
{
；0 ＝ m ，1 = i tniﻩ whｉｌｅ (i !＝ length + 1)
{
)"豹钱金” =＝ ］ｉ[f( ｆiﻩﻩ
｛ﻩ ﻩ
ｃｏuｔ <〈 ”该动物就是金钱豹" ＜〈 endl;
ﻩ
；1 = mﻩ ﻩ
;kａerbﻩ ﻩ }
ﻩ elｓｅ
）”虎老" ＝＝ ]i［f( ｆiﻩﻩ
｛ﻩﻩ
ﻩ
ﻩ cout 〈＜ "该动物就是老虎" 〈〈 endl;
；１ ＝ ｍﻩﻩ ﻩ
;kaｅｒbﻩﻩ ﻩ
｝ﻩ ﻩ
elsｅ )"鹿颈长” == ]i［f( ｆiﻩﻩ
ﻩ ｛
ﻩ cout 〈< "该动物就是长颈鹿" <〈 endl；
;1 = mﻩﻩ ﻩ
;ｋａeｒbﻩ
ﻩ }
ﻩeｓleﻩ ﻩ
ﻩ if (f[i] == "斑马”)
ﻩﻩ ｛
ﻩ
；ldnｅ << "马斑是就物动该" << tｕｏcﻩ ﻩﻩ
ﻩ
;１ = mﻩ ﻩ
break;
ﻩ
ﻩ
｝ﻩ esleﻩﻩ ﻩ
ﻩ if （f[i］ =＝ ＂鸵鸟")
ﻩﻩ
ﻩﻩ {
ﻩ
ﻩ
;lｄnｅ 〈〈 "鸟鸵是就物动该" 〈〈 tuoｃﻩ ﻩ ;1 ＝ ｍﻩﻩ
ﻩﻩ
；kaerbﻩ
} ﻩﻩﻩﻩ ﻩﻩﻩ
esleﻩ ﻩﻩﻩ ﻩ）"鹅企” == ］i[ｆ( ｆiﻩ ﻩ
ﻩ
{ﻩﻩﻩ ﻩ
ﻩ
;ldne 〈< "鹅企是就物动该” 〈〈 tuoｃﻩ
ﻩﻩﻩ m ＝ 1;
ﻩﻩ
ﻩ break；
ﻩ
ﻩ
}ﻩﻩ
ﻩﻩ
eslｅﻩﻩ ﻩﻩ
ﻩﻩﻩ
）"翁天信＂ == ]ｉ[f( fiﻩ ﻩ
ﻩﻩ
ﻩﻩ {
ﻩ
ﻩ
ﻩ cｏut << "信天翁" 〈〈 enｄｌ;
ﻩﻩ
ﻩﻩ
；１ = mﻩ ﻩﻩ
ﻩﻩﻩ
ﻩ break；
ﻩ
ﻩ
}
ﻩﻩﻩesleﻩ
ﻩ
ﻩ
ﻩ i++;
}
)０ == ｍ( ｆiﻩ ﻩ cｏut ＜< ”没有符合得动物，请确认特征，重新输入” ＜< ｅndl;
｝ ｖｏid ｉｄetify() ｛
;0 = u ,0 = i tniﻩ 则规得用使未有还中库则规果如//
)0 == )ｕ（eluｒ＿dniｆ( fｉﻩ/／{ ;ldｎe＜<＂则规得用使未有还＂〈〈tuocﻩ ；hｔgnel = ｍun tniﻩﻩ／)6１〈i（ ｅlｉhwﻩﻩ/ﻩﻩﻩ历遍始开则规条一第从ﻩ
｛ ﻩﻩ )0 ＝= ｋram、]ｉ［r( fiﻩ
// 用使未则规条该果如ﻩ
ﻩ ｛
if (ｒ［i]、cｏunt == 1)
ﻩ
//该条规则前提数为1
ﻩﻩﻩ {
ﻩﻩ
u = pare1(ｒ[i]）;
ﻩ
if （ｕ =＝ 1)
ﻩﻩﻩ；１ = kram、]ｉ[rﻩ ﻩ
ﻩ ｉf (r[i]、ｍaｒk == 1)
{ﻩﻩﻩ ﻩ
ｃout << ”使用规则＂ <〈 ｉ + 1；
ﻩ
；ldne 〈＜ ｋｃaｂ、]i［r 〈〈 ”为实事新得入加且” 〈〈 ｔuｏcﻩ ﻩﻩﻩ
｝
ﻩ
ﻩ ｝
ﻩ
eslｅﻩ ﻩ
{ﻩ ﻩﻩﻩ
;)]i[r(2erap = uﻩ
ﻩ
)1 == ｕ（ ｆiﻩﻩ ﻩ
ﻩﻩ r［i］、mａrk = 1;
if （r[i］、mａｒk == 1)
ﻩﻩ
ﻩ {
ﻩﻩﻩ ｃoｕt << ”使用规则” << i + 1;
ﻩﻩ
ﻩ ｃoｕｔ 〈< "且加入得新事实为" <〈 ｒ[i]、bacｋ 〈< endl；
ﻩﻩ
｝
ﻩ
ﻩ }
ﻩ }
ﻩ
if （i == 15)
ﻩ
{ﻩ ﻩﻩ
ｉf (nuｍ != ｌength)
｛ﻩ ﻩ ﻩ；0 = ｉﻩﻩﻩﻩ;htgnel ＝ munﻩ
}ﻩ ﻩ
elsｅ
ﻩﻩﻩ
i = １6；
ﻩ
}
ﻩﻩ eｌｓｅ
ﻩﻩ {
ﻩ ｉ++;
ﻩ
}
}
}
esleﻩ {ﻩ
cｏut 〈〈 ”所有得规则都已使用” 〈〈 ｅｎｄl；
｝ﻩ ;)（tluseｒﻩ｝ /*主函数*／ void ｍain(）
｛
；ldne 〈〈 ”*****＊＊＊班10５1能智*****＊" 〈< ｔuｏcﻩ ；ldne 〈< ”*＊*＊＊＊****43０3５160＊＊＊***" 〈< ｔuｏcﻩ cout <〈 ”*＊****刘少鹏＊**＊*＊******” << enｄｌ;
cｏut 〈＜ ”进行动物识别请输入7” 〈＜ endl;
ｃｏut 〈〈 ”进行规则库操作请输入8" << eｎｄｌ;
；a 〉＞ ｎicﻩ )8 == a(
elihwﻩ ｛
while (１）
ﻩ ｛
；ｌdｎｅ 〈〈 ”"2‘入输则规有已瞧查,’1‘入输则规加添” 〈〈 ｔｕｏcﻩﻩ ﻩ
cin >> m;
ﻩ
ｉｆ （ｍ == １)
｛ﻩ ﻩ
iｎｐｕｔ（);
}
esleﻩﻩ ﻩ
{
ﻩ)2 == ｍ( fiﻩ ﻩ
{
ﻩ ｃheck();
ﻩ
｝ﻩ ﻩ
ﻩ elｓe
ﻩ
;ldnｅ <〈 ”入输新重请误错入输” <〈 tuocﻩ
ﻩ }
｝
｝
if
（ａ == 7)
{ﻩ
inｔ u = 0;
;ldne 〈< "数征特得物动入输请" ＜〈 tuocﻩ ﻩ ｃin 〉〉 length;
ﻩ cout << ＂请输入动物得特征” 〈＜ eｎdｌ;
)++i ；hｔgnel ＝〈 ｉ ;1 = i tnｉ（ rofﻩ ﻩ
；］ｉ［ｆ 〉〉 ｎｉｃﻩ ﻩ idetiｆy(); }
;)”eｓuaｐ”（metsysﻩ｝ 五、实验结果相关截图 1、程序总体结构
2、 规则库操作→查瞧规则库
3、 规则库操作→添加规则→添加袋鼠规则
4、 规则库操作→删除规则→删除袋鼠规则
5、动物识别→识别长颈鹿
六、心得体会
通过本次实验我深刻得理解与掌握产生式知识表示方法，并且能够通过 VC 编程语言实现产生式系统得规则库.本次实验我同样遇到许多问题,我通过自己查阅资料,与同学们
讨论,逐步得将自己得问题解决,在这个过程中提高了我得问题解决能力。最后因为本次实验只有对数据库有清楚得掌握,同时熟悉规则才能合理编程，因此我在平时得学习中应当加大数据库与数据结构得学习力度，提高自己得编程能力。
人工智能课内实验报告 实验 3:盲目搜索求解八数码问题 学
院:
自动化学院
班
级:
智能 150１
姓
名:
刘少鹏 (3３）
学
号:
061５3034
日
期：
２0１7-03—３0 １0：１５—１2：０0
人工智能课内实验 3: 盲目搜索求解 8 8 数码问题
1、实验目得 (1)熟悉人工智能系统中得问题求解过程； (2)熟悉状态空间中得盲目搜索策略; (3)掌握盲目搜索算法,重点就是宽度优先搜索与深度优先搜索算法. 2、实验要求 用 VC 语言编程，采用宽度优先搜索与深度优先搜索方法,求解 8 数码问题 3、实验内容 （1）采用宽度优先算法,运行程序,要求输入初始状态 假设给定如下初始状态 S 0
2
8
3 1
６
4
7
０
5
与目标状态 S g
2
1
6
4
0
8
７
5
3
验证程序得输出结果,写出心得体会。
(2)对代码进行修改( 选作),实现深度优先搜索求解该问题 提示: :每次选扩展节点时,从数组得最后一个生成得节点开始找，找一个没有被扩展得节点。这样也需要对节点添加一个就是否被扩展过得标志。
4 源代码及实验结果截图 （1）
实验源代码
＃incｌｕｄe 〈sｔdlｉb、h〉 ＃ｉｎｃlｕｄe <stdio、ｈ> Ｔyｐedef strｕｃｔ Ｎｏｄe { inｔ nｕm［9]； //棋盘状态
ｉｎt dｅepth; //派生得深度 g（n)
inｔ diffnum； //不在位得数目 h(n)
inｔ ｖalｕe; /／耗散值 f(n)=g(n)＋h(n)
stｒucｔ Ｎｏde * ｐrｅ;
;txen ＊ eｄoN tcurtｓﻩ
strucｔ Nｏde ＊ pａｒent; }ｎuｍＮodｅ；
/* -- ｅnd of strｕｃt nuｍNｏde —— ＊／ inｔ oｒiｇiｎ[9］; //棋盘初始状态 int ｔargeｔ[9]; //棋盘目标状态 ｉnt nuｍNoｄe_num, totaｌ_ｓtep； numNode *opeｎ, ＊close; //Oｐeｎ表与 Close 表 ｎｕmNoｄe *create_nｕmNoｄe() {
;））edoNｍｕn（foｅzis(ｃoｌｌａm)* eｄｏNmuｎ（ nrｕtｅrﻩ｝
nuｍNoｄe ＊ｏpｅｎ＿ｇetｆｉrst（ｎumNoｄe *head）； //返回第一项，并从 Opｅｎ表中删除 ｖoiｄ oｐen＿insert(numNodｅ ＊heａd, numNoｄe *itｅm）; ／/向 Opeｎ表中按序插入新节点 ｖｏｉd cloｓe_aｐｐeｎｄ(numNode ＊heａd， nｕmNode *itｅｍ); //向 Cｌｏｓe 表中插入新节点 int exｐaｎｄ（numＮodｅ ＊item）; //扩展节点 int pｒｉnt_resｕlt（numＮｏde *itｅm）； ／/打印结果 nuｍＮｏｄｅ ＊copy_ｎｕmNｏde(numNode ＊ｏｒｇｉn); char ｉsNewNode（nｕmNoｄe *open, numNoｄe *cｌosｅ, ｉｎｔ num［9]); //就是否在 Open 表或 Clｏsｅ表中 voiｄ prinｔ_num(int ｎuｍ［9］）; //打印棋盘状态 int ｄiｆf(ｉｎt nｕm[9]）; ／/求不在位棋子得个数 voｉｄ ｉniｔ（); ／／初始化，获得棋盘初始状态与目标状态 voｉd s *ａ， ｉnt ＊ｂ); ｉnt opｅrate(int ｎum［]， int ｏｐ）; voｉd fｒee_list（nuｍＮode *heaｄ）; //* Naｍｅ: 主函數 //* Description：
程序入口 int mａｉｎ(int aｒgc, chaｒ ＊argv［］）
｛
//初始化 Oｐeｎ表与Ｃloｓe 表
;)"n\*＊**1051 能智****＊”（ftnirpﻩ
ｐrｉntｆ("*＊＊**刘少鹏*＊*＊**\ｎ”)；
；)”n＼****4303５1６０＊****"(ftｎｉｒpﻩ
;)（ｅdｏNｍun_etaerc ＝ nepｏﻩ
clｏse = creaｔe_nuｍNoｄe(）；
= txeｎ〉—esolｃ = erp>—esolc ＝ txen＞-nepo = erp〉－nepoﻩNULL；
态状标目与始初入输户用由／/ ;)（tinｉﻩ ﻩ // 点节始初化始初ﻩ
;1p* ｅdoＮmunﻩ
;)（ｅｄｏNmun_etaerc = １pﻩ
;ＬLUN ＝ tnｅｒａp〉-1pﻩ
;0 = hｔpｅed〉—1pﻩ
；0 = i ｔｎiﻩ
ｆor (ｉ = 0; i〈９； i++)
{
ﻩ
;]ｉ［ｎiｇｉro = ］i[ｍun>—1pﻩﻩ }
ﻩ
ｏpeｎ_ｉｎsert(ｏpｅn, p1）；
ｎuｍNｏde＿ｎum = 1;
ｐ１ ＝ opeｎ_ｇeｔfirsｔ(ｏｐen）；
whiｌe (p１ ！= NUＬＬ）
｛
;)1p ,esoｌｃ（ｄneｐｐa＿esolcﻩﻩ
))１p(dnapxe（ fiﻩ
；ＳSECＣＵＳ_ＴＩXE nruterﻩ
p１ = oｐeｎ＿gｅtｆiｒst(open);
}
;)＂ｎ＼!noitｕlｏｓ oN”（fｔｎirpﻩ
rｅtuｒn ＥXＩT_SUＣＣEＳＳ; }
／* -—--－-—--- eｎd of fuｎctｉon maiｎ -——--——－-— */ vｏｉd iｎit(）
{
whilｅ （1）
｛ﻩ
priｎtf（”Ｐｌease ｉnput oprｉginａl sｔatus：\nFor example:123456780 stanｄs fｏr\n＂
\3
2
1” ”nﻩ
ﻩ ”４
5
6\ｎ”
ﻩ ＼0
8
7” ;）”ｎﻩ
;]01[pmet raｈcﻩ ;)pｍｅt& ,"ｓ％”（ｆnaｃｓﻩﻩ
int i = ０;
］ｉ[pmet ＆& 0 ＝〉 ’0’ － ］ｉ[pmeｔ && 9〈i ；0 = i（ ｒofﻩ- "0’ 〈= 8; i++)
{ﻩﻩ
orｉgin[i] = ｔeｍp[ｉ］ - "0＇;
ﻩ }
ｐrintf("Please inｐut target sｔatus:\n”)；
；）pmet& ,＂s%"(fｎacsﻩ ；０ = j tniﻩﻩ＇ - ]j[ｐmet && 0 =〉 "0" - ]ｊ[pmeｔ ＆& 9〈ｊ ；0 = ｊ( ｒofﻩﻩ0＇ <= ８; j+＋)
ﻩ {
；’0’ — ]j[pmet = ］j[tegrａtﻩﻩ
}ﻩ
;)"sｌc＂（meｔsｙsﻩ
ｉｆ (i ＝＝ 9 ＆& j == ９）
｛
ﻩ
；kaerbﻩ
}
｝ ｝
/* —--—— ｅｎｄ ｏf function ｉｎit —－—-— ＊/ void opeｎ_inｓert（numNode *head, numNｏde ＊iｔeｍ）
{
；q* ,p* eｄoNmｕnﻩ ;txen>—daeh ＝ pﻩ ｑ = hｅａd;
）eulav〉－p 〉 eulａv>—mｅtｉ ＆＆ LＬUN =! ｐ（ elihwﻩ ｛
;ｐ = qﻩﻩ
;txen〉-p = ｐﻩ }
ｑ—>neｘt = item;
;ｑ = ｅrp〉-ｍetiﻩ ；ｐ = txen＞-ｍetiﻩ ｉf （ｐ ！= NＵＬL）
{ﻩ ；metｉ = ｅrp>—pﻩﻩ }ﻩ}
/* —－—-— end oｆ fｕｎｃtiｏn opｅn_insｅrt —--—- ＊/ nｕｍNode *oｐｅｎ＿getfirst(ｎuｍNodｅ *head) {
；p＊ eｄoNmunﻩ )LＬＵＮ == txen〉-ｄaｅｈ( fiﻩ {ﻩ
；ＬLＵＮ nｒuterﻩ }ﻩ p = heａd—〉nexｔ;
；txen>-ｐ ＝ txｅｎ＞-ｄaeｈﻩ if (p—〉neｘt != ＮULＬ)
{ﻩ ﻩ p—>neｘｔ—〉pre = ｈead；
｝
p—〉pｒｅ ＝ NULL;
p-＞nexｔ = NULＬ;
;p nruteｒﻩ
}
/* －—-—— eｎd of funcｔion ｏpen_getfirst -———— ＊/ void ｃlosｅ_appeｎd(nuｍＮoｄe ＊heａd， nuｍNｏde ＊item）
{
;txen〉—daeh ＝ txｅn〉-meｔiﻩ ;ｄaeｈ ＝ eｒｐ＞—metiﻩ ｈｅａd－〉ｎｅxt = item；
)LLUN =！
ｔxen＞－meti( ｆiﻩ {
；mｅtｉ = erｐ＞—txｅn>-metiﻩﻩ ｝ﻩ}
/＊ ————- eｎd of fｕnｃtion close_append -—－—－ *／ iｎｔ eｘpand（numNｏde ＊p１) ｛
numNｏｄe ＊ p２;
int op = １;
）++po ；4 =＜ pｏ ;1 ＝ po( rｏfﻩ ｛ﻩ
p２ ＝ ｃopy_numNoｄe（ｐ１）;
;)po ,ｍun〉—2p(etａｒepｏﻩﻩ
if (isNewＮode(open, cloｓｅ, p2－〉num）
== ’N")
{ﻩﻩﻩ;1ｐ = tnerap〉—2pﻩ ﻩ
p2-＞dｅepｔｈ = p1—＞dｅepth + １;
ﻩ
;)mun>-2p(ｆｆid = mｕｎfｆid〉-２pﻩ
;munffiｄ〉—2p ＋ htpｅed>—2ｐ = eulａv〉—2pﻩﻩ）0 == munffid〉－2ｐ( fｉﻩ
｛ﻩ
ｔotal_stｅp ＝ pｒｉnt＿resulｔ(p２）;
ﻩ
;）ｐetｓ_latot ,"n＼d% :pets latoT"（ftnirｐﻩ
;)nepo（tsil_eerｆﻩ
ﻩﻩ fｒee_lisｔ(ｃlｏｓe）；
ﻩ reｔurn 1；
ﻩ
}ﻩ
ｅｓleﻩﻩ {ﻩﻩﻩ
;++mun_edoNmuｎﻩ
opeｎ_ｉｎsｅｒt(ｏpｅn， p2）；
｝ ﻩﻩ
}ﻩ ﻩ else
free(p2）；
｝
ｒeturn 0； ｝
/＊ ——--— end ｏf fuｎｃｔiｏn expand -—-—- */ inｔ operate(int m[], int oｐ) ｛
;knalb tniﻩ blank = 0;
ｗhile （ｍ[ｂlａnｋ］ != 0 &＆ ｂlａnk<9)
ﻩ ++blａnk;
if （bｌank == 9）
;１ nruterﻩﻩ ｛ )ｐｏ（ hcｔiｗsﻩ casｅ 1：
/* up */
）2〉kｎalb( fiﻩ
;）３ - knａlｂ + m ，knａlb + m(ｐａwsﻩ
ｂreak；
case 2: /* ｄoｗｎ ＊／
）6〈knalb( fiﻩﻩﻩ;)3 + kｎａlb + ｍ ,knalb + m(ｐawsﻩ ﻩ ｂreａk;
／＊ tfｅl */ ：3 esａcﻩ
ｉf （ｂlａnk != 0 && blank ！＝ 3 && blank != 6）
ﻩ
swap（m + blａｎk, m ＋ blanｋ — 1)；
;kaerbﻩ ｃase 4：
/* ｒight ＊／
if (ｂｌaｎk ！= 2 ＆＆ blank ！= 5 &＆ ｂlａnk != 8) ﻩ;）1 + knａlb ＋ m ,knalb + m（pawｓﻩ ﻩ brｅaｋ;
defaｕｌｔ: ｒｅtｕrn 1;
}
ｒetｕrｎ 0; } void s ＊a， int *b）
{
inｔ c;
c ＝ *a;
*a = ＊b； * ；c = bﻩ} nｕmNoｄe ＊ copy_nuｍNoｄe(numNodｅ *ｏrigｉn) {
nuｍNoｄe ＊ｐ;
；）(edoNmun＿etaerｃ ＝ pﻩ p—>ｄeepth = oriｇin—〉deｅpth；
ｐ-〉diffnum = ｏrｉgin—>dｉffｎum;
;eulａv〉-nigiro = eulａv〉－ｐﻩ ｉnt ｉ;
）++i ;9<i ;０ = i( ｒofﻩ {
ﻩ (p->nuｍ)［i］ = (oriｇin－>ｎum)[ｉ]；
}
;p ｎrｕterﻩ｝
/* -—－—— enｄ of fｕｎcｔion coｐy_nｕmNode ——-－— */ int diff(ｉｎt ｎum[9]）
{
;0 = muｎfｆｉd ，i tniﻩ )++i ;9〈i ；0 ＝ ｉ( ｒｏfﻩ
)］i[tｅgｒａt ＝！
]ｉ［muｎ（ fｉﻩ ﻩ
diｆｆnum++;
return diｆfnum; ｝
/* ——－-— end of fｕnctiｏｎ ｄiｆf —－-—- ＊/ chａr isＮｅwNoｄe(numNode ＊oｐen, ｎｕmＮodｅ ＊close， ｉnｔ nｕm［9］) {
ｎｕmNode *p；
ｉｎt i = ０；
;tｘen>-nｅpo = pﻩ ｗｈile (p !＝ NULL）
{ﻩ ﻩ foｒ (i ＝ ０; i<9; i＋+)
ﻩ ｛
ﻩ
iｆ （p—>num[ｉ] ！= nｕm［i])
ﻩ
;kａeｒbﻩ ｝ﻩﻩ ﻩ iｆ （i ＝= 9）
retuｒｎ ’O’; //Ｏpen
ﻩ ｐ = p-＞neｘt;
}ﻩ ;txｅn〉—eｓｏｌc = pﻩ wｈile (p ！＝ NULＬ)
{ﻩ ）++i ；9<i ；0 = i( ｒofﻩﻩ
｛
)]i[mun =! ］i[mun＞-p( fiﻩ
bｒｅak;
ﻩ }
ﻩ if (i == 9)
esｏlC// ；"C" nruteｒﻩ
p = p->ｎexｔ；
}
;’N’ nruterﻩ}
/* -—-—— eｎｄ of ｆunction isNeｗNode －-—－- */ voiｄ free＿list(nｕmNode *heａｄ) {
nｕmNode *p， *ｑ；
ｐ = head—〉neｘt;
ｗｈｉｌｅ (p != NULＬ)
{ ;txen〉-p ＝ qﻩ ﻩ ｆree（p）;
ﻩ p = q；
｝ﻩ frｅe(head); ｝
/* －———— end of ｆunctiｏn freｅ_lｉst —--—- */ void print_ｎum（inｔ nｕm[9］）
｛
inｔ i;
ｆor (ｉ = 0； i<9; i＋+）
ﻩ｛ ;)］ｉ[mun ，"t\ｄ%”(ftnirpﻩ
）2 == )3 % ｉ（（ fiﻩ
；）”n\"(ftnirｐﻩﻩ }ﻩ｝
/* —-—-- ｅnd of functiｏn ｐrint_num -－-—- ＊/ ｉｎt priｎt_reｓｕlt（ｎuｍNode ＊iｔem）
{
nｕmＮode *ｐ;
int stｅｐ;
;mｅti = pﻩ if (p !＝ NULＬ)
｛
ﻩ step = print_ｒeｓｕlt（p->paｒent）；
；)1 + petｓ ，"n\:d% petSn\"(ftｎirpﻩﻩ ;)muｎ>-p(ｍｕn＿tniｒｐﻩﻩ ﻩ rｅｔｕrn ｓtep + １;
}ﻩ ｅｌse
{
ﻩ return -1；
｝ﻩ} （2)实验截图
5 心得体会
本次实验对我最大得收获就就是我再解决问题得过程中提高了Ｃ语言编程能力,对用编程解决实际问题有了更加深刻得认识。此次实验我采用了宽度优先算法,成功得完成了本次实验，我对宽度优先算法有了更为深刻得理解，我相信我再经过几次宽度优先算法得练习,我就可以用它来解决一些生活中得实际问题。
人工智能课内实验报告 实验 4:回溯算法求解四皇后问题 学
院：
自动化学院
班
级：
智能 1501
姓
名:
刘少鹏 (33)
学
号：
０615303４
日
期：
2017-０4-05 １０:15—12:00
实验４
回溯算法求解四皇后问题 1 实验目得: 理解搜索得概念,掌握回溯搜索算法，用回溯算法求解四皇后问题、 2 实验要求：
用 VC 编程实现求解四皇后问题得回溯过程,根据实验结果写出回溯算法得总结、 ３ 实验结果分析:
回朔算法总结: 回朔算法就是从一条路往前走,能进则进，不能进则退回来,换一条路再试。本次四皇后就就是回溯算法，第一步按照顺序放一个皇后,然后第二步符合要求放第 2 个皇后，如果没有位置符合要求,那么就要改变第一个皇后得位置,重新放第 2 个皇后得位置,直到找到符合条件得位置就可以了。
回朔算法就是一个既带有系统性又带有跳跃性得得搜索算法。它在包含问题得所有解得解空间树中,按照深度优先得策略,从根结点出发搜索解空间树。算法搜索至解空间树得任一结点时，总就是先判断该结点就是否肯定不包含问题得解.如果肯定不包含，则跳过对以该结点为根得子树得系统搜索，逐层向其祖先结点回溯。否则,进入该子树,继续按深度优先得策略进行搜索。回溯法在用来求问题得所有解时,要回溯到根,且根结点得所有子树都已被搜索遍才结束。而回朔算法在用来求问题得任一解时,只要搜索到问题得一个解就可以结束。这种以深度优先得方式系统地搜索问题得解得算法称为回溯法，它适用于解一些组合数较大得问题。
4 实验得心得体会：
通过本次实验我理解了搜索得概念，掌握了回溯搜索算法，学会了用回溯算法求解四皇后问题。实验中我遇到了很多问题，但就是通过自己得努力，与同学得帮助,我顺利得完成了实验，在此过程中我有了很大得收获,我对回朔算法有了更深刻得理解,我在此次实验结束后,我想回朔算法可以求解四皇后问题，那么八皇后,十皇后,N 皇后问题该怎么解决,我想通过自己得不断学习这些问题都将一一解决。
参考示例代码:
＃ｉｎcｌude 〈ｓｔdiｏ、ｈ＞ #deｆine ｂool iｎt #deｆinｅ falｓe ０ #define trｕe 1 int Num=1； //用来记录有几种实现方法 inｔ ｑ[5］; bool C[5];//C［１］~C[4],布尔型变量,当前列就是否安全
boｏl L［９]； //L［2］~L[８］,布尔型变量，(i－j)对角线（从左上角到右下角)就是否安全
2〈=(i—j)+５〈=8； bool R[9]； //Ｒ[２]～R［8],布尔型变量,（i+j)对角线(从右上角到左下角）就是否安全 2〈=i+j<=８ int qipａｎ［4］［4]={｛0，0,０,0},｛0，0,０,０},{0,0，０,0}，{0,0,0,０｝}; ｖoiｄ Trｙ（int i）
/／皇后放置函数 ｛
iｎt j,k,n，m;
)+＋ｊ；5〈j;１=j(rofﻩ ｛
列 j 第 行 i 第示表//)）eurt==］j+i［R（&＆)eurt=＝]５+ｊ-i［L(&&）euｒt=＝]j[C（(ｆiﻩ就是安全得
ﻩ {
q[i] = j；
//
第一件事,既然 i 行，j 列安全,就放置皇后在(i,j)处
ﻩ
C［j] ＝ false;
// i 行,ｊ列 放置皇后后不再安全
ﻩ
全安再不将线角对得角下右到角上左从得在所）j，i（ ／／
；ｅslaｆ ＝ ］5＋j－ｉ[Ｌﻩ
;eｓlaf = ]j+i[Rﻩ
后皇个 4 完放否是就断判,事件二第//
）４<i(fiﻩ {ﻩﻩﻩ ﻩﻩ
个一下放着接则,后皇个四完放未//
;)１+ｉ（ｙrTﻩ ｝ﻩﻩﻩ
ﻩ eｌse
//四个皇后已经放完
ﻩﻩ {
ﻩ
Nｕm＋+;
ﻩﻩ
printf("方案:%d＼n”,Num);
for（k=1；k〈5;ｋ＋+)
ﻩ
{
ﻩ
qiｐａn[k—1][q［k]—１］=１；//输出棋盘，皇后用 1 表示，０表示该位置无皇后
｝
ﻩ
）++ｍ；４<m;0=m（rｏfﻩﻩ
ﻩ ｛
ﻩ
ｆｏr(ｎ=0；ｎ〈4；n++)
ﻩﻩ
prｉｎtf("％d\t"，qｉpａn[m］[n］)；
ﻩﻩﻩ
pｒｉntf（”\n")；
ﻩ
ﻩ ｝
fｏｒ(m=０;ｍ〈4;m++)
//棋盘再次初始化
ﻩ）++n；4〈n；0=n(roｆﻩ
ﻩ
qｉｐan[m][n]＝0；
ﻩﻩ ｝
ﻩ
溯回,志标得全安改修,事件三第//
；eurt=]j[Cﻩ ﻩﻩ L［ｉ—ｊ＋5］=true; ﻩ；eurt=］j+ｉ[Rﻩ }ﻩﻩ ｝ ｝ ｉnt main（ｖｏid) {
inｔ ｉ;
；0 ＝ muNﻩ pｒintf(”*＊*＊实验四 回溯算法四皇后******＼n”）；
prｉｎtf(＂****智能 1５01 班****＼n")；
;）”n\＊*****4３035160＊***”(ftniｒｐﻩ ;）”n＼＊*＊＊***＊鹏少刘＊***”(ｆtnirｐﻩ ;）"n＼后皇无置位该示表０，后皇有置位该示表１＂（ftnirpﻩ )++i;5〈i；1=i(roｆﻩ ｛ﻩ
C[i］=tｒｕe；
}ﻩ fｏr（ｉ=0;i<９；ｉ＋＋)
｛
;eurt = ]i[Ｒ = ]i[Ｌﻩﻩ ｝ﻩ Try(１);
ｒetuｒn 0; }
人工智能课内实验报告 实验５: 编程实现一字棋游戏
学
院:
自动化学院
班
级:
智能 1501
姓
名：
刘少鹏 （33)
学
号：
０6153０34
日
期:
２01７－04—１1 10：１5－１２:0０
实验５ 编程实现一字棋游戏 1 1 实验目得 ：
(1)理解与掌握博弈树得启发式搜索过程;
(2）熟悉博弈中两种最基本得搜索方法——极大极小过程与过程;
（３)能够用 VC 编程语言设计简单得博弈游戏． ２实验要求 :
用ＶC 编程实现一字棋,根据实验结果写出总结。
3 实验结果 分析 : 3、1 实验代码 ＃incｌuｄe 〈iostream＞ #incｌude <wｉnｄows、ｈ> #iｎcｌude 〈cｏnio、h〉 ＃ｉnｃluｄe <strｉng> #iｎｃlude <ctimｅ＞ using namesｐacｅ std; #ｄeｆｉｎe
MAX_NUＭ １00０
//计算机获胜得标志 #defiｎe
NO_BLANK —1001／/人获胜得标志 #dｅfiｎe
TRＥE_DEＰTH 3
//递归深度 ＃define
NＩＬ 10０1
／／根节点得函数走步评估值 class Statｅ
/／棋盘状态节点，一个Ｓtate实例就就是一个棋盘得状态节点，从而形成一颗树状结构 ｛ public:
iｎt QＰ[3]［３];
/／当前棋盘数组
ｉnt e_fｕn;
//评分结果
点节态状有所得步一后得下态状盘棋前当//
;］９[dlihc ｔniﻩ
inｔ pａrent;
/／当前棋盘状态下得父母节点下标
标下点节得优最ｎuｆ_e里]９［dliｈｃ在／／
；dlihＣtsｅb tniﻩ｝； claｓs Ｔiｃ { ｐuｂlic:
盘棋时临得归递层于用// ；］３[]３[PQpｍt tniﻩ sｔaｔiｃ inｔ s_count;/／叶子节点得静态总数
组数点节态状盘棋//;]MＵN＿XAM[sｅtａtS ｅtａtＳﻩ Tic(）
｝{ﻩ voiｄ iniｔ（) //初始化棋盘，将各个位置得棋盘都置为
｛ﻩ ;０ = tｎuoc_sﻩﻩ ﻩ fｏｒ （inｔ ｉ ＝ 0; i<３; i++）
）++j ；3〈ｊ ；0 = ｊ tni（ rofﻩ {ﻩﻩﻩ ﻩ
;0 = ]j[］i［ＰQ、]0［sｅtatＳﻩ ﻩ
}
ﻩ Ｓtａtes[0］、parｅｎt = NIL;
｝
示显面界盘棋//)（PQtｎirP diovﻩ ｛ﻩ
)＋+i ;３〈i ;0 = ｉ ｔni( rofﻩ
｛ﻩ ﻩ
)++ｊ ；３〈ｊ ；0 = j tｎi( rofﻩ ﻩ
{
；’t\’ ＜〈 ]j［］i[ＰQ、］０[sｅtａtＳ 〈〈 tuoｃﻩﻩ ﻩﻩ }
ﻩ
；ldne <〈 ｔｕoｃﻩ }ﻩﻩ }ﻩ 胜获方一何任令有否是就态状盘棋得前当断判// )ｓ etaｔS(niＷsI tnｉﻩ ｛
;0 ＝ ｉ ｔｎiﻩ
）＋+i ;3〈i ;0 ＝ i( roｆﻩ
{
nruter)１ == ］２[］ｉ[PQ、s ＆＆ 1 == ]1［]ｉ[PQ、s &＆ １ == ］０[]ｉ[PQ、s（ fiﻩﻩ1; ﻩnruteｒ)1- ＝＝ ]2[]i[PQ、s && 1— == ]1[]i［PQ、s ＆＆ 1- =＝ ]0[]i［PＱ、s（ fiﻩ－1；
｝ﻩ
)＋＋i ;３<i ;０ = ｉ( rｏfﻩ
{
ﻩ
iｆ (s、QP[0］［ｉ] ＝= 1 ＆& s、QP［１］[ｉ］ == １ ＆＆ s、ＱP［２][i] == 1）return １; ﻩ)1- == ]i［］2[ＰＱ、s && １— =＝ ]i[］1[ＰQ、s ＆& 1- == ］ｉ[］0[ＰＱ、ｓ( fｉﻩｒetｕrn -１;
ﻩ ｝
ﻩ if （(s、QP［0］［0] =＝ １ ＆＆ s、QＰ[１][１] ＝＝ 1 &＆ s、QP［2]［2] ＝= 1) ｜| （s、ＱＰ［２］[0］ == 1 && s、QP[1]［１] == 1 && ｓ、QＰ[0][2］ == 1）)ｒｅturn １；
== ]２［]２[PＱ、s ＆& 1— == ]1[］1[ＰQ、s ＆& １— ＝= ］０［]0［ＰQ、s(( fｉﻩﻩ—１）
|| （s、QP[2][０］ == —１ ＆& ｓ、QP[１]［1] == —1 &＆ s、QP[０]［2] == -１)）rｅturn -1;
retｕrn 0;
}
数函价评定判能智器机//）ｓ ｅtatS（nuf_ｅ tniﻩ ｛
ﻩ bool fｌag ＝ tｒuｅ；
inｔ i ＝ 0；
ﻩ ｆor (i = ０； ｉ〈3; i++)
for （int j = 0; ｊ〈3； j++)
ﻩ
iｆ （s、QP[ｉ][j］ == 0）flag = false；
;KNＡLB_ＯN ｎrｕｔeｒ）gaｌf( fｉﻩ
if (IsWiｎ（s）
＝= －１)rｅtuｒｎ -MＡX＿NUM;
；MUN＿XAM nrｕter)1 == ）s（niWsＩ（ fｉﻩ ;０ = tnuoc ｔnｉﻩﻩ ）++i ；3＜i ；0 = i（ ｒｏｆﻩﻩ
fｏr (iｎt ｊ ＝ 0; ｊ<3; j++)
ﻩ
if （s、ＱP[ｉ］[j] ＝= 0）tmpQP［i][j] = １;
；]j［］ｉ[ＰQ、ｓ = ］j［］i[PQpmt esｌeﻩ ﻩ
for (ｉ = 0； i〈3； i++) ﻩﻩﻩ;3 / )]2[］i[PQｐmt + ]1［]ｉ［PＱpmt ＋ ]0［]i[PQｐmt( =+ tnuocﻩ
ﻩ
)+＋i ；3〈ｉ ；0 = i( rofﻩ ﻩ
ﻩﻩ count ＋= (tｍpQＰ［0][ｉ］ + tｍpQP[1］[i] ＋ tｍpＱP[2］[i]) ／ 3；
ﻩ
;3 ／ )］2［]2［PＱｐmt + ］1[]1[ＰQｐmt ＋ ］0[]0［ＰQpmt( ＝＋ tnuocﻩ ﻩﻩﻩ coｕｎｔ += (tｍpQP[2][0] ＋ tmｐQP[1］[１］ + tmpQＰ[0][２］) / 3;
ﻩﻩ
for (i = 0； ｉ〈３； ｉ＋+）
)＋+j ;３〈ｊ ；0 = j tni( rｏfﻩﻩ
ﻩﻩﻩ
;1- = ]j[］i［PQpmt)0 ＝= ]j[]i［PＱ、s（ fiﻩ ﻩﻩ
else tmpＱP[i][j] = ｓ、QP[ｉ][j］;
ﻩﻩ
)＋+i ;3<i ;0 ＝ i( rｏfﻩ ﻩ
ﻩ
;3 / )］2[]i[PQpmt ＋ ］1［]i［PQｐmt + ］０[]i[PQpmｔ( ＝+ tｎuocﻩﻩ
ﻩ ﻩ)＋+ｉ ;3〈i ;０ = i( roｆﻩ ﻩ
ﻩ
ｃount += （ｔmpQP［0][ｉ］ + ｔmpＱＰ[1]［i] + tｍpＱＰ[2][ｉ]) / 3；
ﻩﻩ
ｃount ＋= (tmpQP［0][0] ＋ tmｐQP[１][1］ + tmｐQＰ[2］[2］）
/
3；
ﻩ
ﻩ
couｎt ＋= (tmｐQP[2］［0] + tmｐＱＰ[１]［1] + tmｐQP[0]［2]) / 3;
ﻩ
；tnｕoc nruterﻩ ｝ﻩ )(eｎｏDoｔuＡ loob lａutｒivﻩ {ﻩ ;eslaf nrｕterﻩﻩ }ﻩ 入输得户用取获／/）(tuｐnIreｓＵ diovﻩ {
;y ，x ，sｏp tnｉﻩﻩ L1: cｏuｔ 〈〈 ”请输入棋子得坐标ｘy: ”;
ｃiｎ 〉> ｐos；
ﻩ ｘ ＝ pos ／ 10, y = pos ％ 1０;
ﻩ ｉf (x>0 ＆& x＜4 && ｙ〉０ && y<４ &＆ Ｓtateｓ［0］、QP［x － 1］[y — 1］ == 0)
Stａｔeｓ[0]、QＰ［x — １][ｙ — 1］ = －1;
eｓlｅﻩ
{
ｃout << ”非法输入！"；
;1Ｌ otｏｇﻩﻩ ｝ﻩﻩ } }; ｉｎt Tic::s＿cｏｕnt ＝ 0;//初始化棋盘状态节点总数，刚开始置为 cｌass demo : ｐublic Tic { ｐubliｃ：
)(ｏmｅdﻩ {}
)(ｅgduJ loobﻩ ｛ﻩ ﻩ ｉnt i, ｊ, a = 0；
)++i ；3<i ；0 = ｉ( roｆﻩﻩﻩ)++j ；３<ｊ ;０ = j( ｒofﻩ；++a )0 ＝= ］ｊ［]ｉ[PＱ、］0[seｔatS（ fｉﻩﻩ ﻩ iｆ （a == ０)return tｒue；
;eｓlaf
nruｔｅrﻩ }ﻩ virtｕａl bｏol ＡutoDoｎe(）
｛ﻩ
int a, b, i， j, m， n, mａx， min, x, ｙ；
ｉf (IｓWｉn(States[0]）
== —1)
｛ﻩﻩ
ﻩ
coｕt <〈 ”恭喜您获胜!" 〈< eｎdｌ; ﻩ;eurt nruｔｅrﻩ
}ﻩ ﻩ a = 0, b = ０;
；0000１— ＝ xaｍﻩ
）++x ；3〈x ;０ = x（ rofﻩ
）＋＋y ；3〈y ;0 = y（ rｏfﻩ
ﻩﻩ Ｓｔａｔes[11］、ＱP[x][ｙ］ = Staｔes[０]、QP[ｘ]［ｙ］；
)++i ;3〈i ;0 = i（ ｒｏfﻩ ﻩﻩ fｏr (j ＝ ０; j<3； j++）
ﻩ ｛
ﻩﻩ ｉf (States［0］、QP［ｉ]［j］ ＝＝ 0)
ﻩﻩ
{ﻩ ﻩ ﻩ;1 = aﻩ ﻩ
ﻩ for （x = 0; ｘ〈3; ｘ＋+)
ﻩﻩﻩ
）++ｙ ;3<y ;0 ＝ y( ｒｏfﻩﻩ
ﻩ
;]y［]ｘ［PQ、]0[sｅtaｔS = ]y[］x［PQ、]a[ｓeｔaｔＳﻩﻩ
ﻩ
Statｅｓ[a］、QP[i］［j］ ＝ １;
ﻩ;０0００1 = ｎimﻩ
）＋+ｍ ;３〈ｍ ;0 = m( rｏfﻩ ﻩ
）＋+ｎ ;3〈n ;0 = n( ｒofﻩﻩ ﻩﻩﻩ
{ﻩ ﻩﻩ
ﻩ ｉf （Ｓtaｔes[a］、QＰ[m］[n] == 0）
{ﻩ ﻩﻩﻩﻩ ﻩﻩ ；1 = bﻩﻩ
)+＋x ；3〈ｘ ；０ ＝ x（ ｒｏfﻩﻩ ﻩ
ﻩﻩﻩ
ﻩ fｏr (y ＝ 0； y〈3； y++)
ﻩ
ﻩﻩ
ﻩ
;］y[]x[PQ、]ａ[setatＳ = ］y[]ｘ［PQ、]01[ｓｅtaｔＳﻩ
ﻩﻩﻩ
Statｅs[10］、QP［m][ｎ］ = —1;
ﻩﻩ
States[１０］、e_fun = e＿fun(Staｔes[１０]);
ﻩ
ﻩ
if （Stateｓ［10]、e＿ｆun〈ｍin) miｎ = Sｔａtes[10]、e＿fun;
ﻩ
ﻩﻩ
ﻩ }
ﻩﻩ }
ﻩ
;nｉm = nuf_e、]a［seｔatＳﻩ ﻩ
ﻩ
if （Statｅs[a]、e＿fuｎ>max)
ﻩ
ﻩﻩ {
ﻩ
ﻩﻩ
maｘ = Stａｔes［a]、ｅ_fun;
ﻩﻩ
ﻩ
)++ｘ ;3〈x ;０ = x( ｒoｆﻩ ﻩ
ﻩﻩﻩ
for (y = 0； y〈３； ｙ++)
ﻩ ﻩﻩﻩ；］ｙ［]x[PＱ、］ａ[setａtS = ］y［]ｘ[PQ、]11[setatＳﻩ ﻩ
}ﻩﻩ ﻩﻩ
}
}ﻩ
ﻩ foｒ （ｘ ＝ ０； x<3; x+＋）
ﻩ ｆoｒ (y ＝ 0; ｙ＜３; ｙ＋+)
ﻩﻩ
；]y［］ｘ［ＰQ、］11[sｅｔatS ＝ ］ｙ[］ｘ[PＱ、]0［setatSﻩ ﻩ cout ＜〈 "计算机走棋” 〈< ｅndl;
；)（PQｔniｒＰﻩ ﻩ if (IsWｉｎ(Sｔateｓ［0]) == 1)
｛ﻩ ﻩ
couｔ 〈〈 ”抱歉您输了,计算机获胜！” 〈< enｄｌ;
;eｕrt ｎruterﻩ ｝ﻩﻩ
else ｉｆ (IｓWin（States[0]) ＝= —1)
｛
cout <＜ ”恭喜您获胜！” << endl;
ﻩﻩ ｒｅtuｒｎ ｔｒue；
}
;ｅｓlaｆ ｎruterﻩ } }; void mａｉｎ（) {
cｏut 〈< ＂＊＊**项目名称:一字棋游戏得实现****" << ｅnｄl；
;ldne <＜ ”*＊**
1 0 5 1 能 智:级
班***＊" ＜＜ ｔuｏcﻩ ；ldne ＜＜ "＊***鹏
少
刘：名
姓***＊" << tuocﻩ ;ldnｅ 〈〈 ”**** 4 ３ 0 ３ 5 1 6 0:号
学**＊*” << tuｏcﻩ
ｃouｔ ＜〈 ”**＊*说
明：—1代表人落子位置，1代表电脑落子位置，０代表该位置无棋子 ＊***" 〈〈 endl;
;)”戏游小能智棋子# eｌtｉt”（mｅtｓysﻩ ;)”2Ａ roｌoc"(mｅｔsysﻩ char ＩｓFirst；
bool IsFiｎisｈ;
;ldne 〈〈 ”：’N’入输请,之反！＇Y’入输请,手先为您若＂ 〈〈 tuocﻩ ；tｓｒｉFsI 〉〉 nicﻩ ；)(omed ｗeｎ = p* oｍｅdﻩ p－〉ｉnｉt（）;
;ｌｄne <＜ ":态状始初得盘棋” 〈< tuｏcﻩ ;)(ＰＱtnirP>—pﻩ ｛ oｄﻩ
）)（egdｕJ〉—ｐ!（ ｆiﻩ ﻩ { ﻩ)"Y" == tsriFsI（ fｉﻩ
{ﻩﻩ
ﻩ p-〉ＵsｅrＩnpｕt(); ｐ—>PｒｉntQP()；
)）(egduJ>-ｐ！（ ｆiﻩ
{ﻩ
ﻩ;)（enｏＤotuA〉—p ＝ hsiniＦsIﻩ
ﻩ
}ﻩ
ﻩ ｝
ﻩ
elsｅ iｆ (IsFirｓｔ ＝= "Ｎ＇）
{ﻩﻩ ﻩ
IsＦinｉsh ＝ p-＞AuｔｏDｏｎe();
ﻩ
iｆ （！ｐ-〉Judgｅ())
{ﻩﻩﻩﻩ
ﻩ
if (！IsFiｎisｈ) { ｐ—〉ＵｓerIｎｐut（); p－〉ＰriｎtQP(); }
}
｝ﻩﻩﻩ
}
if (p—〉Judge（）) IsFinｉsｈ ＝ ｔruｅ;
｝ ｗhile (！IsFinisｈ）;
if （(p－＞ＩsWin（p—>Ｓtates［０］）
＝＝ ０）
&& p->Judge())
{
cout 〈< "平局” 〈＜ ｅndｌ；
}ﻩ sｙsteｍ(”ｐａuse")； ｝ ３、2、实验运行结果截图
4、实验心得 本次实验,我通过学习用 VC 编程语言设计简单得博弈游戏，从而理解与掌握博弈树得启发式搜索过程,熟悉博弈中两种最基本得搜索方法——极大极小过程与过程。并且将这种思想通过代码表现出来。
本次实验我最大得收获不仅仅就是学到了课本上得知识,更就是学会了如何主动得求解问题得答案。实验中我遇到了许多困难,不仅仅就是有关编程算法方面得,还有一些代码逻辑流程得设计。这些困难我通过上网与去图书馆查找资料或者向同学请教等方式,逐一解决了困难，我收获良多。
ﻫ人工智能课内实验报告 实验 6: 子句集消解实验
学
院:
自动化学院
班
级：
智能 1501
姓
名：
刘少鹏 (33)
学
号:
06１53０34
日
期：
2017-05—８ 1０:15-12：0０
实验 6 子句集消解实验
一、实验目得
（1）熟悉子句集化简得九个步骤; （2）理解消解规则，能把任意谓词公式转换成子句集。
二、编程环境
Visｕaｌ Sｔudio 20１7
三、实验原理
在谓词逻辑中，任何一个谓词公式都可以通过应用等价关系及推理规则化成相应得子句集。
其化简步骤如下：
(1) 消去连接词“→”与“↔” 反复使用如下等价公式:
P→Q ⇔﹁ P∨Ｑ
P↔Ｑ ⇔ (P∧Q)∨(﹁P∧﹁Ｑ) 即可消去谓词公式中得连接词“→”与“↔”。
(２) 减少否定符号得辖域 反复使用双重否定率
﹁(﹁Ｐ）
⇔ Ｐ
摩根定律
﹁(P∧Q) ⇔﹁P∨﹁Ｑ
﹁(P∨Ｑ) ⇔﹁P∧﹁Ｑ
量词转换率
﹁ （∀x）P(x∃ｘ）
﹁P（ｘ)
﹁ (∃x）P（ｘ) ⇔ （∀x)￢P(x) 将每个否定符号“﹁”移到仅靠谓词得位置,使得每个否定符号最多只作用于一个谓词上。
（3) 对变元标准化 在一个量词得辖域内,把谓词公式中受该量词约束得变元全部用另外一个没有出现过得任意变元代替，使不同量词约束得变元有不同得名字．
（4) 化为前束范式 化为前束范式得方法:把所有量词都移到公式得左边,并且在移动时不能改变其相对顺序。
(5) 消去存在量词 (6) 化为Ｓkoleｍ标准形
对上述前束范式得母式应用以下等价关系
P∨(Ｑ∧Ｒ) ⇔ (P∨Q)∧（P∨Ｒ) (7) 消去全称量词 (８) 消去合取词 在母式中消去所有合取词,把母式用子句集得形式表示出来。其中,子句集中得每一个元素都就是一个子句。
（9) 更换变量名称 对子句集中得某些变量重新命名,使任意两个子句中不出现相同得变量名。
四、实验结果及代码
//化简子句集得九步法演示 //作者:刘少鹏 /／时间:2017、5 #iｎclude<iostream> ＃iｎclude<sstｒeam> #inｃlude〈ｓtack〉 #iｎcludｅ〈qｕeue> ｕsｉng naｍespａｃe stｄ; //一些函数得定义 vｏｉd initＳtring(strinｇ &ini);//初始化 sｔring dｅl_inlclue(sｔrｉng ｔｅmp）；/／消去蕴涵符号 ｓtring deｃ_neｇ_raｎｄ（sｔring tｅmp);／／减少否定符号得辖域 strinｇ stａndard＿var(ｓtriｎg ｔｅｍｐ)；//对变量标准化 strinｇ ｄeｌ_eｘiｓｔs(striｎg teｍp）；／/消去存在量词 strｉng ｃonｖerｔ_tｏ_ｆront(sｔｒinｇ ｔemp）;//化为前束形 ｓｔrinｇ convert_ｔo_aｎd(string temp);/／把母式化为合取范式 string deｌ＿all(ｓtring ｔemp);/／消去全称量词 sｔring deｌ_anｄ(ｓtrｉng tｅmｐ）;//消去连接符号合取% ｓｔriｎg changｅ_ｎame(ｓtring ｔemp);/／更换变量名称
ﻩ
ﻩﻩ ／/辅助函数定义 bｏol ｉsAｌbuｍ（ｃhａr tｅmp);//就是字母 stｒing deｌ＿null_brａckeｔ（string ｔemp）;//删除多余得括号 sｔrinｇ del_bｌank(strｉnｇ temp)；/／删除多余得空格 void cｈecｋLegal(strinｇ temｐ);//检查合法性 ｃhａr numAfｅctＣhａr（iｎt tｅmp）；/／数字显示为字符
ﻩ
ﻩﻩ //主函数
voiｄ maｉｎ() ｛ —－—-----———示演法步九集句子求—－----————-－-－——-—” 〈< ｔuocﻩ—－----———--—” <＜ ｅndl;
;)"Ａ0 roloc”(mｅtsyｓﻩ/／ ;")y（P(~%）y，ｘ（Q" = ｎgirｏﻩ// ；”)Ｐ〉)y(P（)x（” = ngirｏﻩ// ;”）x(ｙ）x#(~” = ngiroﻩ// ;”））x（b！x)x（（~” = ｎｇｉrｏﻩ //origｎ = "～(x!ｙ)”;
//oriｇn ＝ "~（~a(ｂ)）";
strｉng orｉgn, ｔｅｍp;
chaｒ manｄ, mand0, ｍand１， mand2, mａnｄ3， mand4， mａnd5，
mand6, mａnｄ７， ｍand8, mａnd9, maｎｄ10; ＝=＝=＝＝=＝===＝====＝＝＝====＝＝==＝=＝=＝==＝=＝=========＝=＝==＝／/ﻩ====＝========＝=＝＝====＝===
cｏｕt 〈〈 ”请输入(Y/y)初始化谓词演算公式＂ ＜＜ endl；
ｃｉn >〉 mａnd;
if (mａnd == ’y’ || ｍaｎd =＝ ’Y＇）
;）ｎgiro(gnｉrtStiniﻩ esｌeﻩ
；）0(tｉxeﻩ＝===========＝＝========＝=====＝===＝=＝==＝=＝==＝================／/ﻩ=====＝==＝====＝==＝=
cout 〈〈 ”请输入（Y/ｙ)消除空格" 〈< endl；
cｉn 〉＞ manｄ0;
)"Y’ ＝= 0ｄnａm ｜| "y’ ＝= 0dnam（ ｆiﻩ {ﻩ
/／dｅl_bｌanｋ(orign)；/／ｕnｄｏnｅ
ｃｏｕt <＜ ＂消除空格后就是" 〈〈 ｅndｌ
<〈ﻩ
；ldnｅ <〈 ngiroﻩ }ﻩ eｌse
;）０（tiｘeﻩ //=＝========＝＝==＝＝==＝=＝====＝＝=＝=＝=====＝=＝==＝＝==＝==＝＝=========＝＝=====＝＝=＝==＝====
;ldnｅ 〈＜ ”项涵蕴去消）y/Y(入输请” <〈 tuocﻩ cin >〉 manｄ1；
if （mａｎd１ == ＇ｙ’ ｜| mand1 == "Y’）
{ﻩ
orｉgn = del_iｎｌclue（orｉgn);
lｄｎe <〈 ”是就后项涵蕴去消＂ 〈〈 tuoｃﻩ ＜<ﻩ;ｌdne << ｎgiｒoﻩ ｝
else
exit(0）；
/／=＝===＝=＝＝=＝====＝====＝===＝======＝==＝＝=＝＝==＝====＝=========＝=＝＝===============＝＝
;ｌdｎe ＜< "域辖得号符定否少减）ｙ/Y(入输请" << tuoｃﻩ cｉn >> mand2；
）’Y＇ ＝= 2dnam || ’ｙ" ＝= 2ｄnam( fiﻩ {ﻩ
oｄﻩ {ﻩﻩﻩ
；nｇiro = pmeｔﻩﻩ;）ngirｏ(dnar＿gen_ｃed = nｇiｒoﻩ ｝
;）ｎgirｏ =! ｐmet( ｅlihwﻩ lｄｎｅ 〈< ”是就后域辖得号符定否少减” <〈 ｔuocﻩﻩ <〈
；ldｎe 〈＜ nｇｉrｏﻩﻩ }
eslｅﻩ
ｅxｉt（0）； ＝======＝==＝=＝=＝===＝=＝====＝========＝========＝=＝==＝＝======＝＝／/ﻩ＝==============＝=== ﻩ coｕt 〈〈 ”请输入(Y/y）对变量进行标准化” <＜ endl；
cin >＞ maｎｄ3；
if (maｎd3 == "y＇ ｜| mａnd３ == ＇Y＇)
{ﻩ
;)ngiro(rａv_dradnats = ngirｏﻩ
coｕt 〈〈 ＂对变量进行标准化后就是” 〈〈 endｌ
<〈 ;ldnｅ ＜＜ nｇiｒoﻩﻩ }ﻩ eｓleﻩ
;)0（tｉxeﻩ＝=＝====================＝=====＝=＝＝=＝＝==＝==＝＝==＝==＝＝====＝==／／ﻩ=＝=======＝=＝=＝====== ﻩ cout <＜ ”请输入(Y／ｙ)消去存在量词" 〈< endl;
；４dｎａm 〉＞ nicﻩ )"Ｙ" == ４dnam || "y" ＝= ４dnam( fiﻩ {
orign ＝ ｄel＿ｅxｉｓts(oriｇn);
ldne <〈 ＂)数函 melokS 个一是就）ｘ(ｇ = ｗ(是就后词量在存去消” 〈〈 tuocﻩ
ﻩ 〈< orign ＜〈 ｅｎdl;
}
else
；）０（tixeﻩ /／==＝=＝＝======＝===========＝==＝=====＝==＝=＝===============＝===========＝==＝======= ﻩ
ｃouｔ << ＂请输入（Y/y）化为前束形" <＜ endl；
cin 〉> mａnｄ5;
)’Y’ ＝＝ 5dnaｍ |｜ "y＇ == ５dnam（ fｉﻩ ｛
;）nｇiｒo(tｎorf_ot_trｅvnｏc ＝ ngirｏﻩ
ｃｏut <〈 ”化为前束形后就是” <〈 eｎdｌ
＜<
；ｌｄne 〈< ngiroﻩﻩ ｝ﻩ elsｅ
；)0(tｉｘeﻩ //＝=＝=======＝=＝＝===＝====＝===＝=＝=====＝==＝========＝==＝==＝========＝=＝==＝＝===＝===== ﻩ cｏuｔ 〈< ”请输入(Y/y）把母式化为合取方式" 〈< enｄｌ；
;6ｄnam >＞ ｎｉｃﻩ )"Ｙ’ == ６dnａｍ || "ｙ＇ == ６dnaｍ（ ｆiﻩ {ﻩ
；)ngiro(ｄna_ｏｔ_treｖnoc = ｎgｉroﻩ
ｌdne 〈〈 "是就后式方取合为化式母把" ＜〈 ｔｕocﻩ 〈<ﻩ
;lｄｎe 〈< ngiｒoﻩ }
elｓe
;)0（ｔixeﻩ=======＝===＝＝===＝=＝===＝======＝===＝=======＝==＝====＝====＝==＝=/／ﻩ＝＝＝==＝=＝＝=========
cｏut 〈< ＂请输入（Y/y)消去全称量词” 〈〈 endｌ；
;7dnam >〉 nｉcﻩ if (mand7 == ’y’ || mand7 == "Ｙ’)
{
;）nｇiro(lla＿led = ngｉroﻩ
ldnｅ << "是就后词量称全去消” ＜＜ tｕocﻩ
<< ；lｄｎe 〈< ngiｒoﻩﻩ ｝ﻩ eslｅﻩ ;）０（tixeﻩﻩ /／=========＝=＝===========＝===========＝=====＝＝＝＝====＝========＝==＝======＝=＝==＝=＝=
coｕt 〈< ”请输入（Y/ｙ)消去连接符号” 〈〈 eｎｄl;
;8dnaｍ 〉〉 nicﻩ if （ｍａnd8 == ’ｙ" || mand8 ＝= ’Y"）
{
；)ngiｒo(dna＿led = nｇiroﻩ
ｃout 〈< "消去连接符号后就是” <〈 eｎdl
〈<ﻩ；lｄne 〈〈 ngiroﻩ ｝
eslｅﻩ
;）０(tｉxeﻩ＝＝==＝==＝=＝=＝==＝====＝==========＝====＝=======＝=＝＝=＝====＝=/／ﻩ====＝＝=＝=＝======＝==＝=＝
cout 〈〈 "请输入（Y／ｙ)变量分离标准化” ＜〈 ｅndｌ;
；9dnam >> nｉcﻩ )’Y’ =＝ 9dnａｍ || "y" == 9dｎam( fiﻩ {ﻩ
；)ｎｇiｒo（eman_eｇnahｃ = nｇiｒｏﻩ
lｄne 〈〈 "）x 量变替代 3x，２x,1ｘ(是就后化准标离分量变＂ 〈〈 tuoｃﻩ
〈＜ ；ldｎe 〈〈 ngirｏﻩﻩ }ﻩ else
;）0（ｔixeﻩ ／/＝＝＝＝==＝===＝==＝==＝＝====＝===＝========＝=＝======＝=========＝==＝===＝==＝＝＝＝======== --－——－-—－-—毕完－-—-—---—---—————-－－————-" ＜＜ tuocﻩ－—-————-——-—－—-—-—-—--—－＂ ＜＜ eｎdl;
couｔ 〈＜ "（请输入 Y/y）结束” ＜＜ enｄl；
odﻩ {
} ;）)(rａhctｅg == ’Y" |｜ )(rahcteｇ == ’ｙ’( elihｗﻩ ｅxit(0); } void inｉtＳtrinｇ（sｔｒｉng ＆ini）
{
;bdｎam ，aｄnam rａhcﻩ ；ldne 〈〈 "式公词谓得换转要需所您入输请” 〈< tuocﻩ coｕｔ <〈 "需要查瞧输入帮助（Y／N)? ” <〈 ｅndl；
cin >〉 ｍaｎda;
)"y’ =＝ adnａｍ ｜| ’Y’ == adｎam（ fiﻩ ne 〈〈 ”，＃为词量在存，为词量称全，〉为号符涵蕴时入输定规程例本" 〈〈 tuoｃﻩｄl ” 〈<< ”母字个一用请名数函，) 、 （为别分号括右左，%为取合,!为取吸,~为反取ﻩﻩ〈 ｅndl;
;ldne <〈 "义定自户用否是就择选)n/y(入输请” <〈 tuoｃﻩ cｉn 〉＞ maｎdb；
if (manｄb == ’Ｙ＇ ｜| ｍandb == "y＇）
;ini >〉 ｎｉcﻩ eｓleﻩ
ini ＝ ”(x)(Ｐ(ｘ)＞((ｙ)（Ｐ(y)>Ｐ(f（x, y))）%～(y)（Q（x,y）〉P(ｙ））))＂；
cｏut 〈＜ "原始命题就是” <＜ eｎdｌ
〈< iｎi 〈〈 endｌ; }
string del＿ｉnlclue（sｔriｎg temp)//消去>蕴涵项 {
//a〉b 变为~a!b
char cteｍp［1０0］ ＝ ｛ ”” }；
;tuptuｏ gnirtsﻩ int length = tｅmp、lengtｈ();
;0 = glaf ,0 = ｔekcarb_thｇir ,０ = i tnｉﻩ stack<char〉 stacｋ1， stａck2, ｓtack3;
；））(rts_c、pmet ,pmｅtc（s_ｙpcrtsﻩ )1 - htgneｌ =〈 i ＆＆ ’０\" =！
]i[pｍｅtｃ（ ｅlihｗﻩ {ﻩ
sｔａｃk1、push(ctｅｍp[ｉ］）；
if (’〉＇ ＝= ctemp[i + 1]）//如果就是 a〉ｂ则用~a！b 替代
｛
;1 = glafﻩﻩﻩ出弹］ｉ［pmetｃ把则母字是就果如/／）)］i[ｐmｅtc（mｕblAsｉ( fiﻩ {ﻩ ﻩ
ﻩ
ｓtack１、poｐ（）；
ﻩ
ｓtack1、pusｈ（’~’）;
ﻩﻩ staｃk1、push(ctemｐ[i］);
;)"！’(hｓup、1kcaｔｓﻩﻩ
ﻩ i ＝ ｉ ＋ 1;
｝ﻩﻩ
ﻩ eｌse if (’）" == ctemp［i])
{ﻩ ﻩ
;++tｅkｃarｂ_tｈgiｒﻩ
ﻩ
do
{ ﻩﻩﻩ
ｉｆ （’（’ == ｓtack1、top（）) ﻩﻩﻩﻩ
;－－ｔｅkcarb＿thgiｒﻩ ﻩ ﻩ
stａck3、pｕsｈ(stack１、toｐ（）);
；）(pｏp、1ｋcatsﻩﻩ
ﻩﻩ ｝ whｉle ((ｒｉｇｈt_bracｋeｔ ！＝ 0));
ﻩ
;）)（pot、1kcats（hｓuｐ、3ｋcatｓﻩﻩﻩ
;)(pｏp、1kcａtsﻩﻩﻩ
;）"～’(hｓuｐ、1kcaｔｓﻩ
ﻩ
))(ｙｔpｍe、３kcats!( ｅｌihwﻩ
ﻩﻩ {
ﻩ
;))(pｏｔ、３ｋｃaｔs（hsup、１kｃaｔｓﻩ
ﻩ
；）(pop、3kcatsﻩﻩ
}ﻩﻩ
；)"!’(hsup、１ｋｃａｔsﻩﻩ ﻩ；1 + i ＝ ｉﻩ } ﻩﻩ
｝
；++ｉﻩﻩ }ﻩ wｈｉｌe （！sｔack１、eｍｐty())
{
sｔaｃk2、puｓh（stack１、toｐ());
;)（ｐop、1kcaｔｓﻩﻩ ｝ﻩ ））（ytpｍｅ、2kcatｓ!( ｅlｉｈwﻩ {
;)(pot、2kcａts =+ ｔｕｐtuoﻩﻩ
；)（pop、２kcatsﻩ }ﻩ )1 == ｇｌaf( fiﻩ
;tupｔｕｏ nruterﻩ eｓleﻩ ；pmet nｒｕterﻩﻩ} string dec＿ｎeg_ranｄ(stｒing ｔemp)//减少否定符号得辖域 ｛
ｃhaｒ ctemp[100], teｍpc；
;ｔｕptuo gnｉrtsﻩ int ｆlaｇ2 = ０;
;)(htgneｌ、ｐｍｅt = htｇnel ,０ = ｔekcaｒb_tfel ,0 = i tniﻩ ;2kcats ,1kcaｔs >ｒahc〈 ｋcatsﻩ ｑueuｅ <chａr〉 ｑuｅue1；
中组数符字到制复//；))（ｒtｓ＿c、ｐｍeｔ ,pmetc(ｓ_ypcrtsﻩ wｈile （ｃtemp[ｉ] !＝ "\0’ &＆ ｉ 〈= lｅngth － 1）
{
；)]i[pmetｃ(ｈｓuｐ、1kｃａｔｓﻩﻩ 做不都么什则否~是就果如／／）’~" == ]i[pmeｔc（ fiﻩﻩ ｛ﻩﻩ
；]２ + i[ｐmetc ＝ of ｒahcﻩﻩ
做不都么什则否,(是就果如/／）’(" == ］1 + i[pmetc( ｆiﻩ
ﻩ ｛
ﻩ
iｆ (ｆo ＝= "’ ｜｜ ｆo == "＃’）/／如果就是全称量词
{ﻩﻩﻩ
ﻩ
;1 = ２galfﻩﻩ
ﻩ
ﻩ i+＋;
ﻩ;)（poｐ、1ｋｃatsﻩ
ﻩ
;)]i［pmetｃ（hsup、１kcatsﻩ
ﻩﻩ
)"’ ＝＝ ｏf（ ｆｉﻩ
ﻩﻩ
ﻩ sｔack1、push(’#");
ﻩ
esleﻩ
ﻩﻩﻩ；）’’(hｓup、1kｃａtｓﻩ
；）]2 + i［ｐｍetc(hsup、1kcatｓﻩ
；)]3 ＋ ｉ[pmetc(hsuｐ、1kcaｔsﻩﻩﻩﻩﻩ
；)’（＇(hｓup、１kｃatsﻩ
ﻩ;)’~’（hｓｕp、1kcatｓﻩ
ﻩ
iｆ (isAｌbｕm（ctｅmp［i + 4]）)
ﻩﻩ
｛ﻩ
ﻩﻩ
;)］4 + i［pｍetc（ｈsｕp、1kcａts...
上一篇：超声实验报告
下一篇：数据库实验报告,(3)