数据结构课程设计农夫过河问题

合集下载

农夫过河

农夫过河

农夫过河问题——程序设计(2009-06-05 13:38:22)标签:分类:一、问题需求分析一个农夫带着一只狼、一只羊和一棵白菜,身处河的南岸。

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

问题是他面前只有一条小船,船小到只能容下他和一件物品,另外只有农夫能撑船。

另外,因为狼能吃羊,而羊爱吃白菜,所以农夫不能留下羊和白菜或者狼和羊单独在河的一边,自己离开。

请问农夫该采取什么方案才能将所有的东西运过河呢?二、算法选择求解这个问题的最简单的方法是一步一步进行试探,每一步都搜索所有可能的选择,对前一步合适的选择再考虑下一步的各种方案。

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

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

u 要实现广度优先搜索,一般都采用队列作为辅助结构。

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

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

三、算法的精化要模拟农夫过河问题,首先需要选择一个对问题中每个角色的位置进行描述的方法。

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

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

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

四、算法的实现完成了上面的准备工作,现在的问题变成:从初始状态二进制0000(全部在河的南岸) 出发,寻找一种全部由安全状态构成的状态序列,它以二进制1111(全部到达河的北岸) 为最终目标,并且在序列中的每一个状态都可以从前一状态通过农夫(可以带一样东西)划船过河的动作到达。

实习六-农夫过河问题

实习六-农夫过河问题

农夫过河问题一、需求分析1.问题描述:一个农夫带着一只狼、一只羊和一棵白菜,身处河的南岸。

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

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

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

2.基本要求:(1)利用图的存储结构(2)图的搜索算法(3)求出农夫将所有的东西运过河的所有方案二、设计1. 设计思想(1)存储结构以邻接矩阵存储合理状态,用一个一维数组保存所有的方案;(2)主要算法基本思想人,狼,羊和白菜共有2的四次方16种状态(河岸的状态可由人的状态确定),去掉不允许出现的6种状态,10个状态对应矩阵的10个结点值,然后根据状态的连续改变初始化矩阵,接着就用递归的深度优先法搜索所有的路径,即求出过河的方案。

main2. 设计表示(1)函数调用关系图main→Judge→Initiate→DFS→Push→StackPop→Top→GetTop→printfpath→Ch(2)函数接口规格说明int Judge(int a,int b) //将16种状态通过a,b输入,去掉不允许的6种int GetTop(Path *path,int *m) //出栈int Push(Path *path,int m) //入栈int Top(Path *path ,int *m) //读出栈顶值void Initiate(AdjMGraph *G,int n)//邻接矩阵顶点数为n的邻接矩阵G的建立int DFS(AdjMGraph *G,Path *path,int x,int t) 图G中搜索的起始点为X,从t点开始搜索与x关联的顶点,搜索过的点入栈path。

int printfpath(Path *path) //复制出出栈path中所有值,用FA【】保存void Printf(AdjMGraph *G)//辅助:邻接矩阵输出,用于观察搜索的过程。

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

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

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

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

农夫怎么才能把所有的东西安全运过河呢?实验要求如下:(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;}实验结果:四、实验总结。

农夫过河问题(数据结构课设)

农夫过河问题(数据结构课设)

#include "stdafx.h"#include <stdio.h>/*0代表在河的这边;1代表在河的对岸*/struct Condition {int farmer;int wolf;int sheep;int cabbage;};/*设置结构体*/struct Condition conditions [100];/*结构体条件数组*/char* action[100];/*字符串数组*/ void takeWolfOver(int i)/*把狼带过去*/ {action[i] = "带狼过去. (wolf)--->对岸";conditions[i+1].wolf=1;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void takeWolfBack(int i)/*把狼带回来*/{action[i] = "带狼回来. 本岸<---(wolf)";conditions[i+1].wolf=0;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void takeSheepOver(int i)/*把羊带过去*/{action[i] = "带羊过去. (sheep)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=1;conditions[i+1].cabbage=conditions[i].cabbage;} void takeSheepBack(int i)/*把羊带回来*/{action[i] = "带羊回来. 本岸<---(sheep)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=0;conditions[i+1].cabbage=conditions[i].cabbage;} void takeCabbageOver(int i)/*把菜带过去*/{action[i] = "带菜过去. (cabbage)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=1;} void takeCabbageBack(int i)/*把菜带回来*/{action[i] = "带菜回来. 本岸<---(cabbage)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=0;} void getOverBarely(int i)/*过河时的情况*/{action[i] = "空手过去. (barely)--->对岸";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;/*全不动*/} void getBackBarely(int i)/*返回时的情况*/{action[i] = "空手回来. 本岸<---(barely)";conditions[i+1].wolf=conditions[i].wolf;conditions[i+1].sheep=conditions[i].sheep;conditions[i+1].cabbage=conditions[i].cabbage;} void showSolution(int i)/*显示解决方法*/{int c;printf("\n");printf ("%s\n", "解决办法:");for(c=0; c<i; c++){printf ("step%d: %s\n", c+1, action[c]);/*换行输出*/}printf ("%s\n", "Successful!");}void tryOneStep(int i)/*再试一遍*/{int c;int j;if(i>=100)/*检查循环是否出现问题*/{printf("%s\n", "渡河步骤达到100步,出错!");return;}if(conditions[i].farmer==1&&conditions[i].wolf==1&&conditions[i].sheep==1&&conditions[i].cabbage==1)/*检查是否都过河*/{showSolution(i);/*是的,都过河了.返回*/return;}if((conditions[i].farmer!=conditions[i].wolf &&conditions[i].wolf==conditions[i].sheep)||(conditions[i].farmer!=conditions[i].sheep && conditions[i].sheep==conditions[i].cabbage))/*检查是否丢失,出错*/{/*不,狼会吃掉羊,或者羊会吃掉菜的*/return;}/*检查条件是否满足*/for (c=0; c<i; c++){if(conditions[c].farmer==conditions[i].farmer&&conditions[c].wolf==conditions[i].wolf&&conditions[c].sheep==conditions[i].sheep&&conditions[c].cabbage==conditions[i].cabbage) {return;}}j=i+1;if(conditions[i].farmer==0)/*农夫在河这边*/{conditions[j].farmer=1;getOverBarely(i);tryOneStep(j);if(conditions[i].wolf==0)/*如果狼没带过去*/{takeWolfOver(i);tryOneStep(j);}if(conditions[i].sheep==0){takeSheepOver(i);tryOneStep(j);}if(conditions[i].cabbage==0){takeCabbageOver(i);tryOneStep(j);}}else{conditions[j].farmer=0;getBackBarely(i);tryOneStep(j);if(conditions[i].wolf==1){takeWolfBack(i);tryOneStep(j);}if(conditions[i].sheep==1){takeSheepBack(i);tryOneStep(j);}if(conditions[i].cabbage==1){takeCabbageBack(i);tryOneStep(j);}}} int main()/*主函数*/{printf("问题:农夫过河。

农夫过河问题

农夫过河问题

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

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

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

过河有以下规则:(1)农夫一次最多能带一样东西(或者是狼、或者是羊、或者是白菜)过河;(2)当农夫不在场是狼会吃羊;(3)当农夫不在场是羊会吃掉白菜。

现在要求为农夫想一个方案,能将3样东西顺利地带过河。

从出事状态开始,农夫将羊带过河,然后农夫将羊待会来也是符合规则的,然后农夫将羊带过河仍然是符合规则的,但是如此这般往返,搜索过程便进入了死循环,因此,在这里,采用改进的搜索算法进行搜索。

二.基本要求(1)为农夫过河问题抽象数据类型,体会数据模型在问题求解中的重要性;(2)要求利用数据结构的方法以及C++的编程思想来完成问题的综合设计;(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结构体是为了储图的顶点数与边数,农夫过河问题我采用的是图的深度优先遍历思想。

农夫过河C语言课程设计

农夫过河C语言课程设计

农夫过河C语言课程设计一、课程目标知识目标:1. 理解C语言中基本的数据类型和语法结构;2. 学会使用C语言进行逻辑判断和循环控制;3. 掌握C语言中的函数定义和调用方法;4. 了解“农夫过河”问题的背景和解决方案。

技能目标:1. 能够运用C语言编写出解决“农夫过河”问题的程序;2. 培养逻辑思维和问题分析能力,将实际问题转化为程序代码;3. 提高编程实践能力,学会调试和修改代码,解决程序中的错误。

情感态度价值观目标:1. 激发学生对编程的兴趣,培养计算机科学素养;2. 培养学生面对问题积极思考、勇于探索的精神;3. 强调团队合作,学会与他人共同解决问题,培养沟通与协作能力。

分析课程性质、学生特点和教学要求:本课程为C语言编程课程,旨在让学生掌握C语言的基本知识,并通过解决实际问题,提高编程能力。

学生为初中生,具有一定的逻辑思维能力和数学基础。

教学要求注重实践,将理论教学与实际操作相结合,引导学生主动参与,培养其独立思考和解决问题的能力。

课程目标分解:1. 知识目标:通过讲解和实例演示,让学生掌握C语言的基本知识;2. 技能目标:通过编写“农夫过河”程序,提高学生的编程实践能力;3. 情感态度价值观目标:通过课程教学,激发学生对编程的兴趣,培养其积极思考、勇于探索的精神,以及团队合作能力。

二、教学内容1. C语言基础知识回顾:- 数据类型、变量、常量- 运算符、表达式、语句- 选择结构(if-else)- 循环结构(for、while、do-while)2. 函数定义与调用:- 函数的概念和作用- 函数的定义、声明和调用- 递归函数的原理和应用3. “农夫过河”问题分析:- 问题的描述和规则- 状态表示和状态空间- 搜索策略(深度优先、广度优先)4. 编程实践:- 设计“农夫过河”问题的算法- 编写C语言程序实现算法- 调试和优化程序5. 教学内容安排与进度:- 第一课时:C语言基础知识回顾,引入“农夫过河”问题- 第二课时:函数定义与调用,分析问题并设计算法- 第三课时:编写程序,实现“农夫过河”算法- 第四课时:调试优化程序,总结经验,展示成果教学内容关联教材章节:- 《C语言程序设计》第一章:C语言概述- 《C语言程序设计》第二章:数据类型与运算符- 《C语言程序设计》第三章:控制结构- 《C语言程序设计》第四章:函数- 《C语言程序设计》第十章:算法与程序设计实例教学内容注重科学性和系统性,结合教材章节,使学生能够在掌握C语言基础知识的基础上,学会解决实际问题,提高编程能力。

农夫过河问题

农夫过河问题

一、题目:农夫过河问题二、目的与要求1、目的:通过布置具有一定难度的实际程序设计项目,使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法,以及它们在程序中的使用方法;使学生掌握分析问题,求解问题的方法并提高学生设计编程实现的能力。

2、要求:基本要求:1.要求利用C\C++语言来完成系统的设计;2.突出C语言的函数特征(以多个函数实现每一个子功能)或者C++语言面向对象的编程思想;3.画出功能模块图;4.进行简单界面设计,能够实现友好的交互;5.具有清晰的程序流程图和数据结构的详细定义;6.熟练掌握C语言或者C++语言的各种操作。

创新要求:在基本要求达到后,可进行创新设计,如系统用户功能控制,改进算法的实现,实现友好的人机交互等等三、问题描述和求解方法:1 、问题描述要求设计实现农夫过河问题(农夫带着一只狼,一只养,一棵白菜,一次只能带一个东西)如何安全过河。

2 、问题的解决方案:可以用栈与队列、深度优先搜索算法及广度优先搜索算法相应的原理去解决问题。

1)实现四个过河对象(农夫、白菜、羊和狼)的状态,可以用一个四位二进制数来表示,0表示未过河,1表示已经过河了。

2)过河的对象必须与农夫在河的同一侧,可以设计函数来判断。

3)防止状态往复,即农夫将一个东西带过去又带回来的情况发生,需将所有可能的状态进行标定。

4)可用深度优先搜索算法及广度优先搜索算法去解题。

四、解题过程1.分析程序的功能要求,划分程序功能模块。

2.画出系统流程图。

3.代码的编写。

定义数据结构和各个功能子函数。

4.程序的功能调试。

5.完成系统总结报告以及使用说明书五、进度安排此次课程设计时间为一周,分以下几个阶段完成:1.选题与搜集资料:每人选择一题,进行课程设计课题的资料搜集。

2.分析与概要设计:根据搜集的资料,进行程序功能与数据结构分析,并选择合适的数据结构、并在此基础上进行实现程序功能的算法设计。

课程设计农夫过河

课程设计农夫过河

课程设计农夫过河一、教学目标本章节的教学目标包括以下三个方面:1.知识目标:学生能够理解并掌握“农夫过河”问题的背景、条件和目标,了解相关的数学知识,如线性方程、不等式等。

2.技能目标:学生能够运用所学的数学知识,通过分析和逻辑推理,找到解决问题的方法,并能够进行有效的沟通和合作。

3.情感态度价值观目标:学生能够培养问题解决的兴趣和自信心,培养团队合作和沟通的能力,培养对数学学科的积极态度。

二、教学内容本章节的教学内容主要包括以下几个部分:1.引入“农夫过河”问题的背景和条件,引导学生了解问题的目标和意义。

2.引导学生学习相关的数学知识,如线性方程、不等式等,并通过例题和练习题进行巩固。

3.引导学生运用所学的数学知识,分析和解决“农夫过河”问题,寻找最优解法。

4.通过小组讨论和展示,培养学生的团队合作和沟通能力。

三、教学方法本章节的教学方法主要包括以下几种:1.讲授法:教师通过讲解和演示,引导学生理解和掌握相关的数学知识和解决问题的方法。

2.讨论法:教师学生进行小组讨论,鼓励学生提出问题、分享思路和解决方案。

3.案例分析法:教师提供具体的案例,引导学生运用所学的数学知识进行分析和解决。

4.实验法:教师引导学生进行实验操作,通过实践来加深对数学知识的理解和应用。

四、教学资源本章节的教学资源主要包括以下几种:1.教材:教师准备相关的数学教材,提供理论知识的学习和练习题的练习。

2.参考书:教师提供相关的参考书籍,供学生进一步深入学习和探索。

3.多媒体资料:教师准备相关的多媒体资料,如图片、视频等,用于辅助讲解和演示。

4.实验设备:教师准备相关的实验设备,供学生进行实验操作和实践。

五、教学评估本章节的教学评估主要包括以下几种方式:1.平时表现:教师通过观察和记录学生在课堂上的参与程度、提问回答等情况,评估学生的学习态度和表现。

2.作业:教师通过布置和批改相关的作业,评估学生对知识的理解和应用能力。

3.考试:教师通过安排章节考试或者小测验,评估学生对知识掌握的程度和问题解决的能力。

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

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

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

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

农夫怎么才能把所有的东西安全运过河呢?实验要求如下:(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;}实验结果:四、实验总结。

农夫携物过河程序

农夫携物过河程序

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

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

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

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

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

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

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

对于农夫,狼,羊,蔬菜组成一个4位向量,即图的顶点(F,W,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//图的各项信息{int VertexNum,CurrentEdges; //图的当前顶点数和边数VexType VerticesList[MaxNumVertices]; //顶点向量(代表顶点)int Edge[MaxNumVertices][MaxNumVertices];//邻接矩阵//用于存储图中的边,其矩阵元素个数取决于顶点个数,与边数无关}AdjGraph;⑵为了实现上述程序的功能,需要:①生成所有安全的图的顶点;②查找顶点的位置;③判断目前(F,W,S,V)是否安全,安全返回1,否则返回0;④判断顶点i和顶点j之间是否可转换,可转换返回真,否则假;⑤深度优先搜索从u到v的简单路径;⑥输出从u到v的简单路径,即顶点序列中不重复出现的路径。

数据结构农夫过河项目课报告

数据结构农夫过河项目课报告

数据结构农夫过河项目课报告数据结构-农夫过河项目课报告-计算机四班第七组项目名称:农夫过河算法与数据结构设计专业班级:计算机科学与技术四班学生姓名:王喆指导教师: 完成日期:2015年12月28日数据结构-农夫过河项目课报告-计算机四班第七组农夫过河算法与数据结构设计摘要农夫过河问题即一个农夫带着一只狼、一只羊和一棵白菜,身处河的南岸,他需要把这些东西全部运到河的北岸。

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

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

好在狼是是肉动物,它不吃白菜,问农夫应该采取什么方案才能将所有的东西安全地从河的南岸运到北岸,这类农夫问题是一个传统的数据结构问题,农夫过河问题根据图求解的搜索过程可采用两种不同的策略:一种是图的深度优先遍历搜索,另外一种是广度优先遍历搜索。

如果采用深度优先遍历搜索,则需要采用递归的方式来编写程序,而这种程序的系统的开销比较大,如果采用广度优先搜索,则可以借助队列的方式,这种方式开销较小。

关键字:农夫过河,广度优先遍历搜索,队列,深度优先遍历搜索,递归。

2数据结构-农夫过河项目课报告-计算机四班第七组目录1.前言…………………………………………………………42.设计任务与技术要求………………………………………43.总体设计方案………………………………………………44.数据结构和算法的设计……………………………………55.程序测试与调试(一)……………………………………7 6.程序测试与调试(二)..........................................9 7.程序出现的问题及修改情况....................................14 8.心得与体会.........................................................14 参考文献 (15)3数据结构-农夫过河项目课报告-计算机四班第七组1.前言课程研究项目是《数据结构》课程学习的重要方式之一,也是《数据结构》课程学习的重要组成部分之一。

农夫过河问题

农夫过河问题
{
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)引言所谓农夫过河问题是指农夫带一只狼、一只羊和一棵白菜在河南岸, 需要安全运到北岸。

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

问农夫怎么能安全过河, 当然狼吃羊, 羊吃白菜, 农夫不能将这两种或三种物品单独放在河的一侧, 因为没有农夫的照看, 狼就要吃羊, 而羊可能要吃白菜? 这类问题的实质是系统的状态问题, 要寻求的是从初始状态经一系列的安全状态到达系统的终止状态的一条路径。

1 问题描述一个农夫带一只狼、一棵白菜和一只羊要从一条河的南岸过到北岸,农夫每次只能带一样东西过河,但是任意时刻如果农夫不在场时,狼要吃羊、羊要吃白菜,请为农夫设计过河方案。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

农夫过河报告(最终版)

农夫过河报告(最终版)

农夫过河算法实验报告――数据结构项目课研究课题组长:崔俊组员:李琦、郑鸿飞、王琅辉、张育博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)的一条简单路径,这样做只能搜到一种合理方法,因为深度优先搜索遍历一个图的时候每一个结点只能被访问一次。

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

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

目录引言 (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种可能状态。

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

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

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

一、需求分析描述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."将狼带回起始岸语句。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

扬州大学信息工程学院
《数据结构》
---课程设计报告
题目:农夫过河
班级:网络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岸
五,测试数据及运行结果
运行结果:
六,源程序
#include<stdio.h>
int s[100],t=0;
void BA(int a[4],int b[4]);
void xu(int a[4])
{int i,j,k;
for(i=0;i<3;i++)
for(j=i+1;j<4;j++)if(a[i]<a[j])
{k=a[i];a[i]=a[j];a[j]=k; }}
int f(int a[4],int x)
{int i,j=0,b[4];
for(i=0;a[i];i++)
{if(i==x)continue;
b[j]=a[i];
if(j&&b[j]==b[j-1]-1)return 1;j++;} return 0;}
int g()
{int i,r;
for(i=t-1;i>=t/2;i-=2)
{for(r=0;r<t-i;r++)
if(s[t-r]!=s[i-r]) break;
if(r==t-i)break;}
if(i<t/2)return 0;
else return 1;}
void huan(int a[4],int b[4],int x)
{int i;
for(i=0;a[i]!=x;i++);
a[i]=0;b[3]=x;xu(a);xu(b);}
void AB(int a[4],int b[4])
{int i;
for(i=0;a[i-1]||i==0;i++)
{if(f(a,i)) continue;
s[t]=a[i];
if(g()) continue;
huan(a,b,s[t]);
t++;
if(a[0]==0) break;
BA(a,b);
if(a[0]==0) break;
t--;
huan(b,a,s[t]);
}
}
void BA(int a[4],int b[4])
{int i;
for(i=0;b[i-1]||i==0;i++)
{if(f(b,i)) continue;
s[t]=b[i];
if(g()) continue;
huan(b,a,s[t]);
t++;
AB(a,b);
if(a[0]==0) break;
t--;
huan(a,b,s[t]);}}
void main()
{int i,a[4]={3,2,1},b[4]={0};
AB(a,b);
for(i=0;i<t;i++)
{if(i%2)printf("农夫从B岸到A岸:");
else printf("农夫从A岸到B岸:");
switch(s[i])
{case 0:printf("什么都不带");break;
case 1:printf("把狼带过河");break;
case 2:printf("把羊带过河");break;
case 3:printf("把菜带过河");break;
}
printf("\n");} }。

相关文档
最新文档