农夫过河实验报告――数据结构

合集下载

数据结构课程设计报告（农夫过河）

数据结构课程设计报告（农夫过河）第一篇：数据结构课程设计报告(农夫过河)目录引言...................................................2 问题描述..............................................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.1 数据结构的设计。

数据结构实验-农夫过河问题

农夫过河问题一、实验目的掌握广度优先搜索策略，并用队列求解农夫过河问题二、实验内容问题描述：一农夫带着一只狼，一只羊和一颗白菜，身处河的南岸，他要把这些东西全部运到北岸，遗憾的是他只有一只小船，小船只能容下他和一件物品。

这里只能是农夫来撑船，同时因为狼吃羊、羊吃白菜、所以农夫不能留下羊和狼或羊和白菜在河的一边，而自己离开；好在狼属肉食动物，不吃白菜。

农夫怎么才能把所有的东西安全运过河呢？实验要求如下：（1）设计物品位置的表示方法和安全判断算法；（2）设计队列的存储结构并实现队列的基本操作（建立空队列、判空、入队、出队、取对头元素），也可以使用STL中的队列进行代码的编写；（3）采用广度优先策略设计可行的过河算法；（4）输出要求：按照顺序输出一种可行的过河方案；提示：可以使用STL中的队列进行代码编写。

程序运行结果：二进制表示：1111011011100010101100011001，0000三、农夫过河算法流程⏹Step1：初始状态0000入队⏹Step2：当队列不空且没有到达结束状态1111时，循环以下操作：⏹队头状态出队⏹按照农夫一个人走、农夫分别带上三个物品走，循环以下操作：⏹农夫和物品如果在同一岸，则计算新的状态⏹如果新状态是安全的并且是没有处理过的，则更新path[ ]，并将新状态入队⏹当状态为1111时，逆向输出path[ ]数组附录一：STL中队列的使用注：队列，可直接用标准模板库（STL）中的队列。

需要#include<queue>STL中的queue，里面的一些成员函数如下（具体可以查找msdn，搜索queue class）：front：Returns a reference to the first element at the front of the queue.pop：Removes an element from the front of the queuepush：Adds an element to the back of the queueempty：Tests if the queue is empty三、实验代码FarmerRiver.H#ifndef FARMERRIVER_H#define FARMERRIVER_Hint FarmerOnRight(int status); //农夫，在北岸返回1，否则返回0int WorfOnRight(int status); //狼int CabbageOnRight(int status); //白菜int GoatOnRight(int status); //羊int IsSafe(int status); //判断状态是否安全，安全返回1，否则返回0void FarmerRiver();#endifSeqQueue.h#ifndef SEQQUEUE_H#define SEQQUEUE_Htypedef int DataType;struct Queue{int Max;int f;int r;DataType *elem;};typedef struct Queue *SeqQueue;SeqQueue SetNullQueue_seq(int m);int IsNullQueue_seq(SeqQueue squeue);void EnQueue_seq(SeqQueue squeue, DataType x);void DeQueue_seq(SeqQueue);DataType FrontQueue_seq(SeqQueue);#endifFarmerRiver.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"#include "FarmerRiver.h"int FarmerOnRight(int status) //判断当前状态下农夫是否在北岸{return (0!=(status & 0x08));}int WorfOnRight(int status){return (0!=(status & 0x04));}int CabbageOnRight(int status){return (0!=(status & 0x02));}int GoatOnRight(int status){return (0!=(status & 0x01));}int IsSafe(int status) //判断当前状态是否安全{if ((GoatOnRight(status)==CabbageOnRight(status)) &&(GoatOnRight(status)!=FarmerOnRight(status)))return (0); //羊吃白菜if ((GoatOnRight(status)==WorfOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status))) return 0; //狼吃羊return 1; //其他状态是安全的}void FarmerRiver(){int i, movers, nowstatus, newstatus;int status[16]; //用于记录已考虑的状态路径SeqQueue moveTo;moveTo = SetNullQueue_seq(20); //创建空列队EnQueue_seq(moveTo, 0x00); //初始状态时所有物品在北岸，初始状态入队for (i=0; i<16; i++) //数组status初始化为-1{status[i] = -1;}status[0] = 0;//队列非空且没有到达结束状态while (!IsNullQueue_seq(moveTo) && (status[15]==-1)){nowstatus = FrontQueue_seq(moveTo); //取队头DeQueue_seq(moveTo);for (movers=1; movers<=8; movers<<=1)//考虑各种物品在同一侧if ((0!=(nowstatus & 0x08)) == (0!=(nowstatus & movers)))//农夫与移动的物品在同一侧{newstatus = nowstatus ^ (0x08 | movers); //计算新状态//如果新状态是安全的且之前没有出现过if (IsSafe(newstatus)&&(status[newstatus] == -1)){status[newstatus] = nowstatus; //记录新状态EnQueue_seq(moveTo, newstatus); //新状态入队}}}//输出经过的状态路径if (status[15]!=-1){printf("The reverse path is: \n");for (nowstatus=15; nowstatus>=0; nowstatus=status[nowstatus]){printf("The nowstatus is: %d\n", nowstatus);if (nowstatus == 0)return;}}elseprintf("No solution.\n");}Sequeue.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"SeqQueue SetNullQueue_seq(int m){SeqQueue squeue;squeue = (SeqQueue)malloc(sizeof(struct Queue));if (squeue==NULL){printf("Alloc failure\n");return NULL;}squeue->elem = (int *)malloc(sizeof(DataType) * m);if (squeue->elem!=NULL){squeue->Max = m;squeue->f = 0;squeue->r = 0;return squeue;}else free(squeue);}int IsNullQueue_seq(SeqQueue squeue){return (squeue->f==squeue->r);}void EnQueue_seq(SeqQueue squeue, DataType x) //入队{if ((squeue->r+1) % squeue->Max==squeue->f) //是否满printf("It is FULL Queue!");else{squeue->elem[squeue->r] = x;squeue->r = (squeue->r+1) % (squeue->Max);}}void DeQueue_seq(SeqQueue squeue) //出队{if (IsNullQueue_seq(squeue))printf("It is empty queue!\n");elsesqueue->f = (squeue->f+1) % (squeue->Max); }DataType FrontQueue_seq(SeqQueue squeue) //求队列元素{if (squeue->f==squeue->r)printf("It is empty queue!\n");elsereturn (squeue->elem[squeue->f]);}main.c#include <stdio.h>#include <stdlib.h>#include "FarmerRiver.h"int main(void){FarmerRiver();return 0;}实验结果：四、实验总结。

农夫过河问题(C++编写)

cout<<" **
------------------------
**\n";
cout<<" **
|
农夫过河问题
|
**\n";
cout<<" **
------------------------
**\n";
cout<<"
****************************************************************************\n";
1、问题描述
从前，一个农夫带着一只狼，一只羊和一棵白菜要河（注意该狼被农夫训服了，但还会吃羊）。他要将所有东西安全的带到河的对岸，不幸的是河边只有一条船，只能装下农夫和他的一样东西，并且农夫必须每次都随船过，因为只有他能撑船。在无人看管的情况下，狼要吃羊，羊要吃白菜，因此，农夫不能在河的某边岸上单独留下狼和羊，也不能单独留下羊和白菜。那么农夫如何才能使三样东西平安过河呢？
3）、如果上两个条件都不满，则可执行运输的动作，但每次都应考虑，该运输情况以前是否执行过（即两岸以及船上的东西以时四者各自的状态，并递归的进行下一次运载。
5、系统测试
6、经验总结
解决实际问题时，应先分析实际问题，找出实际问题的所有约束条件，然后对问题进行数学模型的抽象化，抓主要因素，省去一些不需要的因素，将其抽象为数学问题，然后再从整体上设计算法，搭建程序的框架，最后一步步完善细节，这样做，会使本来毫无头绪的问题变得清晰起来。
if (a[ferryTimes][i] == a[ferryTimes][3]) {

农夫过河问题

课程设计题目：农夫过河一．问题描述一个农夫带着一只狼、一只羊和一箩白菜，身处河的南岸。

他要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

过河有以下规则：(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结构体是为了储图的顶点数与边数，农夫过河问题我采用的是图的深度优先遍历思想。

数据结构实验-农夫过河问题

这里只能是农夫来撑船，同时因为狼吃羊、羊吃白菜、所以农夫不能留下羊和狼或羊和白菜在河的一边，而自己离开；好在狼属肉食动物，不吃白菜。

需要#include<queue>STL中的queue，里面的一些成员函数如下（具体可以查找msdn，搜索queue class）：front：Returns a reference to the first element at the front of the queue.pop：Removes an element from the front of the queuepush：Adds an element to the back of the queueempty：Tests if the queue is empty三、实验代码FarmerRiver.H#ifndef FARMERRIVER_H#define FARMERRIVER_Hint FarmerOnRight(int status); //农夫，在北岸返回1，否则返回0int WorfOnRight(int status); //狼int CabbageOnRight(int status); //白菜int GoatOnRight(int status); //羊int IsSafe(int status); //判断状态是否安全，安全返回1，否则返回0void FarmerRiver();#endifSeqQueue.h#ifndef SEQQUEUE_H#define SEQQUEUE_Htypedef int DataType;struct Queue{int Max;int f;int r;DataType *elem;};typedef struct Queue *SeqQueue;SeqQueue SetNullQueue_seq(int m);int IsNullQueue_seq(SeqQueue squeue);void EnQueue_seq(SeqQueue squeue, DataType x);void DeQueue_seq(SeqQueue);DataType FrontQueue_seq(SeqQueue);#endifFarmerRiver.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"#include "FarmerRiver.h"int FarmerOnRight(int status) //判断当前状态下农夫是否在北岸{return (0!=(status & 0x08));}int WorfOnRight(int status){return (0!=(status & 0x04));}int CabbageOnRight(int status){return (0!=(status & 0x02));}int GoatOnRight(int status){return (0!=(status & 0x01));}int IsSafe(int status) //判断当前状态是否安全{if ((GoatOnRight(status)==CabbageOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status)))return (0); //羊吃白菜if ((GoatOnRight(status)==WorfOnRight(status)) && (GoatOnRight(status)!=FarmerOnRight(status))) return 0; //狼吃羊return 1; //其他状态是安全的}void FarmerRiver(){int i, movers, nowstatus, newstatus;int status[16]; //用于记录已考虑的状态路径SeqQueue moveTo;moveTo = SetNullQueue_seq(20); //创建空列队EnQueue_seq(moveTo, 0x00); //初始状态时所有物品在北岸，初始状态入队for (i=0; i<16; i++) //数组status初始化为-1{status[i] = -1;}status[0] = 0;//队列非空且没有到达结束状态while (!IsNullQueue_seq(moveTo) && (status[15]==-1)){nowstatus = FrontQueue_seq(moveTo); //取队头DeQueue_seq(moveTo);for (movers=1; movers<=8; movers<<=1)//考虑各种物品在同一侧if ((0!=(nowstatus & 0x08)) == (0!=(nowstatus & movers)))//农夫与移动的物品在同一侧{newstatus = nowstatus ^ (0x08 | movers); //计算新状态//如果新状态是安全的且之前没有出现过if (IsSafe(newstatus)&&(status[newstatus] == -1)){status[newstatus] = nowstatus; //记录新状态EnQueue_seq(moveTo, newstatus); //新状态入队}}}//输出经过的状态路径if (status[15]!=-1){printf("The reverse path is: \n");for (nowstatus=15; nowstatus>=0; nowstatus=status[nowstatus]){printf("The nowstatus is: %d\n", nowstatus);if (nowstatus == 0)return;}}elseprintf("No solution.\n");}Sequeue.c#include <stdio.h>#include <stdlib.h>#include "SeqQueue.h"SeqQueue SetNullQueue_seq(int m){SeqQueue squeue;squeue = (SeqQueue)malloc(sizeof(struct Queue));if (squeue==NULL){printf("Alloc failure\n");return NULL;}squeue->elem = (int *)malloc(sizeof(DataType) * m);if (squeue->elem!=NULL){squeue->Max = m;squeue->f = 0;squeue->r = 0;return squeue;}else free(squeue);}int IsNullQueue_seq(SeqQueue squeue){return (squeue->f==squeue->r);}void EnQueue_seq(SeqQueue squeue, DataType x) //入队{if ((squeue->r+1) % squeue->Max==squeue->f) //是否满printf("It is FULL Queue!");else{squeue->elem[squeue->r] = x;squeue->r = (squeue->r+1) % (squeue->Max);}}void DeQueue_seq(SeqQueue squeue) //出队{if (IsNullQueue_seq(squeue))printf("It is empty queue!\n");elsesqueue->f = (squeue->f+1) % (squeue->Max); }DataType FrontQueue_seq(SeqQueue squeue) //求队列元素{if (squeue->f==squeue->r)printf("It is empty queue!\n");elsereturn (squeue->elem[squeue->f]);}main.c#include <stdio.h>#include <stdlib.h>#include "FarmerRiver.h"int main(void){FarmerRiver();return 0;}实验结果：四、实验总结。

【数据结构与算法】狼、羊、菜和农夫过河：使用图的广度优先遍历实现

【数据结构与算法】狼、⽺、菜和农夫过河：使⽤图的⼴度优先遍历实现【数据结构与算法】狼、⽺、菜和农夫过河：使⽤图的⼴度优先遍历实现Java农夫需要把狼、⽺、菜和⾃⼰运到河对岸去，只有农夫能够划船，⽽且船⽐较⼩。

除农夫之外每次只能运⼀种东西。

还有⼀个棘⼿问题，就是如果没有农夫看着，⽺会偷吃菜，狼会吃⽺。

请考虑⼀种⽅法，让农夫能够安全地安排这些东西和他⾃⼰过河。

解题思路学了图论的⼴度优先遍历算法后，我们可以使⽤⼴度优先遍历的思想来完成这道题。

⾸先定义如何表达农夫、狼、⽺、菜在河的哪⼀边。

只有两种状态：1. 在河的⼀边（假设为东边）2. 在河的另⼀边（假设为西边）那么恰好可以⽤0和1来表达，任务定义如下（使⽤字符串来表达）：// ⼈狼⽺菜// 源： 0 0 0 0//⽬标： 1 1 1 1String s = "0000";String t = "1111";那接下来程序的任务就是搜索出从s到t的过程了。

那么如何转换成图论问题？我们知道，0000 代表农夫、狼、⽺、菜都在河的东边，那么下⼀种状态可以有如下⼏种选择：1. 东：空狼⽺菜 | 西：⼈空空空（农夫⾃⼰过河）2. 东：空空⽺菜 | 西：⼈狼空空（农夫带狼过河）3. 东：空狼空菜 | 西：⼈空⽺空（农夫带⽺过河）4. 东：空狼⽺空 | 西：⼈空空菜（农夫带菜过河）我们根据这个可以绘制⼀个图，顶点0000 分别与顶点1000、顶点1100、顶点1010、顶点1001有边连接；其中，根据规则在没有农夫的情况下，狼和⽺不能在⼀起，⽺和菜不能在⼀起，所以排除掉以上的1,2,4选项。

那么下⼀个状态就是 0101然后根据这个原理，再往下查找有哪些是可以的：1. 东：⼈狼空菜 | 西：空空⽺空（农夫⾃⼰过河）2. 东：⼈狼⽺菜 | 西：空空空空（农夫带⽺过河）我们根据这个也可以绘制⼀个图，顶点0101 分别与顶点0000、顶点0010有边连接；然后再根据规则进⾏查找。

农夫过河问题的求解

void ListTraverse(LinkType p, status(*visit)(LinkType q));
//从p(P!=NULL)指示的结点开始，依次对每个结点调用函数visit
其中部分操作的伪码算法如下：
BOOL InitList(OrderdeList &L)
{
if(MakeNode(head,ˊˊ)){ //头结点的虚设元素为空格符ˊˊ
{
//分配由p指向的数据元素为e、后继为“空”的结点，并返回TRUE，
//若分配失败，则返回FALSE
p=(Link Type)malloc(sixeof(Node Type));
if(!p)return FALSE;
p－>data=e;p－>next=NULL; return TRUE;
}
void freeNode(LinkType &p)
//销毁有序链表L
bool Listempty(OrderedList L);
//若L不存在或为“空表”，则返回TRUE，否则返回FALSE
int ListLengty(OrderedList L);
//返回链表的长度
Linktype GetelemPos(OrderedList L, int pos);
构造有序集算法createset读入n个元素逐个用locateelem判定不在当前集合中及确定插入位置后才用insertafetr插入到有序集中所以时间复杂度是on求并集算法union利用集合的有序性将两个集合的个元素不重复地依次利用append插入到当前并集的末尾故可在omn时间内完成
实验报告
题目：编制一个演示农夫过河问题的求解的程序
per=L.head; p=pre－>next;

农夫过河问题

{
df=d[i].f-d[j].f;
dw=abs(d[i].w-d[j].w);
ds=abs(d[i].s-d[j].s);
dc=abs(d[i].c-d[j].c);
if(df!=0&&(dw+ds+dc)<=1)
{
edge[num].col=i;
edge[num++].row=j;
}
}
return num;
int right_edge(DataType *vertex,RowCol *edge,int n) //选出满足题意的边
void DepthFSearch(AdjLGraph G,int v,int visited[],DataType vert[],int *a)
//图的深度优先遍历
3.3抽象数据类型的设计
{
if(!visited[w])
DepthFSearch(G,w,visited,d1,s);
w=GetNextVex(G,v,w);
}
}
4.3函数的调用关系图
5.测试结果
农夫过河问题
1．问题描述
一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。他要把这些东西全部运到北岸。他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。
typedef struct
{
AdjLHeight a[100];//邻接表数组
int numOfVerts;//结点个数
int numOfEdges;//边个数

数据结构—农夫过河问题

题目：一个农夫带着一匹狼、一只羊、一颗白菜要过河，只有一条船而且农夫每次最多只能带一个动物或物品过河，并且当农夫不在的时候狼会吃羊，羊会吃白菜，列出所有安全将所有动物和物品带过河的方案。

要求：广度优先搜索农夫过河解，并输出结果源代码：#include <stdio.h>#include <stdlib.h>typedef int DataType;struct SeqQueue{int MAXNUM;int f, r;DataType *q;};typedef struct SeqQueue *PSeqQueue; // 顺序队列类型的指针类型PSeqQueue createEmptyQueue_seq(int m)//创建一个空队列{PSeqQueue queue = (PSeqQueue)malloc(sizeof(struct SeqQueue)); if (queue != NULL){queue->q = (DataType*)malloc(sizeof(DataType) *m);if (queue->q){queue->MAXNUM = m;queue->f = 0;queue->r = 0;return (queue);}elsefree(queue);}printf("Out of space!!\n"); // 存储分配失败return NULL;}int isEmptyQueue_seq(PSeqQueue queue)//判断队列是否为空{return (queue->f == queue->r);}void enQueue_seq(PSeqQueue queue, DataType x)//入队{if ((queue->r + 1) % queue->MAXNUM == queue->f)printf("Full queue.\n");else{queue->q[queue->r] = x;queue->r = (queue->r + 1) % queue->MAXNUM;}}void deQueue_seq(PSeqQueue queue)// 删除队列头部元素{if (queue->f == queue->r)printf("Empty Queue.\n");elsequeue->f = (queue->f + 1) % queue->MAXNUM;}DataType frontQueue_seq(PSeqQueue queue)//取队头元素{if (queue->f == queue->r)printf("Empty Queue.\n");elsereturn (queue->q[queue->f]);}int farmer(int location)//判断农夫的位置 1000表示在北岸{return (0 != (location &0x08));}int wolf(int location)//判断狼的位置 0100表示在北岸{return (0 != (location &0x04));}int cabbage(int location)//判断白菜的位置 0010表示在北岸{return (0 != (location &0x02));}int goat(int location)//判断羊的位置 0001表示在北岸{return (0 != (location &0x01));}int safe(int location)//安全状态的判断{if ((goat(location) == cabbage(location)) && (goat(location) != farmer(location))) //羊与白菜不安全return 0;if ((goat(location) == wolf(location)) && (goat(location) != farmer(location)))//羊与狼不安全return 0;return 1; // 其他状态是安全的}void bin_print(int num)//将十进制数转换成二进制数输出{char tmp[4];int i;for (i = 0; i < 4; ++i){tmp[i] = num & 0x01;num >>= 1;}for (i = 3; i >= 0; --i)putchar((tmp[i] == 0)?'0':'1');return;}int main(){int i, movers, location, newlocation;int a=0;int r[16];int route[16]; //用于记录已考虑的状态路径PSeqQueue moveTo; //用于记录可以安全到达的中间状态moveTo = createEmptyQueue_seq(20); //创建空队列enQueue_seq(moveTo, 0x00); //初始状态进队列for (i = 0; i < 16; i++)route[i] = -1; //准备数组route初值route[0] = 0;while (!isEmptyQueue_seq(moveTo) && (route[15] == - 1)){location = frontQueue_seq(moveTo); //取队头状态为当前状态deQueue_seq(moveTo);for (movers = 1; movers <= 8; movers <<= 1)//考虑各种物品移动 if ((0 != (location & 0x08)) == (0 != (location & movers)))//判断农夫与移动的物品是否在同一侧{newlocation = location ^ (0x08 | movers);//计算新状态，代表把船上的（0x08|movers）从一个岸移到另一个岸；（0x08|movers）代表船上有农夫和movers代表的东西if (safe(newlocation) && (route[newlocation] == -1)) //新状态安全且未处理{route[newlocation] = location; //记录新状态的前驱 enQueue_seq(moveTo, newlocation); //新状态入队}}}// 打印出路径if (route[15] != -1)//到达最终状态{printf("The reverse path is : \n");for (location = 15; location >= 0; location = route[location]) {r[a]=location;a++;if (location == 0) break;}for(i=a-1;i>=0;i--){printf("%d ",r[i]);bin_print(r[i]);//用1表示北岸，0表示南岸,用四位二进制数的顺序依次表示农夫、狼、白菜、羊的位置if(r[i]==0) printf("开始\n");//0000else if(r[i]==1) printf(" 农夫独自返回南岸\n"); //0001else if(r[i]==2) printf(" 农夫带着羊返回南岸\n");//0010else if(r[i]==3) printf(" 白菜与羊共同在北岸，不安全\n"); //0011else if(r[i]==4) printf(" 只有狼在北岸，农夫独自返回南岸\n"); //0100else if(r[i]==5) printf(" 狼与羊共同在北岸，不安全\n");//0101else if(r[i]==6) printf(" 农夫独自返回南岸\n");//0110else if(r[i]==7) printf(" 狼、白菜和羊共同在北岸，不安全\n");// 0111else if(r[i]==8) printf(" 农夫独自去北岸\n");//1000else if(r[i]==9) printf(" 农夫把羊带到北岸\n");//1001else if(r[i]==10) printf(" 农夫把白菜带到北岸\n");//1010else if(r[i]==11) printf(" 农夫把白菜带到北岸\n");//1011else if(r[i]==12) printf(" 农夫把狼带到北岸\n");//1100else if(r[i]==13) printf(" 只有白菜在南岸\n");//1101else if(r[i]==14) printf(" 农夫把狼带到北岸\n");//1110else if(r[i]==15) printf(" 农夫把羊带到北岸\n");//1111 putchar('\n');}printf("\n");}elseprintf("No solution.\n");}。

数据结构课程设计报告(农夫过河)

目录引言 (2)1 问题描述 (2)基本要求 (2)2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性； (2)2.2设计一个算法求解农夫过河问题，并输出过河方案； (2)3 概要设计 (2)3.1数据结构的设计。

(2)3.1.1农夫过河问题的模型化 (2)3.1.2 算法的设计 (3)4、运行与测试 (5)5、总结与心得 (6)附录 (6)参考文献 (12)引言所谓农夫过河问题是指农夫带一只狼、一只羊和一棵白菜在河南岸, 需要安全运到北岸。

一条小船只能容下他和一件物品, 只有农夫能撑船。

基本要求2.1为农夫过河问题抽象数据模型体会数据模型在问题求解中的重要性；2.2设计一个算法求解农夫过河问题，并输出过河方案；3 概要设计3.1 数据结构的设计。

3.1.1农夫过河问题的模型化分析这类问题会发现以下特征:有一组状态( 如农夫和羊在南, 狼和白菜在北) ; 从一个状态可合法地转到另外几个状态( 如农夫自己过河或农夫带着羊过河) ; 有些状态不安全( 如农夫在北, 其他东西在南) ; 有一个初始状态( 都在南) ; 结束状态集( 这里只有一个, 都在北) 。

问题表示: 需要表示问题中的状态, 农夫等位于南P北( 每个有两种可能) 。

可以采用位向量, 4 个二进制位的0P1 情况表示状态, 显而易见, 共24= 16种可能状态。

从高位到低位分别表示农夫、狼、白菜和羊。

农夫携物过河程序

题目内容：有一农夫要将自己的羊、蔬菜和狼等3件物品运过河。

但农夫过河时所用的船每次最多只能装英中的一件物品，而这3件物品之间又存在一左的制约关系：羊不能单独和狼以及不能和蔬菜在一起，因为狼要吃羊，羊也能吃蔬菜。

试构造出问题模式以编程实现这一问题的求解。

1、问题分析和任务定义：根据对象的状态分为过河（1）和不过河（0）,此对象集合就构成了一个状态空间。

问题就是在这个状态空间内搜索一条从开始状态到结束状态的安全路径。

显然，其初始状态为四对象都不过河，结束状态为四对象全部过河。

这里用无向图来处理，并采用邻接矩阵存储。

对于农夫，狼，羊，蔬菜组成一个4位向量，即图的顶点（F,叭S, V）,状态空间为16, 初始状态为（0000）,目标为（1111）。

解决问题的方法是，找到所有的安全状态，并在其中搜索岀一条（0000）到（1111）的路径。

对当前对象是否安全的判断，若当农夫与羊不在一起时，狼与羊或羊与蔬菜在一起是不安全的，英他情况是安全的。

搜索一条可行路径时，采用深度优先搜索DFS_path,每个时刻探索一条路径，并记录访问过的合法状态，一直向前探视，直到疋不通时回溯。

显然，应该用数组来保存访问过的状态，以便回溯。

显然农夫每次状态都在改变，最多也就能带一件东西过河，故搜索条件是，在顶点（F, W, S, V）的转换中，狼，羊，蔬菜三者的状态不能大于一个，即只有一个发生改变或者都不变。

①数拯的输入形式和输入值的范用：本程序不需要输入数据，故不存在输入形式和输入值的范用。

②结果的输出形式：在屏幕上显示安全状态的转换，即一条安全路径。

2、数据结构的选择概要设计⑴数据结构的选择：本程序采用无向图处理。

#define MaxNumVertices 10 //最大顶点数typedef struct //图的顶点类型int Farmer, Wolf, Sheep, Veget; //存储农夫，狼，羊，蔬菜的状态}VexType;typedef struct//图的各项信息VexType VerticesList LMaxNumVertices]; //顶点向量(代表顶点)int Edge [MaxNumVertices] [MaxNumVertices];//邻接矩阵//用于存储图中的边，苴矩阵元素个数取决于顶点个数，与边数无关}AdjGraph;⑵为了实现上述程序的功能，需要：①生成所有安全的图的顶点：②査找顶点的位置：③判断目前(F, W. S, V)是否安全，安全返回1,否则返回0：④判断顶点i和顶点j之间是否可转换，可转换返回真，否则假：⑤深度优先搜索从u到v的简单路径; ⑥输出从u 到v的简单路径，即顶点序列中不重复出现的路径。

农夫过河实验报告——数据结构

数据结构实验报告——实验四农夫过河的求解本实验的目的是进一步理解顺序表和队列的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。

一、【问题描述】一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。

他要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

如果农夫在场，则狼不能吃羊，羊不能吃白菜，否则狼会吃羊，羊会吃白菜，所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不吃白菜。

请求出农夫将所有的东西运过河的方案。

二、【数据结构设计】求解这个问题的简单的方法是一步一步进行试探，每一步搜索所有可能的选择，对前一步合适的选择再考虑下一步的各种方案。

要模拟农夫过河问题，首先需要对问题中每个角色的位置进行描述。

一个很方便的办法是用四位二进制数顺序分别表示农夫、狼、白菜和羊的位置。

用0表示农夫或者某东西在河的南岸，1表示在河的北岸。

例如整数5(其二进制表示为0101) 表示农夫和白菜在河的南岸，而狼和羊在北岸。

现在问题变成：从初始状态二进制0000(全部在河的南岸) 出发，寻找一种全部由安全状态构成的状态序列，它以二进制1111(全部到达河的北岸)为最终目标，并且在序列中的每一个状态都可以从前一状态到达。

为避免瞎费功夫，要求在序列中不出现重复的状态。

实现上述求解的搜索过程可以采用两种不同的策略：一种是广度优先(breadth_first) 搜索，另一种是深度优先(depth_first) 搜索。

本书只介绍在广度优先搜索方法中采用的数据结构设计。

广度优先就是在搜索过程中总是首先搜索下面一步的所有可能状态，再进一步考虑更后面的各种情况。

要实现广度优先搜索，可以使用队列。

把下一步所有可能的状态都列举出来，放在队列中，再顺序取出来分别进行处理，处理过程中把再下一步的状态放在队列里……。

由于队列的操作遵循先进先出的原则，在这个处理过程中，只有在前一步的所有情况都处理完后，才能开始后面一步各情况的处理。

数据结构课程设计-农夫过河-实验报告.

一、需求分析描述1、针对实现整个过程需要多步，不同步骤中各个事物所处位置不同的情况，可定义一个结构体来实现对四个对象狼、羊、白菜和农夫的表示。

对于起始岸和目的岸，可以用0或者1来表示，以实现在程序设计中的简便性。

2、题目要求给出四种事物的过河步骤，没有对先后顺序进行约束，这就需要给各个事物依次进行编号，然后依次试探，若试探成功，进行下一步试探。

这就需要使用循环或者递归算法，避免随机盲目运算且保证每种情况均试探到。

3、题目要求求出农夫带一只羊，一条狼和一颗白菜过河的办法，所以依次成功返回运算结果后，需要继续运算，直至求出结果，即给出农夫的过河方案。

4、输出界面要求具有每一步中农夫所带对象及每步之后各岸的物体，需要定义不同的数组来分别存储上述内容，并使界面所示方案清晰简洁。

二、系统架构设计1．设计中首先涉及的就是数据类型的定义，首先，定义一个结构体用来存放农夫、狼、羊、白菜的信息。

具体定义为：struct Condition{int farmer;int wolf;int sheep;int cabbage;};定义了一个结构体数组Condition conditions[100]，定义状态数组用来记录他们过河的状态0：起始岸；1：目的岸;程序中定义的char action100数组用来存放各个物件以及人过河或返回的说明语句。

2．程序中定义的子函数有：2.1 将狼带到目的岸以及带回起始岸的函数takeWolfOver（）和takeWolfBack （）；takeWolfOver（）函数中将conditions[i+1].wolf=1，白菜、羊的状态不变，同时要有action[i]=" take wolf over."将狼带到目的岸语句；takeWolfBack（）函数中将conditions[i+1].wolf=0，白菜、羊的状态不变，同时要有action[i]=" take wolf back."将狼带回起始岸语句。

过河问题实验报告

if(a[i][3]==0) printf("farmer ");
if(a[i][0]&&a[i][1]&&a[i][2]&&a[i][3]) printf("none");

printf("
");
printf("west: ");
if(a[i][0]==1) printf("wolf ");
if(a[i][1]==1) printf("goat ");
if (i == -1) { search(Step + 1); }
else if (a[Step][i] == a[Step][3]) {
a[Step + 1][i] = a[Step + 1][3]; search(Step + 1); } } 每次循环从-1 到 2 依次代表农夫渡河时为一人、带狼、带羊、带白菜通过，利用语句 “b[Step] = i”分别记录每一步中农夫的渡河方式，“a[Step + 1][i] = a[Step + 1][3]”即利用赋值方式使该项与农夫一同到对岸或者回到本岸。若渡河成功，则依次输出渡河方式。 “i <= 2”即递归操作的界限，当若 i=2 时仍无符合条件的方式，则渡河失败。
east east east
east east
： farmer goat wolf cabbage west ： none
The 1 time
： wolf cabbage
west ： farmer goat
------ farmer
： farmer wolf cabbage

农夫过河报告(最终版)

农夫过河算法实验报告――数据结构项目课研究课题组长：崔俊组员：李琦、郑鸿飞、王琅辉、张育博15.12.29摘要农夫过河问题是应用广度优先搜索和深度优先搜索的典型问题，但这里我们应用了简单的数组，通过层层筛选的手段也解决了同样的问题，其中用到了部分广度优先搜索的思想。

、八■、-前言农夫过河问题描述：一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸。

他要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

请求出农夫将所有的东西运过河的方案。

正文1∙问题抽象和数据组织农夫过河问题应该应用图的广度优先遍历或者深度优先遍历，但这里我们仅使用简单的线性表一一数组，通过多重的条件限制，达成目的。

这里我们同样用O和1代表农夫、狼、羊、白菜在左岸还是在右岸，并规定O在左，1在右，我们的目的便是从OOOO通过一系列变换到1111。

2.农夫过河算法源代码#in elude VStdio.h>#define MAX 16typedef StrUCt FWSV{int farmer;int wolf;int sheep;int vegetable;}Item;//函数原型//操作：筛选符合条件的安全的数组成员//操作前：无//操作后：返回安全数组的指针void SCree n( void);//操作：判断下一个数应该取安全数组中那个数//操作前：传递一个结构体数组成员//操作后：返回另一个结构体数组指针Item * judge(Item Fwsv);Item safe[MAX];int k = 0;int main (Void){SCree n();Item * n ext;Item first,sec On d,e nd;first = safe[0];end = safe[k];Prin tf("first:0000\n"); n ext = judge(first);void SCree n( 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 Il S == V))){safe[k].farmer = f;safe[k].wolf = w;safe[k].sheep = s;safe[k].vegetable = v;k++;// 用于计数safe[]中的总数}}}}}}Item * judge(Item FWSV){Item * n ext;Item COmPare[4];n ext = compare;int x1 = 0;int SUm = 0;if (Fwsv.farmer == 0){for (int X = 0;X < k;x++){ZZ把出现过的置零操作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;}ZZ筛选出农夫状态值与之前相反的1变0 0变1if(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 = Fwsvfarmer + 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){Il (Fwsv.farmer != Fwsv.vegetable && COmPare[x2].VegetabIe != Fwsv.vegetable)Il (Fwsv.farmer != Fwsv.vegetable && COmPare[x2].VegetabIe != Fwsv.vegetable)){COmPare[x2].farmer = 0;COmPare[x2].wolf = 0;COmPare[x2].SheeP = 0;COmPare[x2].VegetabIe = 0;}sum+=2;//对和的限制if(compare[x2].farmer + COmPare[x2].wolf + COmPare[x2].SheeP +COmPare[x2].VegetabIe != SUm){COmPare[x2].farmer = 0;COmPare[x2].wolf = 0;COmPare[x2].SheeP = 0;COmPare[x2].VegetabIe = 0;}}Printf(" -------------------------------------- ∖n");for(i nt x3 = 0;x3 < 4;x3++){if (COmPare[x3].farmer + COmPare[x3].wolf + COmPare[x3].SheeP +COmPare[x3].VegetabIe != 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 V 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].wolfsafe[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.sheep)Fwsv.vegetable)Fwsv.vegetable)){COmPare[x2].farmer = 0; COmPare[x2].wolf = 0; COmPare[x2].SheeP = 0; COmPare[x2].VegetabIe = 0; } }Printf(" for(i nt x3 = 0;x3 < 4;x3++)∣∣(Fwsv.farmer != Fwsv.sheep && COmPare[x2].SheeP!= Il (Fwsv.farmer!= Fwsv.vegetable && COmPare[x2].VegetabIe != Il (Fwsv.farmer!= Fwsv.vegetable&& COmPare[x2].VegetabIe!=∖n");if (ComPare[x3].farmer + ComPare[x3].Wolf + ComPare[x3].SheeP + ComPare[x3].VegetabIe != 0){Printf(" 上数与：％d%d%d%d 连∖n",ComPare[x3].farmer,compare[x3].wolf,compare[x3].sheep,compare[x3].vegetable);}}}return n ext;}3. 算法功能说明和流程描述首先我们定义了一个结构体Itemtypedef StrUCt FWSV{int farmer;int wolf;int sheep;int vegetable;}Item;Item 中包含了农夫(farmer ),狼(wolf ),羊(SheeP),白菜(VegetabIe ),用来表示农夫、狼、羊、白菜的状态，并作出规定当为0的时候表示在左岸，当为1的时候表示在右岸，我们的目标便是从0000的状态到1111的状态。

农夫过河数据结构

农夫过河数据结构郑州轻工业学院课程设计任务书题目农夫过河专业、班级计算机科学与技术学号姓名主要内容:一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸，要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

如果农夫在场，则狼不能吃羊，羊不能吃白菜;否则狼会吃羊，羊会吃白菜。

所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不能吃白菜。

要求给出农夫将所有的东西运过河的方案。

基本要求:编写求解该问题的算法程序，并用此程序上机运行、调试，屏幕显示结果，能结合程序进行分析。

主要参考资料:数据结构严蔚敏完成期限: 2012/6/21指导教师签名:课程负责人签名:年月日郑州轻工业学院本科数据结构课程设计总结报告设计题目:农夫过河学生姓名:系别:计算机与通信工程学院专业:计算机科学与技术班级:计算机科学与技术学号:指导教师:2012年 6 月 21 日2一，设计题目问题描述:一个农夫带着一只狼、一只羊和一棵白菜，身处河的南岸，他要把这些东西全部运到北岸。

他面前只有一条小船，船只能容下他和一件物品，另外只有农夫才能撑船。

如果农夫在场，则狼不能吃羊，羊不能吃白菜;否则狼会吃羊，羊会吃白菜。

所以农夫不能留下羊和白菜自己离开，也不能留下狼和羊自己离开，而狼不能吃白菜。

要求给出农夫将所有的东西运过河的方案。

二，运行环境(软、硬件环境)VC6.0 Windows7系统三，算法设计的思想对于这个问题，我们需要先自动生成图的邻接矩阵来存储，主要方法是先生成各种安全状态结点，存放在顶点向量中;再根据判断两个结点间状态是否可以转换来形成顶点之间的所有边，并把它们保存在邻接矩阵中。

在建立了图的邻接矩阵存储结构后，利用递归深度优先搜索求出从顶点(0，0，0，0)到顶点(1，1，1，1)的一条简单路径，这样做只能搜到一种合理方法，因为深度优先搜索遍历一个图的时候每一个结点只能被访问一次。

过河问题,数据结构

数据结构课程设计报告1.问题描述（第27题）有一人要将自己的兔子、蔬菜和狐狸等三件物品运过河。

但过河所用的船每次只能装其中的两件，而这三件物品之间又存在一定的制约关系：兔子不能单独和狐狸以及不能和蔬菜在一起，因为狐狸要吃兔子，兔子也能吃蔬菜。

试构造出问题的模型，并编程实现这一问题的求解。

2、模型表示农夫要把三件物品运过河，但三个物品之间又有一定的制约关系。

因此河的两岸，可以用几个状态来表示。

那么为了能够把物品安全的运过河，河两岸的状态可以表示为:用1表示蔬菜，2表示兔子，3表示狐狸,0表示移走了河的此岸河的彼岸(1,2,3) (0,0,0)(1,0,3) (0,2,0)(0,0,3) (1,2,0)(0,2,3) (1,0,0)(0,2,0) (1,0,3)(0,0,0) (1,2,3)为了能够把河两岸的状态正确的表示出来，那么首要解决的问题就是如何确定移走和带回。

设计一个函数来确定带回那个权值（1，2，3，0），这样可以形成河两岸的几种状态。

（1，2，0）、（0，2，3)、（1，2，3）在农夫不在的情况下均是不稳定状态需要移走或者带回。

兔子对于蔬菜和狐狸两个量均有影响。

而我们可以观察到（1，0，3）在农夫不在的情况下是个稳定的状态，从而可以确定移走三个物品的路径了：兔子过去;没有东西回来.白菜过去;兔子回来.狼过去;没有东西回来.兔子过去;没有东西回来.3、算法的思想描述通过对河两岸状态的判断，确定移走哪个、带回哪个。

因此这就需要一个功能函数int begin(int first,int second,int third,int number)来实现这个功能。

在实现此函数的过程中，对剩余量进行判断，用switch（）选择性的语句。

河的此岸还剩三个的时候，直间返回中间量，即兔子；河的此岸还剩两个的时候，分三种情况：（1）有兔子、狼时，返回狼。

（2）不移走时，相当于回到初始状态，因为兔子变量对其他两个均有影响。

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。

本次实验的主要目的包括：1、熟悉常见的数据结构，如链表、栈、队列、树和图等。

2、掌握数据结构的基本操作，如创建、插入、删除、遍历等。

3、提高编程能力和解决实际问题的能力，能够运用合适的数据结构解决具体的问题。

二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。

三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。

双向链表的实现和基本操作。

循环链表的特点和应用。

2、栈和队列的实现栈的后进先出特性，实现入栈和出栈操作。

队列的先进先出原则，完成入队和出队功能。

3、树的操作二叉树的创建、遍历（前序、中序、后序）。

二叉搜索树的插入、查找和删除操作。

4、图的表示与遍历邻接矩阵和邻接表表示图。

深度优先搜索和广度优先搜索算法的实现。

四、实验步骤及结果1、链表的实现与操作单向链表：首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。

通过创建链表头节点，并使用循环依次插入新节点，实现了链表的创建。

插入节点时，根据指定位置找到插入点的前一个节点，然后修改指针完成插入操作。

删除节点时，同样找到要删除节点的前一个节点，修改指针完成删除。

实验结果：成功创建、插入和删除了单向链表的节点，并正确输出了链表的内容。

双向链表：双向链表节点结构体增加了指向前一个节点的指针。

创建、插入和删除操作需要同时维护前后两个方向的指针。

实验结果：双向链表的各项操作均正常，能够双向遍历链表。

循环链表：使链表的尾节点指向头节点，形成循环。

在操作时需要特别注意循环的边界条件。

实验结果：成功实现了循环链表的创建和遍历。

2、栈和队列的实现栈：使用数组或链表来实现栈。

入栈操作将元素添加到栈顶，出栈操作取出栈顶元素。

实验结果：能够正确进行入栈和出栈操作，验证了栈的后进先出特性。

农夫过河

程序设计报告题目：农夫过河专业：计算机科学与技术小组成员：班级:指导教师：日期：2014年12月25日成员分工：农夫过河【摘要】农夫问题即一个农民带着一只狼、一只羊和一棵白菜，身处河的南岸,他需要把这些东西全部运到河的北岸。

而他只有一条小船，且这只小船小到只能容下他和一件物品,另外只有农民能撑船。

农夫不能留下狼和羊自己离开，也不能留下白菜和羊自己离开,更不能留下狼，羊和白菜而独自离开，因为没有农夫的照看,狼就要吃掉羊,而羊又要吃掉白菜。

好在狼是是肉动物，它不吃白菜，问农夫应该采取什么方案才能将所有的东西安全地从河的南岸运到北岸？这类农夫问题是一个传统的数据结构问题,利用基于队列的图的广度优先搜索求解农夫过河问题是一个易于理解、切实可行的方案,具有一定的推广价值。

关键字：农夫过河问题;队列;广度优先搜索一、实验内容概述(设计任务与技术要求)农民过河问题是指农民需要带一只狼、一只羊和一棵白菜到河的南岸去,需要安全运到北岸。

而一条小船只能容下他和一件物品,只有农民能撑船。

问农民怎么能安全过河,问题中需要涉及到狼会吃羊,羊会吃白菜,所以农民不能将这两种或三种物品单独放在河的一侧,因为没有农民的照看,狼就要吃掉羊,而羊可能又要吃掉白菜。

这类问题的实质是系统的状态问题,要寻求的是从初始状态经一系列的安全状态到达系统的终止状态的一条路径。

根据实际情况，对此问题分析可以得到不同的特征：1,是农民和羊在河的南岸，狼和白菜在河的北岸；2,是从一个状态可转到另外一个状态，而不违反狼吃羊，羊吃草的规则（例如农民自己过河或者农民带着羊过河）；3,是有些状态是不安全的（例如农民一人在北岸，而其他的东西都在南岸）；4,是初始状态是农民，羊，狼，白菜都在河的南岸和结束状态是农民，羊，狼，白菜都在河的北岸。

实现农夫过河问题，则需要找到一条合法的路径（相邻状态之间的转移合法），从开始状态到某个结束状态，路途中不能经过不安全的状态。

数据结构与算法专题实验实验报告-八皇后-背包问题的求解-农夫过河

八皇后问题1.问题描述设在初始状态下在国际象棋的棋盘上没有任何棋子（这里的棋子指皇后棋子）。

然后顺序在第1行，第2行……第8行上布放棋子。

在每一行中共有8个可选择的位置，但在任一时刻棋盘的合法布局都必须满足3个限制条件（1）任意两个棋子不得放在同一行（2）任意两个棋子不得放在同一列上（3）任意棋子不得放在同一正斜线和反斜线上。

2.基本要求编写求解并输出此问题的一个合法布局的程序。

3、实现提示：在第i行布放棋子时，从第1列到第8列逐列考察。

当在第i行第j列布放棋子时，需要考察布放棋子后在行方向、列方向、正斜线和反斜线方向上的布局状态是否合法，若该棋子布放合法，再递归求解在第i+1行布放棋子；若该棋子布放不合法，移去这个棋子，恢复布放该棋子前的状态，然后再试探在第i行第j+1列布放棋子。

4 程序代码#include<iostream.h>#include<stdio.h>static char Queen[8][8];static int a[8];static int b[15];static int c[15];static int QueenNum=0;//记录总的棋盘状态数void qu(int i);//参数i代表行int main(){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//否则输出{//输出棋盘状态int Line,Column;cout<<"第"<<++QueenNum<<"种状态为："<<endl;for(Line=0;Line<8;Line++){for(Column=0;Column<8;Column++)cout<<Queen[Line][Column]<<" ";cout<<endl;}cout<<endl;getchar();}/*如果前次的皇后放置导致后面的放置无论如何都不能满足要求，则回溯，重置*/Queen[i][Column]='*';a[Column]=0;b[i-Column+7]=0;c[i+Column]=0;}}}5 程序结果题目2 背包问题的求解1.问题描述假设有一个能装入总体积为T的背包和n件体积分别为w1,w2,…w n的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+w m=T，要求找出所有满足上述条件的解。