传教士(牧师)与野人问题-模拟人工智能实验_CSDN博客_传教士与野人问题

求解野人与传教士问题1

题目：设有n个传教士和m个野人来到河边，打算乘一只般从右岸到左岸云。该般的负载能力为两人。在任何时候，如果野人人数超过传教士人数，野人就会把传教士吃掉。他们怎样才能用这条般安全地把所有的人都渡过河去？
题目分析：
定义节点的结构：以取般的一个来回作为一步搜索，这样节点可由下面几个量进行描述：两岸的传教士人数和野人人数、本节点距离起始节点的距离，即由初始节点搜索几步后到达本节点。需要注意的是并不是所有节点都是可达的，题目中对可达节点作出了限制，只有两大岸上的人数必须不能为负。
void goon(); //判断是否继续搜索
void main()
{
int flag; //标记扩展是否成功
for(;;)
{
initiate();
flag=search()
if(flag==1)
releasemem();
goon();
}
}
}
void initiate()
{
int x;
char choice;
uend=unopened=(struc SPQ*)malloc(sizeof(spq));
void releasemem(); //释放占用内存
void showresult(); //显示解
void addtoopened(struc SPQ *ntx); //将节点ntx从UNOPENED链表移至OPRNENED
//链表中
newnode -> sst = sst;
newnode -> spt = spt;
newnode -> ssr = 0
newnode -> spr = 0

C实现传教士与野人过河问题实验报告

传教士与野人过河问题实验报告1 问题定义河的两岸有三个传教士和三个野人需要过河，目前只有一条能装下两个人的船，在河的任何一方或者船上，如果野人的人数大于传教士的人数，那么传教士就会被野人攻击，怎么找出一种安全的渡河方案呢？2 算法分析首先，先来看看问题的初始状态和目标状态，定义河的两岸分别为左岸和右岸，设定状态集合为（左岸传教士人数，右岸野人数，右岸传教士人数，右岸野人数，船的位置），船的位置：-1表示船在左岸，1表示船在右岸。

初始状态：（3,3,0,0,0，-1）目标状态：（0，0，3，3，1）然后，整个问题就抽象成了怎样从初始状态经中间的一系列状态达到目标状态。

问题状态的改变是通过划船渡河来引发的，所以合理的渡河操作就成了通常所说的算符，根据题目要求，可以得出以下5个算符（按照渡船方向的不同，也可以理解为10个算符）：渡1野人、渡1传教士、渡1野人1传教士、渡2野人、渡2传教士根据船的位置，向左移或向右移通过递归依次执行5种算符，判断是否找到所求，并排除不符合实际的状态，就可以找到所有可能的解，如图1所示为递归函数流程图。

数据结构方面采用如下所示的结构体存储当前传教士、野人、船三者的状态。

struct riverSides {int churchL;//左岸传教士数int wildL;//左岸野人数int churchR; //右岸传教士数int wildR; //右岸野人数int boat;//船的位置，-1在左岸，1在右岸};图 1 传教士与野人过河递归函数流程图3 编程实现程序使用C++实现，具体代码如下：#include<iostream>#include<vector>#include<string>using namespace std;struct riverSides{int churchL;//左岸传教士数int wildL;//左岸野人数int churchR; //右岸传教士数int wildR; //右岸野人数int boat;//船的位置，-1在左岸，1在右岸};int mycount = 0;//统计成功过河次数int CvsWdfs(riverSides lastcurrentState, vector <riverSides> lastParameters, vector<string> operation, int ifboacurrentStatety){if (lastcurrentState.churchR == 3 && lastcurrentState.wildR == 3){mycount++;cout << "第" << mycount << "次成功过河" << endl;cout << "传教士野人 | 移动方向" << endl;for (int i = 0; i < operation.size(); i++){cout << operation[i] << endl;}cout << endl;return 0;}//判断过河操作否重复，去除死循环for (int i = 0; i < lastParameters.size() - 1; i++){if (lastParameters[i].wildL == lastcurrentState.wildL&&lastParameters[i].churchL == lastcurrentState.churchL){if (lastcurrentState.boat == lastParameters[i].boat)return 0;}}//检验人数数据合法性if (lastcurrentState.churchL < 0 || lastcurrentState.wildL < 0 || lastcurrentState.churchR < 0 || lastcurrentState.wildR < 0)return 0;//传教士是否被吃if ((lastcurrentState.churchL < lastcurrentState.wildL&&lastcurrentState.churchL != 0) || (lastcurrentState.churchR < lastcurrentState.wildR&&lastcurrentState.churchR != 0)) return 0;//递归执行五类过河操作，boat=-1船在左岸，boat=1船在右岸，传入boat为上一次船位置//下次应当取反riverSides currentState;//两个传教士过河if (lastcurrentState.boat == 1)operation.push_back(" 2 0 | 左岸->右岸");elseoperation.push_back(" 2 0 | 右岸->左岸");currentState.churchL = lastcurrentState.churchL - 2 * lastcurrentState.boat;currentState.wildL = lastcurrentState.wildL;currentState.churchR = lastcurrentState.churchR + 2 * lastcurrentState.boat;currentState.wildR = lastcurrentState.wildR;currentState.boat = -lastcurrentState.boat;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters,operation, 0);operation.pop_back();lastParameters.pop_back();//两个野人过河if (lastcurrentState.boat == 1)operation.push_back(" 0 2 | 左岸->右岸");elseoperation.push_back(" 0 2 | 右岸->左岸");currentState.churchL = lastcurrentState.churchL;currentState.wildL = lastcurrentState.wildL - 2 * lastcurrentState.boat;currentState.churchR = lastcurrentState.churchR;currentState.wildR = lastcurrentState.wildR + 2 * lastcurrentState.boat;currentState.boat = -lastcurrentState.boat;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters, operation, 0);lastParameters.pop_back();operation.pop_back();//一个野人，一个传教士if (lastcurrentState.boat == 1)operation.push_back(" 1 1 | 左岸->右岸");elseoperation.push_back(" 1 1 | 右岸->左岸");currentState.churchL = lastcurrentState.churchL - 1 * lastcurrentState.boat;currentState.wildL = lastcurrentState.wildL - 1 * lastcurrentState.boat;currentState.churchR = lastcurrentState.churchR + 1 * lastcurrentState.boat;currentState.wildR = lastcurrentState.wildR + 1 * lastcurrentState.boat;currentState.boat = -lastcurrentState.boat;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters,operation, 0);operation.pop_back();lastParameters.pop_back();//一个传教士过河if (lastcurrentState.boat == 1)operation.push_back(" 1 0 | 左岸->右岸");elseoperation.push_back(" 1 0 | 右岸->左岸");currentState.churchL = lastcurrentState.churchL - 1 * lastcurrentState.boat;currentState.wildL = lastcurrentState.wildL;currentState.churchR = lastcurrentState.churchR + 1 * lastcurrentState.boat;currentState.wildR = lastcurrentState.wildR;currentState.boat = -lastcurrentState.boat;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters, operation, 0);operation.pop_back();lastParameters.pop_back();//一个野人过河if (lastcurrentState.boat == 1)operation.push_back(" 0 1 | 左岸->右岸");elseoperation.push_back(" 0 1 | 右岸->左岸");currentState.churchL = lastcurrentState.churchL;currentState.wildL = lastcurrentState.wildL - 1 * lastcurrentState.boat;currentState.churchR = lastcurrentState.churchR;currentState.wildR = lastcurrentState.wildR + 1 * lastcurrentState.boat;currentState.boat = -lastcurrentState.boat;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters, operation, 0);operation.pop_back();lastParameters.pop_back();return 0;}int main(){int churchL = 3, wildL = 3, churchR = 0, wildR = 0;//分别用来计算左岸和右岸的传教士和野人vector <riverSides> lastParameters;//保存每一步移动操作的两岸传教士、野人人数vector <string> operation;//保存当前操作的描述//初始化左岸参数，可以认为是从右岸移动至左岸的操作//boat=-1 表示船在左岸，boat=1表示船在右岸riverSides currentState;currentState.churchL = 3;currentState.wildL = 3;currentState.churchR = 0;currentState.wildR = 0;currentState.boat = 1;lastParameters.push_back(currentState);CvsWdfs(currentState, lastParameters,operation, 0);lastParameters.pop_back();system("pause");return 0;}4 程序结果最终得到如图2、3所示的四种过河方式。

人工智能-习题1

人工智能习题1
1. 传教士和野人问题。

三个传教士和三个野人来到河边，有一条船可供一人或两人乘渡，在渡河过程中，任一岸的野人数若大于传教士人数，野人就会吃掉传教士。

他们怎样才能安全过河？请用一种合适的状态及算符表示该问题，并以此画出状态空间图，找到所有可能的解。

2. 设有如图1所示八数码问题，按如下定义估价函数：
f(x) = d(x) + h(x)
其中d(x)为节点x 的深度；h(x)是所有棋子偏离目标位置的距离总和，试用全局择优搜索画出搜索树，并比较与课堂上给出的估价函数的搜索效率
图1. 八数码问题
3. 推销员旅行问题。

设有5个相互可直达的城市A 、B 、C 、D 、E, 如图2所示，各城市间的交通费用已在图中标出。

推销员从城市A 出发，去每个城市各旅行一次，最后到达城市E 。

请（1）画出该问题的代价树；（2）找出一条费用最少的旅行路线。

图2. 交通费用图
4 ．设有如图3所示博弈树，底端的数字为假设的估值，请对该博弈树做如下工作：
(1)计算各节点的倒推值
(2)利用α-β剪枝技术剪去不必要的分支（假设按照从左至右的顺序进行判断）
图3. 博弈树
5 ．知识表示:
(a)设有下列语句，请用相应的谓词公式把它们表示出来：
（1）李明喜爱音乐和绘画。

（2）喜欢玩篮球的人必喜欢NBA。

（3）所有的自然数都是大于零的整数。

(b)请对下列命题分别写出它的语义网络：
（1）钱老师从 6 月至 8 月给会计专业的学生讲授《市场经济学》课程。

（2）张三是大发电脑公司的经理，他 35 岁，住在飞天胡同 68 号。

野人与传教士问题A算法

野人与传教士问题（A*算法）SY0903620 赵磊一、实验题目请用A*算法实现传教士和野人问题问题：设有3个传教士和3个野人来到河边，打算乘一只船从右岸渡到左岸去。

该船的负载能力为两人。

在任何时候，如果野人人数超过传教士人数，那么野人就会把传教士吃掉。

他们怎样才能用这条船安全地把所有人都渡过河去？算法设计要求给出：状态表示，规则库，启发函数等二、实验目的通过具体问题的编程求解，利用A*算法解决此经典问题，了解人工智能的启发式搜索算法的基本过程与原理。

三、设计思想1、编程工具采用C++语言在Visual Studio 6.0环境下编写；2、整体思想(1)把初始结点So放入OPEN 表中，计算f(So)。

(2)如果OPEN为空，则搜索失败，退出。

(3)把OPEN中的第一个节点(记为节点n)从表中移出放入CLOSED表。

(4)考察节点n是否为目标节点。

若是，则求得问题的解，退出。

(5)若节点n不可扩展，则转第(2)步。

(6)扩展节点n，用估价函数f(x)计算每个子节点的估价值，并为每个子节点配置指向父节点的指针，把这些子节点都送到OPEN表中，然后对OPEN表中的全部节点按估价值从小到大的顺序排列。

3、具体说明用A*算法求解传教士与野人问题。

M=C=5, K=3。

节点估价值设为f(n)=h(n)+g(n)，g(n)设为节点搜索深度，而h(n)= m(n) + c(n) - 2b(n),其中m：河左岸的传教士人数；c：河左岸的野人人数；b：船是否在左岸，1：表示在左岸，0：表示不在左岸。

采用结构体定义形式，定义状态节点*NewNode(int m, int c, int b)，其中包含m左岸传教士人数、c左岸野人人数、b船状态（左或右）。

开始状态为（3，3，1），目标状态为（0，0，0）。

若需要条件满足，即任何时候，如果野人人数超过传教士人数，那么野人就会把传教士吃掉，要对状态结点的安全性进行判断，判断一个状态是否为安全的，即是否满足在河的任何一岸，传教士人数不少于野人人数，或者只有野人而没有传教士。

传教士和野人渡河

传教士和野人渡河问题作品报告有5个传教士和5个野人过河，只有一条能装下3个人的船，在河的任何一方或者船上，如果野人的人数大于传教士的人数，那么传教士就会有危险。

请设计合适的摆渡方案，并使得所需的摆渡次数最少。

源代码：#include "stdio.h"#include "string.h"#define STEP_MAX 20 //来回过河的最大次数#define NO 5 //野人和传教士各有的人数#define HEAVY 3 //船的最大载重量typedef struct{int wild; //右岸上的野人数int man; //右岸上的传教士数int boat_state; //0表示在左岸，1表示在右岸}state;typedef struct{int wild; //船上的野人数int man; //船上的传教士数int boat_run; //0表示去左岸，1表示去右岸}boat;state now[STEP_MAX]={0}; //保存过河过程中对岸的状态boat path[STEP_MAX]={0}; //保存过河的路径int suit_NO=STEP_MAX; //最合适的过河次数，初始值为一足够的数boat suit_path[STEP_MAX]; //最合适的过河方式//是否全部过河bool All(state c){//右岸的最终状态const state cs={NO,NO,1};if(memcmp(&cs,&c,sizeof(state))==0){return true;}return false;}//传教士是否有危险bool Danger(state ca){if ((ca.wild>ca.man&&ca.man>0)||(NO-ca.wild>NO-ca.man&&NO-ca.man>0)) {return true;}elsereturn false;}//判断该状态是否与前面的一样bool Same(state cs,int n){for (int i=0;i<n;i++){if (memcmp(&cs,&now[i],sizeof(state))==0){return true;}}return false;}//将最短路径保存到suit_path中void Min(int n,boat path[]){if (n<suit_NO){suit_NO=n;memcpy(&suit_path[0],&path[0],n*sizeof(boat));}}//查找过河方案void Cross(int n){int i,j;if (All(now[n])){Min(n,path);return;}if (Danger(now[n])){return;}if (Same(now[n],n)){return;}if(now[n].boat_state==0)//船在左岸时{for(i=0;i<=HEAVY && i<=NO-now[n].wild;i++){for(j=0;j<=HEAVY-i && j<=NO-now[n].man;j++){if (i==0 && j==0){continue;}path[n].wild=i;path[n].man=j;path[n].boat_run=1;memcpy(&now[n+1],&now[n],sizeof(state));now[n+1].wild+=i;now[n+1].man+=j;now[n+1].boat_state=1;Cross(n+1);}}}else//船在右岸时{for(i=0;i<=HEAVY && i<=now[n].wild;i++){for(j=0;j<=HEAVY-i && j<=now[n].man;j++){if (i==0 && j==0){continue;}path[n].wild=i;path[n].man=j;path[n].boat_run=0;memcpy(&now[n+1],&now[n],sizeof(state));now[n+1].wild-=i;now[n+1].man-=j;now[n+1].boat_state=0;Cross(n+1);}}}}void main(){Cross(0);for(int i=0;i<suit_NO;i++){if(path[i].boat_run==0)printf("第%d次过河,从右岸到左岸,船上野人数为%d,传教士数为%d.\n",i+1,suit_path[i].wild,suit_path[i].man);elseprintf("第%d次过河,从左岸到右岸,船上野人数为%d,传教士数为%d.\n",i+1,suit_path[i].wild,suit_path[i].man);}}使用方法：上述程序主要采用了递归调用和近似于枚举的方法。

传教士野人问题

问题：野人过河问题属于人工智能学科中的一个经典问题，问题描述如下：有三个牧师（也有的翻译为传教士）和三个野人过河，只有一条能装下两个人的船，在河的任何一方或者船上，如果野人的人数大于牧师的人数，那么牧师就会有危险. 你能不能找出一种安全的渡河方法呢？解答一：一、算法分析先来看看问题的初始状态和目标状态，假设和分为甲岸和乙岸：初始状态：甲岸，3野人，3牧师；乙岸，0野人，0牧师；船停在甲岸，船上有0个人；目标状态：甲岸，0野人，0牧师；乙岸，3野人，3牧师；船停在乙岸，船上有0个人；整个问题就抽象成了怎样从初始状态经中间的一系列状态达到目标状态。

问题状态的改变是通过划船渡河来引发的，所以合理的渡河操作就成了通常所说的算符，根据题目要求，可以得出以下5个算符（按照渡船方向的不同，也可以理解为10个算符）：渡1野人、渡1牧师、渡1野人1牧师、渡2野人、渡2牧师算符知道以后，剩下的核心问题就是搜索方法了，本文采用深度优先搜索，通过一个FindNext(…)函数找出下一步可以进行的渡河操作中的最优操作，如果没有找到则返回其父节点，看看是否有其它兄弟节点可以扩展，然后用Process(…)函数递规调用FindNext(…)，一级一级的向后扩展。

搜索中采用的一些规则如下：1、渡船优先规则：甲岸一次运走的人越多越好（即甲岸运多人优先），同时野人优先运走；乙岸一次运走的人越少越好（即乙岸运少人优先），同时牧师优先运走；2、不能重复上次渡船操作（通过链表中前一操作比较），避免进入死循环;3、任何时候河两边的野人和牧师数均分别大于等于0且小于等于3；4、由于只是找出最优解，所以当找到某一算符（当前最优先的）满足操作条件后，不再搜索其兄弟节点，而是直接载入链表。

5、若扩展某节点a的时候，没有找到合适的子节点，则从链表中返回节点a的父节点b，从上次已经选择了的算符之后的算符中找最优先的算符继续扩展b。

二、基本数据结构仔细阅读问题，可以发现有些基本东西我们必须把握，例如：每时刻河两岸野人牧师各自的数目、船的状态、整个问题状态。

人工智能：野人与修道士问题

野人与修道士问题（Missionaries-and-Cannibals Problem ）[修道士与野人问题]：三个野人与三个传教士来到河边，打算乘一只船从右岸渡到左岸去，该船的最大负载能力为两个人。

在任何时候，如果野人人数超过传教士人数，那么野人就会把传教士吃掉。

用状态空间法表示修道士与野人问题并设计编写计算机程序求问题的解。

问题分析：从上图可知，修道士、野人和船一共有六种可能，M L 、C L 、B L 、M R 、C R 、B R 。

可以表示为q ＝（M ，C ，B ），其中m 表示修道士的数目（0、1、2、3）、c 表示野人的数目（0、1、2、3）、b 表示船在左岸（1）或右岸（0）。

1、定义状态的描述形式：（m ，c ，b ）2、表示所有可能的状态，并确定初始状态集和目标状态集：s0(3,3,1) s8(1,3,1) s16(3,3,0) s24(1,3,0)s1(3,2,1) s9(1,2,1) s17(3,2,0) s25(1,2,0)s2(3,1,1) s10(1,1,1) s18(3,1,0) s26(1,1,0)s3(3,0,1) s11(1,0,1) s19(3,0,0) s27(1,0,0)s4(2,3,1) s12(0,3,1) s20(2,3,0) s28(0,3,0)s5(2,2,1) s13(0,2,1) s21(2,2,0) s29(0,2,0)s6(2,1,1) s14(0,1,1) s22(2,1,0) s30(0,1,0)s7(2,0,1) s15(0,0,1) s23(2,0,0) s31(0,0,0)初始状态：（3,3,1）目标状态：（0,0,0）3、定义算符：L ij ：把i 个修道士，j 个野人从河的左岸送到右岸R ij ：把i 个修道士，j 个野人从河的右岸送到左岸整个问题就抽象成了怎样从初始状态经中间的一系列状态达到目标状态。

问修道士M野人C 左L 右R题状态的改变是通过划船渡河来引发的，所以合理的渡河操作就成了通常所说的算符，根据题目要求，可以得出以下5个算符（按照渡船方向的不同，也可以理解为10个算符）：渡1野人、渡1牧师、渡1野人1牧师、渡2野人、渡2牧师即：L01或R01，L10或R10，L11或R11，L02或R02，L20或R204、状态空间图：5、设计编写计算机程序求问题的解：算法：在应用状态空间表示和搜索方法时，用（M，C，B）来表示状态描述，其中M和C分别表示在左岸的传教士与野人数。

传教士和野人问题

传教士和野人问题（Missionaries and Cannibals）传教士和野人问题是一个经典的智力游戏问题。

在这个问题中，实际上隐含了这样一个条件：如果在河的某一岸只有野人，而没有传教士，也同样被认为是合法状态。

在具体书写某些条件时，为了简便，这一点有时并没有考虑，但我们默认这个条件是被考虑了的。

有N个传教士和N个野人来到河边准备渡河，河岸有一条船，每次至多可供k人乘渡。

问传教士为了安全起见，应如何规划摆渡方案，使得任何时刻，在河的两岸以及船上的野人数目总是不超过传教士的数目。

即求解传教士和野人从左岸全部摆渡到右岸的过程中，任何时刻满足M（传教士数）≥C （野人数）和M＋C≤k的摆渡方案。

设N＝3，k＝2，则给定的问题可用图1.2表示，图中L和R表示左岸和右岸，B＝1或0分别表示有船或无船。

约束条件是：两岸上M≥C，船上M＋C≤2。

图1.2 M－C问题实例由于传教士和野人数是一个常数，所以知道了一岸的情况，另一岸的情况也就知道了。

因此为了简便起见，在描述问题时，只描述一岸--如左岸--的情况就可以了。

另外，该问题我们最关心的是在摆渡过程中，两岸状态的变化情况，因此船上的情况并不需要直接表达出来。

在一次摆渡过程中，船上究竟有几个传教士和野人，可以通过两个相连的状态简单得到。

这样表达更简练，突出了问题的重点。

（1）综合数据库：用三元组表示左岸的情况，即（，，），其中0≤，≤3，∈{0，1}，其中表示在左岸的传教士人数，表示在左岸的野人数，＝1表示船在左岸，＝0表示船在右岸。

则此时问题描述可以简化为：（3，3，1）→（0，0，0）N＝3的M－C问题，状态空间的总状态数为4×4×2＝32，根据约束条件的要求，可以看出只有20个合法状态。

再进一步分析后，又发现有4个合法状态实际上是不可能达到的。

因此实际的问题空间仅由16个状态构成。

下表列出分析的结果：（）（001）达不到（传教士（）（000）均在右，船在左）（011）（021）（031）（101）不合法（右岸野人多）（111）（121）不合法（左岸野人多）（131）不合法（左岸野人多）（201）不合法（右岸野人多）（211）不合法（右岸野人多）（221）（231）不合法（左岸野人多）（301）达不到（311）（321）（331）（010）（020）（030）达不到（100）不合法（右岸野人多）（110）（120）不合法（左岸野人多）（130）不合法（左岸野人多）（200）不合法（右岸野人多）（210）不合法（右岸野人多）（230）不合法（右岸野人多）（300）（220）（310）（320）（330）达不到规则集可以划分为两组：一组是从左岸到右岸，称为p 操作，另一组是从右岸到左岸，称为q操作。

传教士野人过河问题两种解法思路

第５次:左岸到右岸,传教士过去2人,野人过去０人
第６次：右岸到左岸,传教士过去1人，野人过去1人
第7次:左岸到右岸,传教士过去2人,野人过去0人
第8次:右岸到左岸，传教士过去0人，野人过去1人
第9次:左岸到右岸，传教士过去0人,野人过去2人
第１0次：右岸到左岸，传教士过去1人,野人过去0人
第11次：左岸到右岸，传教士过去1人,野人过去１人
F={P０1,P10,P11,P02,P２0,Q０１,Q10，Q11，Q０２,Ｑ20｝
P10ﻩif (ＭＬ,CＬ,ＢＬ=１)tｈeｎ（MＬ–1 , CL，BL–１)
P0１ﻩif ( ML，CL , BＬ＝1）tｈen ( ML ,ＣL–1 , BL–１)
P11ﻩif (MＬ,CＬ,BL=１) then ( ML–1 , CL–1,ＢL–１)
二、解答步骤
(1)设置状态变量并确定值域
M为传教士人数，C为野人人数,Ｂ为船数,要求M>=C且Ｍ+C<=3，L表示左岸,R表示右岸。
初始状态ﻩﻩ目标状态
LﻩRﻩﻩﻩLR
Mﻩ３０ﻩﻩﻩM０3
Cﻩ30ﻩﻩﻩﻩﻩC0３
B1ﻩ０ﻩﻩﻩﻩB0ﻩ1
(2)确定状态组,分别列出初始状态集和目标状态集
用三元组来表示：（ML，CL，BＬ）（均为左岸状态）
图1状态空间图
箭头旁边所标的数字表示了P或Ｑ操作的下标，即分别表示船载的传教士数和食人者数。
三、算法设计
方法一:树的遍历
根据规则由根(初始状态）扩展出整颗树，检测每个结点的“可扩展标记”,为“-1”的即目标结点。由目标结点上溯出路径。
见源程序１。
方法二：启发式搜索
构造启发式函数为：
选择较大值的结点先扩展。

传教士与野人问题

传教士与野人问题：传教士（M）与野人（C）数目均为五人，渡船（B）最多可乘3人，请定义一个启发函数，并给出相应的搜索树。

解：定义启发函数h（n）=0; h（n）=M+C; h（n）=M+C-2B 只有h（n）=M+C-2B可满足h（n）≤h*（n），是满足A*条件
的。

分两种情况来讨论：
先考虑船在左岸的情况，如果不考虑限制条件，至少需要[（M+C-3）/2]*2+1次，其中分子上的“-3”表示剩下的3个留待最后一次运过去。

除以2是因为一个来回可以运过去2人，需（M+C-3）/2个来回，而来回数不能是小数，所以要取整。

一个来回是两次，所以“*2”，而最后的“+1”，则表示将剩下的3个运过去需要一次摆渡。

化简后为：
[（M+C-3）/2]*2+1=M+C-2
再考虑船在右岸的情况。

同样不考虑限制条件。

船在右岸，需要一个人将船运往左岸，因此，对于状态（M，C，0），需要的摆渡数，相当于船在左岸的（M+1，C，1）或（M，C+1，1），所以需要的最少摆渡数为M+C+1-2+1=M+C。

综合条件，需要的最少摆渡数为M+C-2B。

当加上限制条件时，最优的摆渡次数只能大于等于该摆渡数。

所以该启发函数是满足A*条件的。

搜索图如下：。

传教士和野人问题实验报告

传教士和野人问题实验报告1.上机内容传教士与野人问题求解（宽度搜索算法）二二问题背景：从前有一条河，河的左岸有 m 个传教士(Missionary)和 m 个野人(Cannibal)，和一艘最多可乘 n 人的小船。

约定左岸，右岸和船上或者没有传教士，或者野人数量少于传教士，否则野人会把传教士吃掉。

三三实验内容：编程，接收 m 和 n，搜索一条可让所有的野人和传教士安全渡到右岸的方案，例如下图: （M 表示传教士(Missionary)，C 表示野人(Cannibal)）初态目标 Left Bank River Right bankLeft Bank River Right bank M....M....C....C....注：本实验的举例均以 3 个传教士和 3 个野人同在左岸作为初始状态。

四四实验方案和算法：1 ．数据结构：本实验需要用到的数据结构主要是队列和堆栈，其实现均包含于 dso.h 头文件中，分别命名为 class stack 和 class queue。

2 2 ．宽度搜索算法：(1) 结点结构：class Move {public:int missionary;//要移动的传教士数量int cannibal;//野人}; class ElemType : Move {//继承 Move 类，获得传教士，野人数据成员。

private:bool boat;//船是否在左岸？public:ElemType_flag;// 标示前一状态即扩展出本结点的父结点信息ElemType(int MA__PEOPLE) {//创建初始状态missionary = cannibal = MA__PEOPLE;boat = true;flag = NULL;} ......在这里，Elemtype 集成了 Move，从而获得 Move 类的传教士和野人数据成员。

以上两个类的数据成员用于保存所有扩展生成的结点。

野人与传教士问题A算法

野人与传教士问题（A*算法）SY0903620 赵磊一、实验题目请用A*算法实现传教士和野人问题问题：设有3个传教士和3个野人来到河边，打算乘一只船从右岸渡到左岸去。

该船的负载能力为两人。

在任何时候，如果野人人数超过传教士人数，那么野人就会把传教士吃掉。

他们怎样才能用这条船安全地把所有人都渡过河去？算法设计要求给出：状态表示，规则库，启发函数等二、实验目的通过具体问题的编程求解，利用A*算法解决此经典问题，了解人工智能的启发式搜索算法的基本过程与原理。

三、设计思想1、编程工具采用C++语言在Visual Studio 6.0环境下编写；2、整体思想(1)把初始结点So放入OPEN 表中，计算f(So)。

(2)如果OPEN为空，则搜索失败，退出。

(3)把OPEN中的第一个节点(记为节点n)从表中移出放入CLOSED表。

(4)考察节点n是否为目标节点。

若是，则求得问题的解，退出。

(5)若节点n不可扩展，则转第(2)步。

(6)扩展节点n，用估价函数f(x)计算每个子节点的估价值，并为每个子节点配置指向父节点的指针，把这些子节点都送到OPEN表中，然后对OPEN表中的全部节点按估价值从小到大的顺序排列。

3、具体说明用A*算法求解传教士与野人问题。

M=C=5, K=3。

节点估价值设为f(n)=h(n)+g(n)，g(n)设为节点搜索深度，而h(n)= m(n) + c(n) - 2b(n),其中m：河左岸的传教士人数；c：河左岸的野人人数；b：船是否在左岸，1：表示在左岸，0：表示不在左岸。

采用结构体定义形式，定义状态节点*NewNode(int m, int c, int b)，其中包含m左岸传教士人数、c左岸野人人数、b船状态（左或右）。

开始状态为（3，3，1），目标状态为（0，0，0）。

若需要条件满足，即任何时候，如果野人人数超过传教士人数，那么野人就会把传教士吃掉，要对状态结点的安全性进行判断，判断一个状态是否为安全的，即是否满足在河的任何一岸，传教士人数不少于野人人数，或者只有野人而没有传教士。

传教士野人问题参考答案

传教士-野人问题有N个传教士和N个野人要过河，现在有一条船只能承载K个人（包括野人），K<N，在任何时刻，如果有野人和传教士在一起，必须要求传教士的人数多于或等于野人的人数。

设M为传教士的人数，C为野人的人数，用状态空间发求解此问题的过程如下：M、C = N，boat = k，要求M>=C且M+C <= K初始状态目标状态L R L RM 3 0 M 0 3C 3 0 C 0 3B 1 0 B 0 1(1)用三元组来表示（ML , CL , BL）其中0<=ML , CL <= 3 , BL ∈{ 0 , 1}(3 , 3 , 1) (0 , 0 , 0)(2)规则集合P10if ( ML ,CL , BL=1 ) then ( ML–1 , CL , BL –1 )P01if ( ML ,CL , BL=1 ) then ( ML , CL–1 , BL –1 )P11if ( ML ,CL , BL=1 ) then ( ML–1 , CL–1 , BL –1 )P20if ( ML ,CL , BL=1 ) then ( ML–2 , CL , BL –1 )P02if ( ML ,CL , BL=1 ) then ( ML , CL–2 , BL –1 )Q10if ( ML ,CL , BL=0 ) then ( ML+1 , CL , BL+1 )Q01if ( ML ,CL , BL=0 ) then ( ML , CL+1 , BL +1 )Q11if ( ML ,CL , BL=0 ) then ( ML+1 , CL +1, BL +1 )Q20 if ( ML ,CL , BL=0 ) then ( ML+2 , CL +2, BL +1 )Q02if ( ML ,CL , BL=0 ) then ( ML , CL +2, BL +1 )(3)寻找一个启发式函数引导规则的选用右岸总人数6 – ML – CL 两岸中传教士数目>=野人数目f =–∞其它f=3 Q 01f=2 P 02 f=1 Q 01f=1 Q 11f=1 P 01 f=2 P 11 （3，3，1）（3，2，0）（2，2，0）（3，1，0）（3，2，1）（3，0，0） f=3 P 02（3，1，1） f=2 Q 01（1，1，0） f=4 P 20（2，2，1） f=2 Q 11（1，1，0） f=4 P 20（2，2，1） f=2 Q 11（0，2，0） f=4 P 20（0，3，1）f=3 Q 01（0，1，1）f=5 P 02（0，2，1） f=4 Q 01 （0，0，0）f=3 Q 01（1，1，1） f=4 Q 106.2.3 用状态空间法求解传教士和食人者问题例6-2 传教士和食人者问题（The Missionaries and Cannibals Problem）。

用Prolog求解传教士和野人问题

用Prolog求解传教士和野人问题实验七用Prolog求解传教士和野人问题 1、实验目的复习经典谓词演算中的归结原理，掌握人工智能程序设计语言Prolog，理解通过搜索求解问题实现人工智能的思想。

2、实验原理谓词演算中的消解法，3、实验内容设有3个传教士和3个野人同在河的左岸，他们都要到对岸去;河里只有一条船，他们都会划船，但每次渡船至多只能乘两人;如果在任何一边河岸上，野人的数量超过传教士，野人就要吃掉传教士，问怎样才能用船将3个传教士和3个野人从左岸都渡到右岸，又不会发生传教士被吃的事件呢,通过Prolog程序，给出乘船过河的动作序列。

4、实验步骤(1) 设计该问题的状态。

例如:((左岸牧师数，左岸野人数),(右岸牧师数，右岸野人数),船的位置)。

(2) 定义目标状态。

这里是:((0,0),(3,3),1)3) 描述可能的动作。

船上所能够载人的状态就是可能的操作。

用谓词(move表示。

(4) 判断合法状态(5) 深度优先搜索三个传教士和三个野人的示例程序如下:move(1,0).move(0,1).move(0,2).move(2,0).move(1,1).legal((X,Y,_)):-legal1(X),legal1(Y). legal1((X,Y)):-X=:=0,Y>=0,!. legal1((X,Y)):-Y=:=0,X>=0,!. legal1((X,Y)):-X>=Y,X>=0,Y>=0.update((X,Y,0),Move,Statu1):-(A,B)=X,(C,D)=Y,(E,F)=Move,C1 is C+E,D1 is D+F,A1 is A-E,B1 is B-F,Statu1=((A1,B1),(C1,D1),1). update((X,Y,1),Move,Statu1):- (A,B)=X, (C,D)=Y,(E,F)=Move,C1 is C-E,D1 is D-F,A1 is A+E,B1 is B+F,Statu1=((A1,B1),(C1,D1),0). connect(Statu,Statu1):- move(X,Y),update(Statu,(X,Y),Statu1), legal(Statu1).findroad(X,X,L,L):-write(L). findroad(X,Y,L,L1):-connect(X,Z),not(member(Z,L)),findroad(Z,Y,[Z|L],L1).传教士和野人问题有三个牧师和三个野人过河，只有一条能装下两个人的船，在河的任何一方或者船上，如果野人的人数大于牧师的人数，那么牧师就会有危险。

人工智能实验——传教士和野人过河C++源程序

e[i]=false;
ofstream fout(argv[2]);
if(k < 2){//一定无解
fout << "no solution" << endl;
return 0;
}
//初始状态存入结果向量
Node n;
n.x = N;
n.y = N;
n.c = 1;
n0.c = 0;
answer.push_back(n0);
return true;
}
}
Node n0;
n0.x = tx;
n0.y = ty;
n0.c = 0;
answer.push_back(n0);
e[tx+ty*20]=true;
//试探过河，从右岸到左岸
for(j=4;j>=0;j--){
int ttx = tx+Q2[j][0];
if(!crossBy3(N)){
fout << "no solution" << endl;
return 0;
}
}
for(unsigned i=0;i<answer.size();i++){
fout <<"(" << answer.at(i).x <<","<<answer.at(i).y<<","<<answer.at(i).c<<")"<<endl;

人工智能+野人传教士过河问题c程序+深度优先

pHead=open;
open[top].m=M;
open[top].c=C;
open[top].s=S;
open[top].f=0;
open[top].pre=0;
inist();
find(pHead);
system("PAUSE");
{
flag=0;
break;
}
pTemp=pTemp->pre;
}
if(flag)
{
j++;
boatState[j].m = m;
boatState[j].c = c;
}
}
}
}
//*******************************************************************************
int goal(struct state * p) //判断当前状态是否目标状态
{
if(p->m==0&&p->c==0&&p->s==1) return 1;
else return 0;
}
//******************************************************************************
//初始状态：左岸，3野人，3牧师；
// 右岸，0野人，0牧师；
// 船停在左岸，船上有0个人
//目标状态：左岸，0野人，0牧师；
// 右岸，3野人，3牧师；
// 船停在右岸，船上有0个人；

人工智能第三版源码-传教士_野人问题

传教士-野人问题有N个传教士和N个野人要过河，现在有一条船只能承载K个人（包括野人），K<N，在任何时刻，如果有野人和传教士在一起，必须要求传教士的人数多于或等于野人的人数。

设M为传教士的人数，C为野人的人数，用状态空间发求解此问题的过程如下：M、C = N，boat = k，要求M>=C且M+C <= K初始状态目标状态L R L RM 3 0 M 0 3C 3 0 C 0 3B 1 0 B 0 1(1)用三元组来表示（ML , CL , BL）其中0<=ML , CL <= 3 , BL ∈{ 0 , 1}(3 , 3 , 1) (0 , 0 , 0)(2)规则集合P10 if ( ML ,CL , BL=1 ) then ( ML–1 , CL , BL –1 )P01 if ( ML ,CL , BL=1 ) then ( ML , CL–1 , BL –1 )P11 if ( ML ,CL , BL=1 ) then ( ML–1 , CL–1 , BL –1 )P20 if ( ML ,CL , BL=1 ) then ( ML–2 , CL , BL –1 )P02 if ( ML ,CL , BL=1 ) then ( ML , CL–2 , BL –1 )Q10 if ( ML ,CL , BL=0 ) then ( ML+1 , CL , BL+1 )Q01 if ( ML ,CL , BL=0 ) then ( ML , CL+1 , BL +1 )Q11 if ( ML ,CL , BL=0 ) then ( ML+1 , CL +1, BL +1 )Q20 if ( ML ,CL , BL=0 ) then ( ML+2 , CL +2, BL +1 )Q02 if ( ML ,CL , BL=0 ) then ( ML , CL +2, BL +1 )(3)寻找一个启发式函数引导规则的选用右岸总人数6 – ML – CL 两岸中传教士数目>=野人数目f =–∞其它f=3 Q01 f=2 P02 f=1 Q01 f=1 Q10 f=1 P01 f=2 P11 （3，3，1）（3，2，0）（2，2，0）（3，1，0）（3，2，1）（3，0，0） f=3 P02 （3，1，1） f=2 Q01 （1，1，0） f=4 P20 （2，2，1） f=2 Q11 （1，1，0） f=4 P20 （2，2，1） f=2 Q11 （0，2，0） f=4 P20 （0，3，1） f=3 Q01 （0，1，1） f=5 P02 （0，2，1） f=4 Q01 （0，0，0） f=3 Q01 （1，1，1） f=4 Q10。

人工智能里野人和传教士问题代码

//而对于函数qq(int& a)，这是C++中引入的一个新类型：引用，所带来的新的函数传值方式，即按引用传值。

#include<process.h> /* exit() */#include<stdio.h>#include <stdlib.h>#define NULL 0#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0typedef struct{int m;int c;int b;}QElemType; /* 定义队列的数据元素类型QElemType为结构体类型*/typedef struct _Rule{int m;int c;}Rule;Rule rule[5] = {{1,1}, {1,0}, {0,1}, {2,0}, {0,2}}; // 规则集etypedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front,rear; /* 队头、队尾指针*/}LinkQueue;void InitQueue(LinkQueue *Q){ /* 构造一个空队列Q */(*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));if(!(*Q).front)exit(0);(*Q).front->next=NULL;}int DeQueue(LinkQueue *Q,QElemType *e){ /* 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR */QueuePtr p;if((*Q).front==(*Q).rear)return ERROR;p=(*Q).front->next;*e=p->data;(*Q).front->next=p->next;if((*Q).rear==p)(*Q).rear=(*Q).front;free(p);return OK;}void EnQueue(LinkQueue *Q,QElemType e){ /* 插入元素e为Q的新的队尾元素*/QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p) /* 存储分配失败*/exit(0);p->data=e;p->next=NULL;(*Q).rear->next=p;(*Q).rear=p;}int cmp(LinkQueue *Q,QElemType e){QueuePtr p=(*Q).front->next;while(p!=NULL){if(p->data.m==e.m&&p->data.c==e.c&&p->data.b==e.b)return TRUE;else p=p->next;}return FALSE;}int QueueEmpty(LinkQueue Q){ /* 若Q为空队列，则返回TRUE，否则返回FALSE */if(Q.front->next==NULL)return TRUE;elsereturn FALSE;}// EnQueue(&q[i],f); /* 将f入队到第i队列（i=0～Qu-1）*/ // DeQueue(&q[i],&customer); /* 删除第i队列的排头客户*/ // if(!QueueEmpty(q[i]))//p=(*Q).front->next;//*e=p->data;void main(){LinkQueue open,closed;QueuePtr p;int i;InitQueue(&open);InitQueue(&closed);QElemType s={3,3,1},e,e1;EnQueue(&open,s);while(!QueueEmpty(open)){DeQueue(&open,&e);EnQueue(&closed,e);if(e.m==0&&e.c==0&&e.b==0){printf("成功!");continue;}for(i=0;i<5;i++){e1.m=e.m,e1.c=e.c,e1.b=e.b;if(e1.b==1)//船在左岸{e1.m=e1.m-rule[i].m;e1.c=e1.c-rule[i].c;e1.b=0;if((e1.m>=e1.c||e1.m==0)&&((3-e1.m)>=(3-e1.c)||(3-e1.m)==0)&&e1.m<=3&&e1.c<=3&&e1.m>=0&&e1.c>=0) {if(!cmp(&closed,e1))if(!cmp(&open,e1))EnQueue(&open,e1);}//需要解决元素问题}//ifelse{e1.m=e1.m+rule[i].m;e1.c=e1.c+rule[i].c;e1.b=1;if((e1.m>=e1.c||e1.m==0)&&((3-e1.m)>=(3-e1.c)||(3-e1.m)==0)&&e1.m<=3&&e1.c<=3&&e1.m>=0&&e1.c>=0) {if(!cmp(&closed,e1))if(!cmp(&open,e1))EnQueue(&open,e1);}//需要解决元素重复问题}//else}//for}//whilep=closed.front;p=p->next;while(p!=NULL){printf("%d,%d,%d\n",p->data.m,p->data.c,p->data.b); p=p->next;}//p=(open).front->next;//e=p->data;//printf("%d",e.m);}。

传教士与野人过河问题

传教士-野人问题有N个传教士和N个野人要过河，现在有一条船只能承载K个人（包括野人），K<N，在任何时刻，如果有野人和传教士在一起，必须要求传教士的人数多于或等于野人的人数。

设M为传教士的人数，C为野人的人数，用状态空间发求解此问题的过程如下：M、C = N，boat = k，要求M>=C且M+C <= K初始状态目标状态L R L RM 3 0 M 0 3C 3 0 C 0 3B 1 0 B 0 1(1)用三元组来表示（ML , CL , BL）其中0<=ML , CL <= 3 , BL ∈{ 0 , 1}(3 , 3 , 1) (0 , 0 , 0)(2)规则集合P10if ( ML ,CL , BL=1 ) then ( ML–1 , CL , BL –1 )P01if ( ML ,CL , BL=1 ) then ( ML , CL–1 , BL –1 )P11if ( ML ,CL , BL=1 ) then ( ML–1 , CL–1 , BL –1 )P20if ( ML ,CL , BL=1 ) then ( ML–2 , CL , BL –1 )P02if ( ML ,CL , BL=1 ) then ( ML , CL–2 , BL –1 )Q10if ( ML ,CL , BL=0 ) then ( ML+1 , CL , BL+1 )Q01if ( ML ,CL , BL=0 ) then ( ML , CL+1 , BL +1 )Q11if ( ML ,CL , BL=0 ) then ( ML+1 , CL +1, BL +1 )Q20 if ( ML ,CL , BL=0 ) then ( ML+2 , CL +2, BL +1 )Q02if ( ML ,CL , BL=0 ) then ( ML , CL +2, BL +1 )(3)寻找一个启发式函数引导规则的选用右岸总人数6 – ML – CL 两岸中传教士数目>=野人数目f =–∞其它f=3 Q 01f=2 P 02 f=1 Q 01f=1 Q 11f=1 P 01 f=2 P 11 （3，3，1）（3，2，0）（2，2，0）（3，1，0）（3，2，1）（3，0，0） f=3 P 02（3，1，1） f=2 Q 01（1，1，0） f=4 P 20（2，2，1） f=2 Q 11（1，1，0） f=4 P 20（2，2，1） f=2 Q 11（0，2，0） f=4 P 20（0，3，1）f=3 Q 01（0，1，1）f=5 P 02（0，2，1） f=4 Q 01 （0，0，0）f=3 Q 01（1，1，1） f=4 Q 106.2.3 用状态空间法求解传教士和食人者问题例6-2 传教士和食人者问题（The Missionaries and Cannibals Problem）。