农夫过河报告(最终版)
这最起码是一个报
告，虽然我尽力的
看，终究还是看不
懂。
农夫过河算法实验报告
——数据结构项目课研究课题
组长：崔俊
组员：李琦、郑鸿飞、王琅辉、张育博
15.12.29
摘要
农夫过河问题是应用广度优先搜索和深度优先搜索的典型问题，但这里我们应用了简单的数组，通过层层筛选的手段也解决了同样的问题，其中用到了部分广度优先搜索的思想。
前言
农夫过河问题描述：一个农夫带着—只狼、一只羊和—棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和—件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。请求出农夫将所有的东西运过河的方案。
正文
1.问题抽象和数据组织
农夫过河问题应该应用图的广度优先遍历或者深度优先遍历，但这里我们仅使用简单的线性表——数组，通过多重的条件限制，达成目的。这里我们同样用0和1代表农夫、狼、羊、白菜在左岸还是在右岸，并规定0在左，1在右，我们的目的便是从0000通过一系列变换到1111。
2.农夫过河算法源代码
#include
#define MAX 16
typedef struct FWSV
{
int farmer;
int wolf;
int sheep;
int vegetable;
}Item;
//函数原型
//操作：筛选符合条件的安全的数组成员
//操作前：无
//操作后：返回安全数组的指针
void screen(void);
//操作：判断下一个数应该取安全数组中那个数
//操作前: 传递一个结构体数组成员
//操作后：返回另一个结构体数组指针
Item * judge(Item Fwsv);
Item safe[MAX];
int k = 0; //用于计数safe[]中的总数
int main (void)
{
screen();
Item * next;
Item first,second,end;
first = safe[0];
end = safe[k];
printf("first:0000\n");
next = judge(first);
for (int count = 0;count <= 6;count++)
{
if (next->farmer + next->wolf + next->sheep + next->vegetable != 0)
{
second = *next;
next = judge(second);
}
else
next++;
}
printf("end:1111\n");
return 0;
}
void screen(void)
{
int f = 0,w = 0,s = 0,v = 0;
for(f = 0;f < 2;f++)
{
for(w = 0;w < 2;w++)
{
for(s = 0;s < 2;s++)
{
for(v = 0;v < 2;v++)
{
if (!(f != s && (s == w || s == v)))
{
safe[k].farmer = f;
safe[k].wolf = w;
safe[k].sheep = s;
safe[k].vegetable = v;
k++;
}
}
}
}
}
}
Item * judge(Item Fwsv)
{
Item * next;
Item compare[4];
next = compare;
int x1 = 0;
int sum = 0;
if (Fwsv.farmer == 0)
{
for (int x = 0;x < k;x++)
{
//把出现过的置零操作
if(safe[x].farmer == Fwsv.farmer && safe[x].wolf == Fwsv.wolf && safe[x].sheep == Fwsv.sheep && safe[x].vegetable == Fwsv.vegetable )
{
safe[x].farmer = 0;
safe[x].wolf = 0;
safe[x].sheep = 0;
safe[x].vegetable = 0;
}
//筛选出农夫状态值与之前相反的 1变0 0变1
if(safe[x].farmer == 1 && (safe[x].farmer + safe[x].wolf + safe[x].sheep + safe[x].vegetable != 4 ))
{
compare[x1] = safe[x];
x1++;
}
}
for (int x2 = 0;x2 < 4;x2++)
{
//删除状态值与农夫不同但是改变了的
sum = Fwsv.farmer + Fwsv.wolf + Fwsv.sheep + Fwsv.vegetable;
if ((Fwsv.farmer != Fwsv.wolf && compare[x2].wolf != Fwsv.wolf) ||(Fwsv.farmer != Fwsv.sheep && compare[x2].sheep != Fwsv.sheep)
|| (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable)
|| (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable))
{
compare[x2].farmer = 0;
compare[x2].wolf = 0;
compare[x2].sheep = 0;
compare[x2].vegetable = 0;
}
sum+=2;
//对和的限制
if(compare[x2].farmer + compare[x2].wolf + compare[x2].sheep + compare[x2].vegetable != sum)
{
compare[x2].farmer = 0;
compare[x2].wolf = 0;
compare[x2].sheep = 0;
compare[x2].vegetable = 0;
}
}
printf("-----------------------------------------\n");
for(int x3 = 0;x3 < 4;x3++)
{
if (compare[x3].farmer + compare[x3].wolf + compare[x3].sheep + compare[x3].vegetable != 0)
{
printf("上数与：%d%d%d%d相连\n",
compare[x3].farmer,compare[x3].wolf,compare[x3].sheep,compare[x3].veget abl ）;
}
}
}
if (Fwsv.farmer == 1)
{
for (int y = 0;y < k;y++)
{
if(safe[y].farmer == Fwsv.farmer && safe[y].wolf == Fwsv.wolf && safe[y].sheep == Fwsv.sheep && safe[y].vegetable == Fwsv.vegetable )
{
safe[y].farmer = 0;
safe[y].wolf = 0;
safe[y].sheep = 0;
safe[y].vegetable = 0;
}
if(safe[y].farmer == 0 && (safe[y].farmer + safe[y].wolf + safe[y].sheep + safe[y].vegetable != 0 ))
{
compare[x1] = safe[y];
x1++;
}
}
for (int x2 = 0;x2 < 4;x2++)
{
sum = Fwsv.farmer + Fwsv.wolf + Fwsv.sheep + Fwsv.vegetable;
if ((Fwsv.farmer != Fwsv.wolf && compare[x2].wolf != Fwsv.wolf) ||(Fwsv.farmer != Fwsv.sheep && compare[x2].sheep != Fwsv.sheep)
|| (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable)
|| (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable))
{
compare[x2].farmer = 0;
compare[x2].wolf = 0;
compare[x2].sheep = 0;
compare[x2].vegetable = 0;
}
}
printf("-----------------------------------------\n");
for(int x3 = 0;x3 < 4;x3++)
{
if (compare[x3].farmer + compare[x3].wolf + compare[x3].sheep + compare[x3].vegetable != 0)
{
printf("上数与：%d%d%d%d相连\n",
compare[x3].farmer,compare[x3].wolf,compare[x3].sheep,compare[x3].vegetable );
}
}
}
return next;
}
3.算法功能说明和流程描述
首先我们定义了一个结构体Item
typedef struct FWSV
{
int farmer;
int wolf;
int sheep;
int vegetable;
}Item;
Item中包含了农夫（farmer），狼（wolf），羊（sheep），白菜（vegetable）,用来表示农夫、狼、羊、白菜的状态，并作出规定当为0的时候表示在左岸，当为1的时候表示在右岸，我们的目标便是从0000的状态到1111的状态。
接下来用一个调用函数screen（）
void screen(void)
{
int f = 0,w = 0,s = 0,v = 0;
for(f = 0;f < 2;f++)
{
for(w = 0;w < 2;w++)
{
for(s = 0;s < 2;s++)
{
for(v = 0;v < 2;v++)
{
if (!(f != s && (s == w || s == v)))
{
safe[k].farmer = f;
safe[k].wolf = w;
safe[k].sheep = s;
safe[k].vegetable = v;
k++;
}
}
}
}
}
}
函数一连用了4个for循环完成了对0000到1111之间每一位数字的所有排列组合的遍历，虽然这里的时间复杂度直接跃至O(n4)但却是比较全面、写法简单的遍历，而且n仅为2，其中的if语句的判断从所有的排列组合中（总计16种）剔除了不会出现的组合，其中包括：农夫不在，羊吃白菜，狼吃羊等情况。并让符合条件的情况存入了全局变量数组safe[MAX]中。
Item * judge(Item Fwsv)函数是整个算法的核心，思想比较简单但写法繁琐，目的是判断safe[k]数组中符合如题条件的数值，它的参数是上一次的状态值，对于初始时便为0000，它的返回值是一个符合条件的数值的数组首地址next，为了防止有多解的情况我们把符合条件的值存入了一个compare[4]数组，如果为单解则将compare中其他成员置零，接下来我们拆分着看看这个函数。
if (Fwsv.farmer == 0)表示农夫现在在左岸接下来的for循环是对safe[k]数组的遍历，目的是第一轮找出符合条件的值
for (int x = 0;x < k;x++)
{
//这里的if判断是把出现过的值在safe[k]中置零的操作，为了进一步方便判断
if(safe[x].farmer == Fwsv.farmer && safe[x].wolf == Fwsv.wolf && safe[x].sheep == Fwsv.sheep && safe[x].vegetable == Fwsv.vegetable )
{
safe[x].farmer = 0;
safe[x].wolf = 0;
safe[x].sheep = 0;
safe[x].vegetable = 0;
}
//从safe[k]中筛选出农夫状态值与之前相反的并存入compare数组中。因为只有农夫会划船，所以来回农夫的状态必定改变，比如传进来的是0打头的传输出去的必定是1打头的。我们要做的就是从safe[k]中找出农夫状态值与之前相反的数值，总计5个，其中我们把1111的情况也要剔除掉，现在总计4个了，我们把符合要去的数值从16个缩减到10个现在又缩减到4个，接下来我们还要缩减
if(safe[x].farmer == 1 && (safe[x].farmer + safe[x].wolf + safe[x].sheep + safe[x].vegetable != 4 ))
{
compare[x1] = safe[x];
x1++;
}
}
//这里的for便是对compare的遍历了
for (int x2 = 0;x2 < 4;x2++)
{
//上述缩减到4个但是范围还是太大，现在置零状态值与农夫不同但是改变了的。
也就是说如果之前与农夫状态值相同，说明和农夫在相同一侧的岸，这时它才有可能改变的机会，要是与农夫之前与农夫状态值不同，说明和农夫相处对岸，这时它改变了，显然是不符合逻辑的，狼，羊，白菜是不会自己游过河的。
sum = Fwsv.farmer + Fwsv.wolf + Fwsv.sheep + Fwsv.vegetable;
if ((Fwsv.farmer != Fwsv.wolf && compare[x2].wolf != Fwsv.wolf)
||(Fwsv.farmer != Fwsv.sheep && compare[x2].sheep != Fwsv.sheep)
|| (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable) || (Fwsv.farmer != Fwsv.vegetable && compare[x2].vegetable != Fwsv.vegetable)) {
compare[x2].farmer = 0;
compare[x2].wolf = 0;
compare[x2].sheep = 0;
compare[x2].vegetable = 0;
}
sum+=2;
//由于船一次只能拉不超过两个，其中一个还要是农夫划船，所以这里我们对和有一个限制。当农夫拉着东西从左岸划向右岸时，总的状态值之和应该等于上一个状态+现在的状态,而现在的状态和必定为2，所以sum+=2。这里我们举个例子就明白了：0000开始，农夫拉着羊从左岸到右岸变成1010（此时的状态和为2），之后农夫划船回来变成0010（此时状态值为1），接着农夫划船拉着狼从左至右变成1110（此时状态和为3，3 = 1 + 2）......
if(compare[x2].farmer + compare[x2].wolf + compare[x2].sheep + compare[x2].vegetable != sum)
{
compare[x2].farmer = 0;
compare[x2].wolf = 0;
compare[x2].sheep = 0;
compare[x2].vegetable = 0;
}
}
printf("-----------------------------------------\n");
//通过上述三种限制，我们已经可以判断出safe[k]中完全符合要求的数值了，可能有一个，可能有两个，也可能多个，接下来的for遍历compare并打印我们需要的结果for(int x3 = 0;x3 < 4;x3++)
{
if (compare[x3].farmer + compare[x3].wolf + compare[x3].sheep + compare[x3].vegetable != 0)
{
printf("上数与：%d%d%d%d相连\n",
compare[x3].farmer,compare[x3].wolf,compare[x3].sheep,compare[x3].vegetabl ）
}
}
}
if (Fwsv.farmer == 1)
{
/*表示农夫现在在右岸接下来的for循环是对safe[k]数组的遍历，目的是第一轮找出符合条件的值，与Fwsv.farmer == 0的情况一样，判断方法与条件也完全相同，只不过对于0打头的情况省去了对和的限制这一条件*/
}
4.算法实现与验证
首先0000传入judge函数，返回1010，表示0000与1010相连，接下来1010传入，返回0010，现在0000----1010----0010，接下来0010传入，返回1011和1110两个，表示0000----1010----0010----1011和1110，我们只取第一个，1011传入，返回0001，传入
0001，返回1101，现在是0000----1010----0010----1011（还有1110）----0001----1101，接下来传入1101，返回0100和0101，同理只取第一个，传入0100，返回1110，至此结束整个传递，到达1111的状态
这些数字看着有些不清晰，我们来整理下
整理得
通过图示我们发现农夫过河有两种解
（1）农夫、狼、羊、白菜开始都在左岸0000，农夫拉羊从左岸到右岸1010，农夫自己从右岸到左岸0010，农夫拉着白菜从左岸到右岸1011，农夫把羊从右岸拉回左岸0001，农夫拉着狼从左岸到右岸1101，农夫自己从右岸到左岸0101，农夫拉着羊从左岸到右岸1111。
（2）农夫、狼、羊、白菜开始都在左岸0000，农夫拉羊从左岸到右岸1010，农夫自己从右岸到左岸0010，农夫拉着狼从左岸到右岸1110，农夫把羊从右岸拉回左岸0100，农夫拉着白菜从左岸到右岸1101，农夫自己从右岸回到左岸0101，农夫拉着羊从左岸到右岸1111。
5.算法性能分析
本算法性能比较低，因为是一次次遍历，筛选，最后确定符合条件的值。但算法偏向正常思维，较简单，且节省了很大内存，整个过程均建立在对safe[k]数组和compare[k]的操作。不过唯一感到不满意的地方是之前为电脑计算了好多，算法的性能还有待优化。
农夫过河数据结构
郑州轻工业学院 课程设计任务书 题目农夫过河 专业、班级计算机科学与技术 学号姓名 主要内容： 一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸，要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜；否则狼会吃羊，羊会吃白菜。所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不能吃白菜。要求给出农夫将所有的东西运过河的方案。基本要求: 编写求解该问题的算法程序，并用此程序上机运行、调试，屏幕显示结果，能结合程序进行分析。 主要参考资料: 数据结构严蔚敏 完成期限：2012/6/21 指导教师签名： 课程负责人签名： 年月日
郑州轻工业学院 本科 数据结构课程设计总结报告 设计题目：农夫过河 学生姓名： 系别：计算机与通信工程学院 专业：计算机科学与技术 班级：计算机科学与技术 学号： 指导教师： 2012年6 月21 日
一，设计题目 问题描述： 一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸，他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜；否则狼会吃羊，羊会吃白菜。所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不能吃白菜。要求给出农夫将所有的东西运过河的方案。 二，运行环境（软、硬件环境） VC6.0 Windows7系统 三，算法设计的思想 对于这个问题，我们需要先自动生成图的邻接矩阵来存储，主要方法是先生成各种安全状态结点，存放在顶点向量中；再根据判断两个结点间状态是否可以转换来形成顶点之间的所有边，并把它们保存在邻接矩阵中。在建立了图的邻接矩阵存储结构后，利用递归深度优先搜索求出从顶点（0，0，0，0）到顶点（1，1，1，1）的一条简单路径，这样做只能搜到一种合理方法，因为深度优先搜索遍历一个图的时候每一个结点只能被访问一次。 四，算法的流程图 要写算法的流程图，必须要先很了解自己的函数结构，我先在纸上手动的把整个过程在纸上画一遍，了解它的大体流程，然后把各个函数给分开，下面是我自己根据我的代码中画的各个函数画的流程图，希望老师满意。 主函数的流程图：
人工智能实验一指导
实验1: Prolog语言程序设计 人工智能（AI）语言是一类适应于人工智能和知识工程领域的、具有符号处理和逻辑推理能力的计算机程序设计语言。能够用它来编写求解非数值计算、知识处理、推理、规划、决策等具有智能的各种复杂问题。 Prolog是当代最有影响的人工智能语言之一，由于该语言很适合表达人的思维和推理规则，在自然语言理解、机器定理证明、专家系统等方面得到了广泛的应用，已经成为人工智能应用领域的强有力的开发语言。 尽管Prolog语言有许多版本，但它们的核心部分都是一样的。Prolog的基本语句仅有三种，即事实、规则和目标三种类型的语句，且都用谓词表示，因而程序逻辑性强，方法简捷，清晰易懂。另一方面，Prolog是陈述性语言，一旦给它提交必要的事实和规则之后，Prolog就使用内部的演绎推理机制自动求解程序给定的目标，而不需要在程序中列出详细的求解步骤。 一、实验目的 1、加深学生对逻辑程序运行机理的理解。 2、掌握Prolog语言的特点、熟悉其编程环境。 3、为今后人工智能程序设计做好准备。 二、实验内容 1、编写一个描述亲属关系的Prolog程序，然后再给予出一些事实数据，建立一个小型演绎数据库。 提示：可以以父亲和母亲为基本关系（作为基本谓词），再由此来描述祖父、祖母、兄弟、姐妹以及其他所属关系。 2、编写一个路径查询程序，使其能输出图中所有路径。 提示：程序中的事实描述了下面的有向图，规则是图中两节点间通路的定义。 e
3、一个雇主在发出招聘广告之后，收到了大量的应聘申请。为了从中筛选出不量的候选人，该雇主采用下列判据：申请者必须会打字、开车，并且住在伦敦。 （a）用Prolog规则表述这个雇主的选择准则。 （b）用Prolog事实描述下列申请者的情况： 史密斯住在剑桥，会开车但不会打字。 布朗住在伦敦，会开车也会打字。 简住在格拉斯哥，不会开车但会打字。 埃文斯住在伦敦，会开车也会打字。 格林住在卢顿，会开车也会打字。 （c）要求Prolog提供一个候选人名单。 4、实现递归谓词remove(X,Y,Z),它用于从表Y中除去所有整型数X的倍数值后得到新表Z。例如，对于询问 remove(2,[3,4,5,6,7,8,9,10],Z). 的回答为： Z=[3,5,7,9] 三、实验建议 1、首先运行Prolog安装目录中PROGRAM目录下的示例程序，对Prolog功能有一个感性认识。 （1）HANOI．PRO 实现汉诺塔演示的程序。 程序运行界面如图所示。
商人过河实验报告
数学模型实验—实验报告6 学院：工商学院专业：电气二类（计算机）姓名：辛文辉尚磊张亨 学号：___ 2012484019 2012484091 2012484055 ____ 实验时间：__ 3.18 ____ 实验地点：b3 一、实验项目： Matlab程序设计 安全渡河问题可以看成一个多步决策过程。每一步，即船由此岸驶向彼岸或从彼岸驶回此岸，都要对船上的人员(商人随从各几人)作出决策，在保证安全的前提下(两岸的商人数都不比随从数少)，在有限步内使人员全部过河。用状态(变量)表示某一岸的人员状况，决策(变量)表示船上的人员状况，可以找出状态随决策变化的规律。问题转化为在状态的允许变化范围内(即安全渡河条件)，确定每一步的决策，达到渡河的目的。 此类智力问题经过思考，可以拼凑出一个可行方案。但是，我们现在希望能找到求解这类问题的规律性，并建立数学模型，用以解决更为广泛的问题。 二、实验目的和要求 a.了解Matlab程序设计有关基本操作 b.掌握有关程序结构 三、实验内容
允许的状态向量 0 0 0 1 0 2 0 3 0 4 0 5 0 6 0 7 0 8 0 9 0 10 0 11 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 0 11 1 11 2
11 3 11 4 11 5 11 6 11 7 11 8 11 9 11 10 允许的决策向量: 0 1 0 2 0 3 0 4 0 5 0 6 1 0 1 1 2 0 2 1 2 2 3 0 3 1 3 2 3 3 4 0 4 1 4 2 5 0 5 1 6 0 过河步骤： 第1步：0商5仆过河，0商1仆返回 第2步：5商1仆过河，1商1仆返回 第3步：3商3仆过河，1商1仆返回 第4步：3商3仆过河，1商1仆返回 第5步：3商3仆过河，完成 过河过程中状态变化： 步骤此岸商此岸仆方向彼岸商彼岸仆 1 11 6 ==> -8 -3
人工智能实验报告
计算机科学与技术1341901301 陈敏 实验一：知识表示方法 一、实验目的 状态空间表示法是人工智能领域最基本的知识表示方法之一，也是进一步学习状态空间搜索策略的基础，本实验通过牧师与野人渡河的问题，强化学生对知识表示的了解和应用，为人工智能后续环节的课程奠定基础。 二、问题描述 有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数(除非牧师人数为0)，且假定野人与牧师都会划船，试设计一个算法，确定他们能否渡过河去，若能，则给出小船来回次数最少的最佳方案。 三、基本要求 输入：牧师人数(即野人人数)：n；小船一次最多载人量：c。 输出：若问题无解，则显示Failed，否则，显示Successed输出一组最佳方案。用三元 组(X 1, X 2 , X 3 )表示渡河过程中的状态。并用箭头连接相邻状态以表示迁移过程：初始状态-> 中间状态->目标状态。 例：当输入n=2，c=2时，输出：221->110->211->010->021->000 其中：X 1表示起始岸上的牧师人数；X 2 表示起始岸上的野人人数；X 3 表示小船现在位置(1表 示起始岸，0表示目的岸)。 要求：写出算法的设计思想和源程序，并以图形用户界面实现人机交互，进行输入和输出结果，如： Please input n: 2 Please input c: 2 Successed or Failed?: Successed Optimal Procedure: 221->110->211->010->021->000 四、算法描述
农夫过河问题状态图及程序
农夫过河问题状态图及程序 一、问题需求分析 一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。问题是他面前只有一条小船，船小到只能容下他和一件物品，另外只有农夫能撑船。另外，因为狼能吃羊，而羊爱吃白菜，所以农夫不能留下羊和白菜或者狼和羊单独在河的一边，自己离开。请问农夫该采取什么方案才能将所有的东西运过河呢？ 二、算法选择 求解这个问题的最简单的方法是一步一步进行试探，每一步都搜索所有可能的选择，对前一步合适的选择再考虑下一步的各种方案。 用计算机实现上述求解的搜索过程可以采用两种不同的策略：一种是广度优先(breadth_first) 搜索，另一种是深度优先(depth_first) 。 广度优先： u 广度优先的含义就是在搜索过程中总是首先搜索下面一步的所有可能状态，然后再进一步考虑更后面的各种情况。u 要实现广度优先搜索，一般都采用队列作为辅助结构。把下一步所有可能达到的状态都列举出来，放在这个队列中，
然后顺序取出来分别进行处理，处理过程中把再下一步的状态放在队列里……。 u 由于队列的操作遵循先进先出的原则，在这个处理过程中，只有在前一步的所有情况都处理完后，才能开始后面一步各情况的处理。 三、算法的精化 要模拟农夫过河问题，首先需要选择一个对问题中每个角色的位置进行描述的方法。一个很方便的办法是用四位二进制数顺序分别表示农夫、狼、白菜和羊的位置。例如用0表示农夫或者某东西在河的南岸，1表示在河的北岸。因此整数5(其二进制表示为0101) 表示农夫和白菜在河的南岸，而狼和羊在北岸。 四、算法的实现 完成了上面的准备工作，现在的问题变成： 从初始状态二进制0000(全部在河的南岸) 出发，寻找一种全部由安全状态构成的状态序列，它以二进制1111(全部到达河的北岸) 为最终目标，并且在序列中的每一个状态都可以从前一状态通过农夫（可以带一样东西）划船过河的动作到达。
MC牧师过河问题
人工智能上机实验报告 学号：姓名：所在系：信息学院班级： 实验名称：实验日期2016年12月3日 实验指导教师实验机房A401 ------------------------------------------------------------------------------------------------------ 1.实验目的： (1)在掌握状态空间搜索策略的基础上，理解知识表示的方法。 (2)能够应用知识表示方法，解决实际问题 2. 实验内容： (1)M-C问题描述 有n个牧师和n个野人准备渡河，但只有一条能容纳c个人的小船，为了防止野人侵犯牧师，要求无论在何处，牧师的人数不得少于野人的人数(除非牧师人数为0)，且假定野人与牧师都会划船，试设计一个算法，确定他们能否渡过河去，若能，则给出小船来回次数最少的最佳方案。 3．算法设计（编程思路或流程图或源代码） #include
农夫过河和骑士周游(数据结构课程设计)教学内容
1:实验要求 1.1实验目的 掌握图的遍历问题，运用图的遍历算法解决复杂问题。掌握并应用邻接存储结构和图的深度遍历问题。培养学习使用图的相关知识解决实际问题的能力。 1.2实验内容问题描述 问题描述：农夫携带一只狼，一只羊，一棵白菜从和的左岸到达河的右岸，由于船只较小，农夫每次只能携带一样过河，在无人看管的情况下狼吃羊，羊吃白菜。 1.3：实验输出要求 要求输出农夫携带所有东西安全过河的步骤。 2：程序设计分析 2.1：实验内容分析 农夫需要多次驾船往返于河的左右两岸，农夫每次过河都会使农夫，狼，羊，白菜的位置发生变化。利用四元组（农夫，狼，羊，白菜）来表示各自所处于河的左岸右岸的位置，0表示河的左岸，1表示河的右岸。初始状态时（0,0,0,0）都处在河的左岸，终态是（1，1,1,1）四者都处在河的右岸。 共有16种状态，但其中有些状态不安全，删除不安全的状态，将安全的状态按照合理的过河步骤联系起来. （0,0,0，0） (1,0,1,0) (0,0,1,0) (1,1,1,0) (1,0,1,1) (0,1,0,0) (0,0,0,1) (1,1,0,1) (0,1,0,1) (1,1,1,1) 安全过河状态图 2.2主要函数模块算法分析
1：栈的相关函数 PSeqStack Init_SeqStack(void) //栈的初始化 int Empty_SeqStack(PSeqStack s) //判断栈是否为空栈非空1表示栈空 void Push_SeqStack(PSeqStack s,int x) //入栈 int Pop_SeqStack(PSeqStack s,int *x) //出栈 int Size_SeqStack(PSeqStack s) //顺序栈中元素的个数 void Destroy_SeqStack(PSeqStack *S) //销毁栈 2,：求结点直接后继结点个数的函数 int CountAdjoin(MGraph *G,int u) 3：查找状态(f,w,s,v)在无向图中的位置的函数 int located(MGraph *G,int f,int w,int s,int v) 4：结点值安全状态判断函数 int if_safe(int f,int w,int s,int v) 5：判断农夫过河的两个状态是否是相邻的函数 int if_connected(MGraph *G,int i,int j) 6：创建农夫过河状态的无向图 void Creat_MGraph(MGraph *G) 7：广优度先遍历遍历所有从状态下标u到状态下标v的路径函数 void BFS_path(MGraph *G,int u,int v) 8：输出所有从状态下标为u到状态下标为v的所有简单路径 void print_path(MGraph *G,int u,int v) 2.3部分函数源代码 path[u][m] 为状态下标u的直接后继状态下标 m表示状态下标u的直接后继结点个数：int path[MaxVertexNum][MaxVertexNum]; 主要结构：typedef struct { int farmer; int wolf; int sheep; int vegetable;
C# 关于农夫过河的问题
课程设计第五题 1．题目探讨农夫过河的问题 2.设计思路 （1）农夫由A到B的情况 （1）带走一个动物后，另外的两个物是不是可以相吃 （2）会不会把刚带回来的又带到对岸去 （3）最后一次带的情况比较的特殊，判断最后一次走后是不是所有的都不在了对岸 （2）农夫从B到A的情况 （1）对岸是不是只有一个物体 （2）对岸是不是有两个物体，若是有两个物体的话他们的处理方式不一样，1。两个物体会相克的，则把羊带走，2如果不是的话那么农夫就空着手回去。 3．应该注意的问题 （1）。在最后的一次带走羊的时候，应该加如一个新的判段 （2）。以及在带回羊的时候，我们要对其进行一个标记，不然的话我们就很容易进行死循环里面 （3）以及每一次从A带东西去B的时候，我们都要对他的位置进行标记下 4．咸受 在对一个问题分析的时候，我们应该先把每一种情况给分析出来，要把问题分析得分面一些，最好是不要落下任何的一种情况，这样我们就可以对每一种情况编写相应的代码了。5．源代码 static int sum(int[] a) { int sum = 0; for (int i = 0; i < a.Length; i++) { sum = sum + a[i]; } return sum; } static void Main(string[] args) { string[] wu = new string[4] { "农夫", "狼", "羊", "白菜" }; int[] a = new int[4] { 3, 1, -1, 1 }; int[] b = new int[4] { 0, 0, 0, 0 }; Console.WriteLine(" 关于农夫过河的问题"); int weizhi = 0; do { if (a[0] == 3) {
农夫过河实验报告――数据结构
数据结构实验报告 ——实验四农夫过河的求解本实验的目的是进一步理解顺序表和队列的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。 一、【问题描述】 一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。请求出农夫将所有的东西运过河的方案。 二、【数据结构设计】 求解这个问题的简单的方法是一步一步进行试探，每一步搜索所有可能的选择，对前一步合适的选择再考虑下一步的各种方案。 要模拟农夫过河问题，首先需要对问题中每个角色的位置进行描述。一个很方便的办法是用四位二进制数顺序分别表示农夫、狼、白菜和羊的位置。用0表示农夫或者某东西在河的南岸，1表示在河的北岸。例如整数5(其二进制表示为0101)表示农夫和白菜在河的南岸，而狼和羊在北岸。 现在问题变成：从初始状态二进制0000(全部在河的南岸)出发，寻找一种全部由安全状态构成的状态序列，它以二进制1111(全部到达河的北岸)为最终目标，并且在序列中的每一个状态都可以从前一状态到达。为避免瞎费功夫，要求在序列中不出现重复的状态。 实现上述求解的搜索过程可以采用两种不同的策略：一种是广度优先(breadth_first)搜索， 另一种是深度优先(depth_first)搜索。本书只介绍在广度优先搜索方法中采用的数据结构设计。 广度优先就是在搜索过程中总是首先搜索下面一步的所有可能状态，再进一步考虑更后面的各种情况。要实现广度优先搜索，可以使用队列。把下一步
数学模型实验商人过河
《数学模型实验》实验报告 姓名：王佳蕾学院：数学与信息科 学学院 地点：主楼402 学号：055专业：数学类时间：2017年4 月16日 实验名称： 商人和仆人安全渡河问题的matlab实现 实验目的： 1.熟悉matlab基础知识，初步了解matlab程序设计； 2.研究多步决策过程的程序设计方法； 3.（允许）状态集合、（允许）决策集合以及状态转移公式的matlab表示；实验任务： 只有一艘船，三个商人三个仆人过河，每一次船仅且能坐1-2个人，而且任何一边河岸上仆人比商人多的时候，仆人会杀人越货。怎么在保证商人安全的情况下，六个人都到河对岸去，建模并matlab实现。 要求：代码运行流畅，结果正确，为关键语句加详细注释。 实验步骤： 1.模型构成 2.求决策 3.设计程序 4.得出结论（最佳解决方案） 实验内容： （一）构造模型并求决策
设第k次渡河前此岸的商人数为xk，随从数为yk，k=1,2,...，xk，yk=0,1,2,3.将二维向量sk=（xk，yk）定义为状态，安全渡河条件下的状态集合称为允许状态集合，记作S，S 对此岸和彼岸都是安全的。 S={(x,y)|x=0,y=0,1,2,3;x=3,y=0,1,2,3;x=y=1,2} 设第k次渡船上的商人数为uk，随从数vk，将二维变量dk=（uk，vk）定义为决策，允许决策集合记为D,由小船的容量可知， D={(u,v)|1<=u+v<=2,u,v=0,1,2} k为奇数时，船从此岸驶向彼岸，k为偶数时，船从彼岸驶向此岸，状态sk随决策变量dk的变化规律为sk+1=sk+(-1)^k*dk（状态转移律） 这样制定安全渡河方案归结为如下的多步决策模型： 求决策dk∈D(k=1,2,...,n)，使状态sk∈S，按照转移律，由初始状态s1=（3,3）经有限步n到达状态sn+1=（0,0）。 （二）程序设计
农夫过河实验报告
“数据结构与算法综合实验”课程设计报告题目：农夫过河问题 学院计算机科学技术 年级2014级 专业计算机科学与技术 学号20142060 姓名高晗 日期2016年3月30日星期三 成绩 评语 黑龙江大学 计算机科学技术学院、软件学院
《数据结构与算法综合实验》报告 1.系统概述 （1）一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸，他要把这些东西全部运到北岸。他面前只有一只小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜；否则狼会吃羊，羊会吃白菜。所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，但是狼不吃白菜。要求给出农夫将所有东西运过河的方案。 （2）为农夫过河问题抽象数据模型，体会数据模型在求解问题中的重要作用。 （3）掌握顺序表和队列的逻辑结构和存储结构。 2.系统需求分析 (1)针对实现整个过程需要多步，不同步骤中各个事物所处位置不同的情况，可定义一个结构体来实现对四个对象狼、羊、白菜和农夫的表示。对于起始岸和目的岸，可以用0或者1来表示，以实现在程序设计中的简便性。 (2)题目要求给出四种事物的过河步骤，没有对先后顺序进行约束，这就需要给各个事物依次进行编号，然后依次试探，若试探成功，进行下一步试探。这就需要使用循环或者递归算法，避免随机盲目运算且保证每种情况均试探到，不接受非法输入。 (3)题目要求求出农夫带一只羊，一条狼和一颗白菜过河的办法，所以依次成功返回运算结果后，需要继续运算，直至求出结果，即给出农夫的过河方案。输出界面要求具有每一步中农夫所带对象及每步之后各岸的物体，需要定义不同的数组来分别存储上述内容，并使界面所示方案清晰简洁。 (4)实验运行环境为VC++6.0. 3.系统概要设计 (1)数据结构设计 要模拟农夫过河的问题，用四位二进制数顺序分别表示农夫，狼，羊，白菜的位置。用0表示农夫或某种东西在河的南岸，1表示在河的北岸。则问题的初
LAB05+队列的操作及应用
Lab05．队列的操作及应用 【实验目的和要求】 1．掌握队列的顺序表示和链表表示下的基本操作； 2．深入理解深度优先搜索和广度优先搜索的思想并能正确描述其算法； 3．会应用广度优先搜索算法解决较复杂的问题。 【实验内容】 1．编写一个C源程序，其中包含顺序表示的空队列的创建、判断队列是否为空、进队、出队、取队列头部元素等操作。 2．编写一个C源程序，其中包含链表表示的空队列的创建、判断队列是否为空、进队、出队、取队列头部元素等操作。 3. 简述深度优先搜索和广度优先搜索的思想，并给出具体的算法步骤。 4．应用广度优先搜索算法求解农夫过河问题。 【实验仪器与软件】 1．CPU主频在1GHz以上，内存在512Mb以上的PC； 2．VC6.0，Word 2003及以上版本。 实验讲评： 实验成绩： 评阅教师： 2012 年月日
Lab05．队列的操作及应用 一、顺序表示的队列基本操作 1．顺序表示的队列操作基本源程序 #include
研究性学习实验报告
研究性学习实验报告 课题名称：有关全息投影的研究 班级：1403班 小组组长：郭嘉昕 小组成员：郭京伟段泽华王捷聪孙泽錡 日期：2015年3月
有关全息投影的实验报告
第一部分 有关实验选材的研究 一、实验设计思想 （1）实验目的 通过对比，研究不同材料对于光线的折射和漫反射的效果，并且在其中寻找效果最佳、性价比高的材料，进行下一步实验。 （2）实验原理 当一束平行的入射光线射到粗糙的表面时，表面会把光线向着四面八方反射，所以入射线虽然互相平行，由于各点的法线方向不一致，造成反射光线向不同的方向无规则地反射，这种反射称之为“漫反射”。 （3）实验方法 从成本方面考虑，先将不同材料做成面积的板状模型和立方体状模型，再将我们的光源设备调节到最高亮度，以最佳效果的角度将画面投射到不同的材料上。在同样暗度的房间里，用高度、距离固定的摄影机进行拍摄，再将不同材料的照片转入Photoshop,通过其内置的亮度数值初步判断不同材料的反射效果。将亮度（p）、材料制作的难易程度(q)以及其它视觉效果(w)三项各10分的标准分数按一定比例绘制出总分数，来选取实验材料。
实验测量表格如下： （4）实验仪器：各种实验材料*1、投影光源（4.7英寸）*1、摄像机*1、Windows电脑（Photoshop软件）*1 二、实验过程记录 （1）实验分工 （2）实验步骤
第一步—确定材料。因为我们是初次进行研究，对于具体的实验材料并不能确定，所以我们进行了解后，一共选取了4种材料： 第二步--选取材料。因为我们进行的实验成本非常有限所以我们必须先走向市场，来查看和询问有些材料是否可以被加工和购买到（具体材料价格请见附录）。将他们的难易程度（q）进行量化，10分为很容易得到，1分为基本不可能得到，以此绘制表格： 第三步—对比亮度。在了解了我们选取的材料的基础上，以节约环保为本，我们购买或借到了这四种材料。并选择在2015年3月8日的晚上，在教室里进行亮度测试。我们先将光源设备调节到最大亮度，拍摄的得到了一张照片，再不断尝试不同的角度，以求能用最好的效果反射光源并拍摄下来。我们将五张照片导入电脑，用Photoshop软件分别查看他们的RGM指数（具体RGM指数请见附录），来进行评分，但因为镜子的超好反射效果，我们改进了我们算法，以分段函数的方式来进行得分评判（p）。 评分结果如下
农夫过河问题
课程设计题目：农夫过河 一．问题描述 一个农夫带着一只狼、一只羊和一箩白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。过河有以下规则： (1)农夫一次最多能带一样东西（或者是狼、或者是羊、或者是白菜）过河； (2)当农夫不在场是狼会吃羊； (3)当农夫不在场是羊会吃掉白菜。 现在要求为农夫想一个方案，能将3样东西顺利地带过河。从出事状态开始，农夫将羊带过河，然后农夫将羊待会来也是符合规则的，然后农夫将羊带过河仍然是符合规则的，但是如此这般往返，搜索过程便进入了死循环，因此，在这里，采用改进的搜索算法进行搜索。 二．基本要求 (1)为农夫过河问题抽象数据类型，体会数据模型在问题求解中的重要性； (2)要求利用数据结构的方法以及Ｃ＋＋的编程思想来完成问题的综合设 计； (3)在问题的设计中，使用深度优先遍历搜索方式，避免死循环状态； (4)设计一个算法求解农夫过河问题，并输出过河方案； (5)分析算法的时间复杂度。 三．概要设计 (1)数据结构的设计 typedef struct // 图的顶点 { int farmer; // 农夫 int wolf; // 狼 int sheep; // 羊 int veget; // 白菜 }Vertex;
设计Vertex结构体的目的是为了存储农夫、狼、羊、白菜的信息，因为在遍历图的时候，他们的位置信息会发生变化，例如1111说明他们都在河的北岸，而0000说明他们都在河的南岸。 t ypedef struct { int vertexNum; // 图的当前顶点数 Vertex vertex[VertexNum]; // 顶点向量（代表顶点） bool Edge[VertexNum][VertexNum]; // 邻接矩阵. 用于存储图中的边，其矩阵元素个数取决于顶点个数，与边数无关 }AdjGraph; // 定义图的邻接矩阵存储结构 存储图的方法是用邻接矩阵，所以设计一个简单的AdjGraph结构体是为了储图的顶点数与边数，农夫过河问题我采用的是图的深度优先遍历思想。 (2)算法的设计 深度优先遍历基本设计思想：设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的1/12边(x，y)。若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y)到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选择一条从x出发的未检测过的边。上述过程直至从x出发的所有边都已检测过为止。此时，若x不是源点，则回溯到在x之前被访问过的顶点；否则图中所有和源点有路径相通的顶点(即从源点可达的所有顶点)都已被访问过，若图G是连通图，则遍历过程结束，否则继续选择一个尚未被访问的顶点作为新源点，进行新的搜索过程。 程序中的深度优先遍历算法如下： void dfsPath(AdjGraph *graph, int start, int end) // 深度优先搜索从u到v的简单路径 //DFS--Depth First Search { int i = 0; visited[start] = true; //标记已访问过的顶点 if (start == end)
PROLOG实验报告
*******大学 实验报告| | 实验名称PROLOG语言练习与编程上机实验 课程名称人工智能及应用 | | 专业班级：*******学生姓名：****** 学号：*******成绩： 指导教师：*******实验日期：
一、实验目的及要求 1、熟悉并掌握prolog的编程环境、prolog语言的回溯、递归技术和表处理技 术； 2、运用prolog及其相关技术，编写并调试求解农夫过河和模式搜索问题的程 序。要求实验报告中包括：程序及其注释和说明、程序运行结果。 二、所用仪器、设备 PC台式机和prolog编译软件 三、实验原理 1、prolog本身自带推理机，其回溯、递归技术和表处理技术可简化复杂问 题求解。 2、prolog的跟踪、设断点对于调试程序是非常有用的。 四、求解的问题与程序 农夫过河问题 opposite(s,n). opposite(n,s). safe_goat(X,_,X,_). safe_cabbage(X,_,_,X). safe_goat(F,X,Y,_):-opposite(X,Y). safe_cabbage(F,_,X,Y):-opposite(X,Y). is_peaceful(F,W,G,C):-safe_goat(F,W,G,C),safe_cabbage(F,W,G,C). transform(location(X,W,G,C),location(Y,W,G,C)):-opposite(X,Y). transform(location(X,X,G,C),location(Y,Y,G,C)):-opposite(X,Y). transform(location(X,W,X,C),location(Y,W,Y,C)):-opposite(X,Y). transform(location(X,W,G,X),location(Y,W,G,Y)):-opposite(X,Y). member(X,[X|_]). member(X,[_|T]):-member(X,T). legal_states(location(F0,W0,G0,C0),location(F,W,G,C),States,X):- transform(location(F0,W0,G0,C0),location(F1,W1,G1,C1)),
趣味数学教案—农夫过河
农夫过河 教学目标 1、知识与能力：通过农夫过河的数学逻辑问的题，探讨研究找到解决问题的办法和养成自己动脑动手的解决问题的能力。 2、过程与方法：通过以角色扮演的形式让学生自己动脑动手寻找答案和探讨解决问题的方法。 3、态度价值观：知道数学有很多有趣的东西，培养爱科学的情感。教师准备 1. 数学课件。 2、做“狼、羊、白菜、农夫”头饰。 3、准备四张纸分别写上“狼、羊、白菜、农夫”。 教学过程 一、谈话导入 介绍我国著名的数学家华罗庚爷爷。 数学家华罗庚生平介绍，主要科学业绩，对数学的贡献等等。介绍华罗庚爷爷的话。“数学本身，也是无穷的美妙，认为数学枯燥，是不正确的，就像站在花园外面，说花园枯燥无味一样，只要你踏进大门，随时会发现数学有许多有趣的东西。”数学并不是几个数字算来算去，它的学问大着呢。下面这道题能引起你的兴趣吗？ 二、创设情境 1、出示数学问题：有一个农夫带一匹狼、一只羊和一棵白菜过河（从河的东岸到西岸）。如果没有农夫看管，则狼要吃羊，羊要吃白菜。
但是船很小，只够农夫带一样东西过河。 2、图片演示。（一条河；一边是对岸；另一边是河岸，有农夫、狼、羊、白菜） 三、探究学习 1、以小组表演形式（演示出河的位置）和讨论形式解题 第一步是什么？必须是什么？（农夫和羊先过河） 第二步是什么？（农夫自己回来） 第三步是什么？ 2、全班学生汇报交流 问题的突破口在——狼与白菜能够共存！农夫、狼、羊、白菜和船组成了这个系统。系统中各要素是一个整体，都依赖农夫过河；最大的问题是“船很小，只够农夫带一样东西过河”和“没有农夫看管，则狼要吃羊，羊要吃白菜”的冲突。我们联系已知条件，做了一系列的分析实验，但是比较其他方案不能实现所有要素都安全过河。最后得出以上方案。 具体描述如下： 第一步：把羊带过河，坐船返回； 第二步：把狼带过河，带羊返回； 第三步：将羊放在这一岸后，带白菜过河； 第四步：坐船返回，把羊带过河。 或者： 第一步：把羊带过河，坐船返回；
数据结构课程设计报告(农夫过河)
目录 引言 (2) 1 问题描述 (3) 基本要求 (3) 2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性； (3) 2.2设计一个算法求解农夫过河问题，并输出过河方案； (3) 3 概要设计 (3) 3.1数据结构的设计。 (3) 3.1.1农夫过河问题的模型化 (3) 3.1.2 算法的设计 (4) 4、运行与测试 (6) 5、总结与心得 (7) 附录 (7) 参考文献 (13)
引言 所谓农夫过河问题是指农夫带一只狼、一只羊和一棵白菜在河南岸, 需要安全运到北岸。一条小船只能容下他和一件物品, 只有农夫能撑船。问农夫怎么能安全过河, 当然狼吃羊, 羊吃白菜, 农夫不能将这两种或三种物品单独放在河的一侧, 因为没有农夫的照看, 狼就要吃羊, 而羊可能要吃白菜? 这类问题的实质是系统的状态问题, 要寻求的是从初始状态经一系列的安全状态到达系统的终止状态的一条路径。
1 问题描述 一个农夫带一只狼、一棵白菜和一只羊要从一条河的南岸过到北岸，农夫每次只能带一样东西过河，但是任意时刻如果农夫不在场时，狼要吃羊、羊要吃白菜，请为农夫设计过河方案。 基本要求 2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性； 2.2设计一个算法求解农夫过河问题，并输出过河方案； 3 概要设计 3.1 数据结构的设计。 3.1.1农夫过河问题的模型化 分析这类问题会发现以下特征: 有一组状态( 如农夫和羊在南, 狼和白菜在北) ; 从一个状态可合法地转到另外几个状态( 如农夫自己过河或农夫带着羊过河) ; 有些状态不安全( 如农夫在北, 其他东西在南) ; 有一个初始状态( 都在南) ; 结束状态集( 这里只有一个, 都在北) 。 问题表示: 需要表示问题中的状态, 农夫等位于南P北( 每个有两种可能) 。可以采用位向量, 4 个二进制位的0P1 情况表示状态, 显而易见, 共24= 16种可能状态。从高位到低位分别表示农夫、狼、白菜和羊。0000( 整数0) 表示都在南岸, 目标状态1111( 即整数15) 表示都到了北岸。有些状态0011,0101, 0111, 0001, 1100, 1001 是不允许出现的, 因为这些状态是不安全状态。根据上述条件可以画出系统的状态图如图1 所示。 图1 系统状态转换图 其中双向的箭头表示状态可逆, 即农夫可以带 着某种东西过去, 也可以带着该东西回来。箭头上的字母表示农夫所携带的东西: f( farmer) , w(wolf) , g(goat) , c( cabbage) 分别表示农夫自己、农夫携带狼、农夫携带羊、农夫携带菜过河。现在的问题转化为: 找一条合法路径( 相邻状态之间的转移合法) , 从开始状态到某个结束状态, 途中不经过不安全状态。
数据结构课程设计农夫过河问题
扬州大学信息工程学院 《数据结构》 ---课程设计报告 题目：农夫过河 班级：网络1501 学号：1524 姓名：王 指导教师：王
一、课程题目 一个农夫带着一只狼，一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。 二、需求分析 求出农夫将所有的东西运过河的方案。 三、概要设计 求解这个问题的简单的方法是一步一步进行试探，每一步搜索所有可能的选择，对前一步合适的选择再考虑下一步的各种方案。要模拟农夫过河问题，首先需要对问题中每个角色的位置进行描述。一个很方便的办法是用四位二进制数顺序分别表示农夫、狼、白菜和羊的位置。用0表示农夫或者某东西在河的南岸，1表示在河的北岸。例如整数5(其二进制表示为0101) 表示农夫和白菜在河的南岸，而狼和羊在北岸。现在问题变成：从初始状态二进制0000(全部在河的南岸) 出发，寻找一种全部由安全状态构成的状态序列，它以二进制1111(全部到达河的北岸)为最终目标，并且在序列中的每一个状态都可以从前一状态到达。为避免瞎费功夫，要求在序列中不出现重复的状态。 四、详细设计 实现上述求解的搜索过程可以采用策略广度优先(breadth_first) 搜索。广度优先就是在搜索过程中总是首先搜索下面一步的所有可能状态，再进一步考虑更后面的各种情况。要实现广度优先搜索，可以使用队列。把下一步所有可能的状态都列举出来，放在队列中，再顺序取出来分别进行处理，处理过程中把再下一步的状态放在队列里。由于队列的操作遵循先进先出的原则，在这个处理过程中，只有在前一步的所有情况都处理完后，才能开始后面一步各情况的处理。这样，具体算法中就需要用一个整数队列moveTo，它的每个元素表示一个可以安全到达的中间状态。另外还需要一个数据结构记录已被访问过的各个状态，以及已被发现的能够到达当前这个状态的路径。由于在这个问题的解决过程中需要列举的所有状态（二进制0000 －1111）一共16种，所以可以构造一个包含16个元素的整数顺序表来实现。顺序表的第i个元素记录状态i是否已被访问过，若已被访问过则在这个顺序表元素中记入前驱状态值，把这个顺序表叫做route。route的每个分量初始值均为-1。route的一个元素具有非负值表示这个状态已访问过，或是正被考虑。最后可以利用route顺序表元素的值建立起正确的状态路径。于是得到农夫过河问题的广度优先算法。在具体应用时，采用链队和顺序队均可，为叙述的方便，不妨设为使用顺序队。 模块划分 1、void BA() //农夫从B岸到A岸 2、void xu() //初始化三样东西的位置 3、void f() //判断农夫的位置 4、int g() //判断羊的位置 5、void huan () //农夫返回 6、void AB() //农夫从A岸到B岸
数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河
八皇后问题 1.问题描述 设在初始状态下在国际象棋的棋盘上没有任何棋子（这里的棋子指皇后棋子）。然后顺序在第1行，第2行……第8行上布放棋子。在每一行中共有8个可选择的位置，但在任一时刻棋盘的合法布局都必须满足3个限制条件（1）任意两个棋子不得放在同一行（2）任意两个棋子不得放在同一列上（3）任意棋子不得放在同一正斜线和反斜线上。 2.基本要求 编写求解并输出此问题的一个合法布局的程序。 3、实现提示： 在第i行布放棋子时，从第1列到第8列逐列考察。当在第i行第j列布放棋子时，需要考察布放棋子后在行方向、列方向、正斜线和反斜线方向上的布局状态是否合法，若该棋子布放合法，再递归求解在第i+1行布放棋子；若该棋子布放不合法，移去这个棋子，恢复布放该棋子前的状态，然后再试探在第i行第j+1列布放棋子。 4 程序代码 #include
{ int Line,Column; //棋盘初始化，空格为*，放置皇后的地方为@ for(Line=0;Line<8;Line++) { a[Line]=0; //列标记初始化，表示无列冲突 for(Column=0;Column<8;Column++) Queen[Line][Column]='*'; } //主、从对角线标记初始化，表示没有冲突 for(Line=0;Line<15;Line++) b[Line]=c[Line]=0; qu(0); return 0; } void qu(int i) { int Column; for(Column=0;Column<8;Column++) { if(a[Column]==0&&b[i-Column+7]==0&&c[i+Column]==0) //如果无冲突 { Queen[i][Column]='Q'; //放皇后 a[Column]=1;//标记，下一次该列上不能放皇后 b[i-Column+7]=1;//标记，下一次该主对角线上不能放皇后 c[i+Column]=1;//标记，下一次该从对角线上不能放皇后 if(i<7) qu(i+1); //如果行还没有遍历完，进入下一行 else//否则输出