当前位置： 首页 > article >正文

人工智能原理实验一：知识的表示与推理实验

article 2024/12/24 11:38:45

一、实验目的

本实验课程是计算机、智能、物联网等专业学生的一门专业课程，通过实验，帮助学生更好地掌握人工智能相关概念、技术、原理、应用等；通过实验提高学生编写实验报告、总结实验结果的能力；使学生对智能程序、智能算法等有比较深入的认识。本实验通过不同知识的表达与推理问题，强化学生对知识表示的了解和应用，为人工智能后续环节的课程奠定基础。

二、基本要求

1、实验前，复习《人工智能》课程中的有关内容。

2、准备好实验数据。

3、编程或验证需要独立完成，程序应加适当的注释。

4、完成实验报告。

三、实验软件

使用C或C++（Visual studio平台等）,或其它语言,如matlab或Python。

四、实验内容：

（一）猴子摘香蕉问题

利用一阶谓词逻辑求解猴子摘香蕉问题：房内有一个猴子，一个箱子，天花板上挂了一串香蕉，其位置如图1所示，猴子为了拿到香蕉，它必须把箱子搬到香蕉下面，然后再爬到箱子上。请定义必要的谓词，列出问题的初始化状态（即下图所示状态），目标状态（猴子拿到了香蕉，站在箱子上，箱子位于位置b）。（附加：从初始状态到目标状态的谓词演算过程。） 

1、定义描述环境状态的谓词。

AT(x,w)：x在w处，个体域：x?{monkey}，w?{a,b,c,box}；

HOLD(x,t)：x手中拿着t，个体域：t?{box,banana}；

EMPTY(x)：x手中是空的；

ON(t,y)：t在y处，个体域：y?{b,c,ceiling}；

CLEAR(y)：y上是空的；

BOX(u)：u是箱子，个体域：u?{box}；

BANANA(v)：v是香蕉，个体域：v?{banana}；

2、使用谓词、连结词、量词来表示环境状态。

问题的初始状态可表示为：So：AT(monkey,a)->EMPTY(monkey)->ON(box,c)->ON(banana,ceiling)->CLEAR(b)->BOX(box)->BANANA(banana)

要达到的目标状态为：Sg：AT(monkey,box)->HOLD(monkey,banana)->ON(box,b)->CLEAR(ceiling)->CLEAR(c)->BOX(box)->BANANA(banana)

3、从初始状态到目标状态的转化, 猴子需要完成一系列操作, 定义操作类谓词表示其动作。

WALK(m,n)：猴子从m走到n处，个体域：m,n?{a,b,c}；

CARRY(s,r)：猴子在r处拿到s，个体域：r?{c,ceiling}，s?{box,banana}；

CLIMB(u,b)：猴子在b处爬上u；

这3个操作也可分别用条件和动作来表示。条件直接用谓词公式表示，是为完成相应操作所必须具备的条件；当条件中的事实使其均为真时，则可激活操作规则，于是可执行该规则中的动作部分。动作通过前后状态的变化表示，即通过从动作前删除或增加谓词公式来描述动作后的状态。

4、按照行动计划, 一步步进行状态替换, 直至目标状态

AT(monkey,a)?EMPTY(monkey)?ON(box,c)?ON(banana,ceiling)?CLEAR(b)?BOX(box)?

BANANA(banana)

AT(monkey,c)?EMPTY(monkey)?ON(box,c)?ON(banana,ceiling)?CLEAR(b)?BOX(box)?

BANANA(banana)

AT(monkey,c)?HOLD(monkey,box)?ON(banana,ceiling)?CLEAR(b)?CLEAR(c)?BOX(box)?

BANANA(banana)

AT(monkey,b)?HOLD(monkey,box)?ON(banana,ceiling)?CLEAR(b)?CLEAR(c)?BOX(box)?

BANANA(banana)

AT(monkey,box)?EMPTY(monkey)?ON(box,b)?ON(banana,ceiling)?CLEAR(c)?BOX(box)?

BANANA(banana)

AT(monkey,box)?HOLD(monkey,banana)?ON(box,b)?CLEAR(ceiling)?CLEAR(c)?BOX(box)?

BANANA(banana)（目标得解）

猴子行动的规则序列是：WALK(a,c)→CARRY(c,box)→WALK(c,b)→CLIMB(box,b)→

CARRY(banana,ceiling)

5、参考代码：

#include <stdio.h>
struct State
{
	int monkey; /*-1:Monkey at A;0: Monkey at B;1:Monkey at C;*/
    int box; /*-1:box at A;0:box at B;1:box at C;*/
    int banana; /*Banana at B,Banana=0*/
    int monbox; /*-1: monkey on the box;1: monkey  the box;*/
};
struct State States [150];
char* routesave[150];
/*function monkeygoto,it makes the monkey goto the other place*/
void monkeygoto(int b,int i)
{  
	int a;
	a=b;
	if (a==-1)
	{
		routesave[i]="Monkey go to A";
		States[i+1]=States[i];
		States[i+1].monkey=-1;
	}
	else if(a==0)
	{
		routesave[i]="Monkey go to B";
		States[i+1]=States[i];
		States[i+1].monkey=0;
	}
	else if(a==1)
	{
		routesave[i]="Monkey go to C";
		States[i+1]=States[i];
		States[i+1].monkey=1;
	}
	else
    {
		printf("parameter is wrong");
	}
}
/*end function monkeyygoto*/
/*function movebox,the monkey move the box to the other place*/
void movebox(int a,int i)
{  
	int B;
	B=a;
	if(B==-1)
	{
		routesave[i]="monkey move box to A";
		States[i+1]=States[i];
		States[i+1].monkey=-1;
		States[i+1].box=-1;
	}
	else if(B==0)
	{
		routesave[i] = "monkey move box to B";
		States[i+1]=States[i];
		States[i+1].monkey=0;
		States[i+1].box=0;
	}
	else if(B==1)
	{
		routesave[i] = "monkey move box to C";
		States[i+1]=States[i];
		States[i+1].monkey=1;
		States[i+1].box=1;
	}
	else
	{
		printf("parameter is wrong");
	}
}
/*end function movebox*/
/*function climbonto,the monkey climb onto the box*/
void climbonto(int i)
{
	routesave[i]="Monkey climb onto the box";
	States[i+1]=States[i];
	States[i+1].monbox=1;
}
/*function climbdown,monkey climb down from the box*/
void climbdown(int i)
{  
	routesave[i]="Monkey climb down from the box";
	States[i+1]=States[i];
	States[i+1].monbox=-1;
}
/*function reach,if the monkey,box,and banana are at the same place,the monkey reach banana*/
void reach(int i)
{   
	routesave[i]="Monkey reach the banana";
}
/*output the solution to the problem*/
void showSolution(int i)
{
    int c;
    printf ("%s \n", "Result to problem:");
    for(c=0; c<i+1; c++)
    {
		printf ("Step %d : %s \n",c+1,routesave[c]);
    }
    printf("\n");
}
/*perform next step*/
void nextStep(int i)
{
	int c;
    int j;
    if(i>=150)
    {
		printf("%s  \n", "steplength reached 150,have problem ");
        return;
    }
	for (c=0; c<i; c++) /*if the current state is same to previous,retrospect*/
    {
		if(States[c].monkey==States[i].monkey&&States[c].box==States[i].box&&States[c].banana==States[i].banana&&States[c].monbox==States[i].monbox)
        {
			return;
        }
    }
    if(States[i].monbox==1&&States[i].monkey==0&&States[i].banana==0&&States[i].box==0)
    {
		showSolution(i);
		printf("Press any key to continue \n");
		getchar();/*to save screen for user,press any key to continue*/
		return;
	}  
	j=i+1;    
	if(States[i].monkey==0)
	{ 
		if(States[i].box==0)
		{
			if(States[i].monbox==-1)
			{
				climbonto(i);
				reach(i+1);
				nextStep(j);
				/*monkeygoto(-1,i);
				nextStep(j);
				monkeygoto(0,i);
				nextStep(j);
				movebox(-1,i);
				nextStep(j);
				movebox(0,i);
				nextStep(j);*/
			}
			else
			{
				reach(i+1);
				nextStep(j);
				/*climbdown(i);
				nextStep(j);*/
			}
		}
		else if(States[i].box==1)
		{
			/*monkeygoto(-1,i);
			nextStep(j);*/
			monkeygoto(1,i);
			nextStep(j);
			movebox(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
		else /*box==-1*/
		{
			monkeygoto(-1,i);
			nextStep(j);
			movebox(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
    }
	/*end if*/
	if(States[i].monkey==-1)
    { 
		if(States[i].box==-1)
		{
			if(States[i].monbox==-1)
			{ 
				movebox(0,i);
				nextStep(j);
				climbonto(i);
				reach(i+1);
				nextStep(j);
			}
			else
			{
				climbdown(i);
				nextStep(j);
				movebox(0,i);
				nextStep(j);
				climbonto(i);
				reach(i+1);
				nextStep(j);
			}
		}
		else if(States[i].box==0)
		{ 
			monkeygoto(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
		else
		{
			monkeygoto(1,i);
			nextStep(j);
			movebox(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
	}
	/*end if*/
	if(States[i].monkey==1)
    {	
		if (States[i].box==1)
		{
			if(States[i].monbox==-1)
			{     
				movebox(0,i);
				nextStep(j);
				climbonto(i);
				reach(i+1);
				nextStep(j);
			}
			else
			{
				climbdown(i);
				nextStep(j);
				movebox(0,i);
				nextStep(j);
				climbonto(i);
				reach(i+1);
				nextStep(j);          
			}
		}
		else if(States[i].box==-1)
		{        
			monkeygoto(-1,i);
			nextStep(j);
			movebox(0,i);
			nextStep(j);
 			movebox(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
		else
		{
			monkeygoto(0,i);
			nextStep(j);
			movebox(0,i);
			nextStep(j);
			climbonto(i);
			reach(i+1);
			nextStep(j);
		}
    }
	/*end if*/
}/*end nextStep*/
int main()
{
    States[0].monkey=-1;
    States[0].box=1;
    States[0].banana=0;
    States[0].monbox=-1;
    nextStep(0);
}

（二）传教士(牧师)与野人问题

问题描述：

有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数(除非牧师人数为0)，且假定野人与牧师都会划船，试设计一个算法，确定他们能否渡过河去，若能，则给出小船来回次数最少的最佳方案。

实验步骤：

输入：牧师人数(即野人人数)：n；小船一次最多载人量：c。  

输出：若问题无解，则显示Failed，否则，显示Successed输出所有可行方案，并标注哪一组是最佳方案。用三元组(X1, X2, X3)表示渡河过程中的状态。并用箭头连接相邻状态以表示迁移过程：初始状态->中间状态->目标状态。   

例：当输入n=2，c=2时，输出：221->200->211->010->021->000；  

其中：X1表示起始岸上的牧师人数；X2表示起始岸上的野人人数；X3表示小船现在位置(1表示起始岸，0表示目的岸)。

要求：写出算法的设计思想和源程序，并有用户界面实现人机交互（控制台或者窗口都可以），进行输入和输出结果，如：

Please input n: 2         Please input c: 2

Optimal Procedure: 221->200->211->010->021->000

Successed or Failed?: Successed     

五、学生实验报告要求

（1）对于猴子摘香蕉问题根据自己编写代码或者参考代码，用不同的初始状态测试代码，记录每种初始状态下的输出结果，并对每个结果进行解释。

（2）完善猴子摘香蕉问题参考代码，参考代码中有什么问题？应该如何修改会更好。

问题：

1. 数组索引和函数调用：

   使用数组索引i访问和更新状态。确保数组索引在范围内，以避免潜在的内存问题。

   考虑将状态数组封装在结构体内部或将其作为参数传递给函数，而不是使用全局数组。

2. 字符串赋值：

   避免直接将字符串赋值给 routesave[i]，例如 routesave[i] = "Monkey go to A";，使用strcpy或类似的函数进行字符串赋值，以避免潜在的问题。

3. 未使用的变量：

   movebox函数中声明了变量int B;但未使用。移除它以避免混淆。

4. 递归函数：

   nextStep 函数是递归的，它一直调用自身。这可能会导致大量步骤时发生堆栈溢出。考虑使用迭代方法，或者根据需要增加堆栈大小。

5. 内存管理：

   代码使用一个固定大小的数组 (States[150]) 存储状态。如果状态数量不能事先确定，考虑使用动态内存分配或其他数据结构。

（3）传教士(牧师)与野人问题，写出状态表示的数据结构，还有每种解的状态迁移图示。

struct State {
    int m;//传教士
    int c;//野人
    int dep;//已划船次数
    int boat;//左岸是否有船
    bool friend operator <(const struct State& a, const struct State& b)//为实现自定义类型的set提供排序规则
    {
        return a.dep < b.dep;//升序排序
    }
};

例：n=2,c=2时：

1.(2,2,1) -> (2,0,0) -> (2,1,1) -> (0,1,0) -> (0,2,1) -> (0,0,0)

2.(2,2,1) -> (2,0,0) -> (2,1,1) -> (0,1,0) -> (1,1,1) -> (0,0,0)

3.(2,2,1) -> (1,1,0) -> (2,1,1) -> (0,1,0) -> (0,2,1) -> (0,0,0)

4.(2,2,1) -> (1,1,0) -> (2,1,1) -> (0,1,0) -> (1,1,1) -> (0,0,0)

（4）写出传教士(牧师)与野人问题的程序清单(语言不限)

#include<iostream>
#include<set>
#include<vector>
using namespace std;

int n, c;//传教士的人数及船的载客量
int min_deep = INT_MAX;//船的最小来回次数
int path = 0;//可达路径的数量

struct State {
    int m;//传教士
    int c;//野人
    int dep;//已划船次数
    int boat;//左岸是否有船
    bool friend operator <(const struct State& a, const struct State& b)//为实现自定义类型的set提供排序规则
    {
        return a.dep < b.dep;//升序排序
    }
};
set<State> Set;//自定义类型State实现set
vector<vector<State>> res;//保存所有路径

//判断状态是否已经在当前路径中，避免重复加入
bool isExist(State next)
{
    for (auto it = Set.begin(); it != Set.end(); it++)
        if (it->m == next.m && it->c == next.c && it->boat == next.boat)
            return true;
    return false;
}
//输出路径
void output()
{
    for (int i = 0; i < res.size(); i++)
    {
        if (res[i].size() == min_deep + 1)//判断是否为最优路径
            cout << "optimal" << endl;
        cout << "Solution" << i + 1 << endl;
        for (int j = 0; j < res[i].size(); j++)//依次输出路径上的各个状态
            cout << "(" << res[i][j].m << "," << res[i][j].c << "," << res[i][j].boat << ")" << endl;
        cout << endl;
    }
}
//用深度优先进行搜索
void dfs(State s)
{
    Set.insert(s);//加入当前路径的集合中(已按状态的先后顺序排序）
    if (s.m == 0 && s.c == 0)//目标状态
    {
        if (s.dep < min_deep)//记录最短路径的划船次数
            min_deep = s.dep;
        path++;
        vector<State> v(Set.begin(), Set.end());
        res.push_back(v);//保存该路径
        Set.erase(--Set.end());//已达终点，进行回退
        return;
    }
    if (s.boat == 1)//左岸
    {
        for (int i = c; i >= 1; i--)//船载i从左往右划
        {
            if (i > s.m + s.c)//i多于左岸的总人数
                continue;
            for (int j = i; j >= 0; j--)//船上有j个野人
            {
                if (j > s.c || i - j > s.m)//多于左岸传教士、野人的实际人数
                    continue;
                if (j != i && j > i - j)//船上传教士的人数少于野人的人数
                    continue;
                if (s.m - (i - j) != 0 && s.m - (i - j) != n && s.m - (i - j) != s.c - j)//左岸剩下的传教士与野人的人数不相等
                    continue;
                State next;
                next.boat = 0;
                next.m = s.m - (i - j);
                next.c = s.c - j;
                next.dep = s.dep + 1;
                if (!isExist(next))//判断当前路径是否存在该状态
                    dfs(next);
            }
        }
    }
    else//右岸
    {
        for (int i = c; i >= 1; i--)//船载i个人从右往左划
        {
            if (i > (n - s.m) + (n - s.c))//i多于右岸的总人数
                continue;
            for (int j = i; j >= 0; j--)//船上有j个野人
            {
                if (j > n - s.c || i - j > n - s.m)//多于右岸传教士、野人的实际人数
                    continue;
                if (j != i && j > i - j)//船上野人的数量大于传教士的数量
                    continue;
                if (n - s.m - (i - j) != 0 && n - s.m - (i - j) != n && n - s.m - (i - j) != n - s.c - j)//右岸剩下的传教士人数与野人不相等
                    continue;
                State next;
                next.boat = 1;
                next.m = s.m + (i - j);
                next.c = s.c + j;
                next.dep = s.dep + 1;
                if (!isExist(next))//判断当前路径是否存在该状态
                    dfs(next);
            }
        }
    }
    Set.erase(--Set.end());//无路可走，进行回退
}

int main()
{
    cout << "请输入传教士（野人）人数:";
    cin >> n;
    cout << endl;
    cout << "请输入船的载人量：";
    cin >> c;
    State start;//初始状态
    start.m = start.c = n;
    start.boat = 1;
    start.dep = 0;
    dfs(start);
    cout << "Successed or Failed?:";
    if (path == 0)
        cout << "failed" << endl;
    else
    {
        cout << "Successed" << endl;
        output();
        cout << "共有" << path << "条路径。" << endl;
        cout << "min_deep=" << min_deep << endl;
    }
}

（5）实验结果讨论。

这是n=2,c=2的情况，共有四种情况的最短路径，最短路径为5

这是n=3,c=2的情况，共有四种情况的最短路径，最短路径为11

3 汉诺塔问题

汉诺塔问题来自一个古老的传说：在世界刚被创建的时候有一座钻石宝塔（塔A),其上有64个金碟。所有碟子按从大到小的次序从塔底堆放至塔顶。紧挨着这座塔有另外两个钻石宝塔（塔B和塔C）。从世界创始之日起，婆罗门的牧师们就一直在试图把塔A上的碟子移动到塔C上去，其间借助于塔B的帮助。每次只能移动一个碟子，任何时候都不能把一个碟子放在比它小的碟子上面。当牧师们完成任务时，世界末日也就到了。

  采用问题归约法把汉诺塔问题分成以下三个步骤实现：

  1. 将塔A上的n-1个碟子借助塔C先移到塔B上
  2. 把塔A上剩下的一个碟子移到塔C上
  3. 把n-1个碟子从塔B借助于塔A移到塔C上

实验要求： 

  1. 让盘子数从2 开始到7进行实验，记录程序运行时间和递归调用次数。

2.画出盘子数n和运行时间t 、递归调用次数m的关系图，并进行分析

分析：

运行时间 vs 盘子数（n）： 通常来说，汉诺塔问题的解决时间呈指数增长。图表中应该看到一个指数曲线，显示随着盘子数的增加，解决问题所需的时间迅速增加。但是运行时间都太短了，看不出明显趋势。

递归调用次数 vs 盘子数（n）： 递归调用次数也是指数级增长的，因为每增加一个盘子，递归调用次数就翻倍。这与汉诺塔问题的递归性质相一致。

在解决类似指数级增长问题时，递归算法可能会面临的性能挑战。

实验代码：

import time

def hanoi(n, source, target, auxiliary):
    global recursive_calls
    if n > 0:
        recursive_calls += 1
        hanoi(n - 1, source, auxiliary, target)
        # 移动盘子
        # print(f"Move disk {n} from {source} to {target}")
        hanoi(n - 1, auxiliary, target, source)

def run_experiment(n):
    global recursive_calls
    recursive_calls = 0
    start_time = time.time()
    hanoi(n, 'A', 'C', 'B')
    end_time = time.time()
    execution_time = end_time - start_time
    return execution_time, recursive_calls

# 实验
results = []
for i in range(2, 8):
    time_taken, calls_made = run_experiment(i)
    results.append((i, time_taken, calls_made))

# 打印结果
print("n\tTime(s)\tRecursive Calls")
for result in results:
    print(f"{result[0]}\t{result[1]:.6f}\t{result[2]}")

import matplotlib.pyplot as plt

def plot_results(results):
    n_values = [result[0] for result in results]
    time_values = [result[1] for result in results]
    calls_values = [result[2] for result in results]

    # Plotting time vs n
    plt.figure(figsize=(10, 5))
    plt.subplot(1, 2, 1)
    plt.plot(n_values, time_values, marker='o')
    plt.title('Time vs Number of Disks')
    plt.xlabel('Number of Disks (n)')
    plt.ylabel('Time (s)')

    # Plotting recursive calls vs n
    plt.subplot(1, 2, 2)
    plt.plot(n_values, calls_values, marker='o', color='r')
    plt.title('Recursive Calls vs Number of Disks')
    plt.xlabel('Number of Disks (n)')
    plt.ylabel('Recursive Calls')

    plt.tight_layout()
    plt.show()

# 实验
results = []
for i in range(2, 8):
    time_taken, calls_made = run_experiment(i)
    results.append((i, time_taken, calls_made))

# 绘制图表
plot_results(results)

http://www.kler.cn/a/378179.html

相关文章：

  • Vue3之Pinia
  • 「Mac畅玩鸿蒙与硬件47」UI互动应用篇24 - 虚拟音乐控制台
  • 深度学习每周学习总结J9（Inception V3 算法实战与解析 - 天气识别）
  • TCP与UDP的端口连通性
  • 鸿蒙学习笔记：用户登录界面
  • MySQL 主从复制与高可用
  • Windows Server2012 R2搭建NFS服务器
  • 认识类与对象(下)
  • 算法——递推
  • 组织架构图
  • Linux: network: hw csum failure
  • 【ceral】c++轻量的序列化库
  • 2024 年（ 第五届）“ 大湾区杯” 粤港澳金融数学建模竞赛A 题
  • 背包问题的详细理解(无基础-＞详细掌握)
  • Ubuntu 24 配置vsftp
  • SpringBoot抗疫物资管理与数据分析系统
  • vulhub之Spring篇
  • AIGC与虚拟现实(VR)的结合与应用前景
  • 人工智能中FOPL语言是什么？
  • php实现sl651水文规约解析
  • 自定义view实现历史记录流式布局
  • 5G基础知识
  • 【51 Pandas+Pyecharts | 深圳市共享单车数据分析可视化】
  • Java爬虫：京东商品SKU信息的“窃听风云”
  • 消息中间件类型介绍
  • 共创一带一路经济体，土耳其海外媒体软文发稿 - 媒体宣发报道