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

合集下载

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

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

数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河实验报告:数据结构与算法专题实验报告实验题目:八皇后问题的求解与背包问题的求解实验目的:1. 掌握八皇后问题的求解方法,了解回溯算法的应用。

2. 掌握背包问题的求解方法,了解动态规划算法的应用。

3. 进一步理解数据结构与算法的基本概念和应用。

实验内容:1. 八皇后问题的求解八皇后问题是一个经典的递归与回溯算法问题,要求在一个8×8的棋盘上放置8个皇后,使得任意两个皇后不在同一行、同一列或同一斜线上。

具体求解步骤如下:a. 定义一个8×8的二维数组作为棋盘,初始化所有元素为0。

b. 从第一行开始,依次尝试在每一列放置皇后。

c. 对于每一列,判断当前位置是否与已经放置的皇后冲突。

如果冲突,则回溯到上一行,重新选择位置;否则,继续放置下一行的皇后。

d. 当放置完所有皇后时,输出结果。

2. 背包问题的求解背包问题是一个经典的动态规划算法问题,要求在给定的一组物品中选择一些物品放入背包,使得背包的总重量最大,但不能超过背包的承重量。

具体求解步骤如下:a. 定义一个二维数组dp,其中dp[i][j]表示在前i个物品中选择,背包容量为j时的最大重量。

b. 初始化dp数组的第一行和第一列为0,表示背包容量为0时和没有物品可选时的最大重量都为0。

c. 对于每个物品,分两种情况讨论:- 如果当前物品的重量大于背包的容量,则无法选择该物品,直接继承前i-1个物品的最大重量,即dp[i][j] = dp[i-1][j];- 如果当前物品的重量小于等于背包的容量,则可以选择该物品或不选择该物品。

选择该物品时,背包的总重量为dp[i-1][j-w[i]] + v[i],不选择该物品时,背包的总重量为dp[i-1][j]。

取两者中的较大值作为dp[i][j]的值。

d. 最终,dp[n][m]即为所求的最大重量,其中n为物品的个数,m为背包的承重量。

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

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

数据结构课程设计报告(农夫过河)第一篇:数据结构课程设计报告(农夫过河)目录引言...................................................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;}实验结果:四、实验总结。

八皇后实验报告

八皇后实验报告

八皇后实验报告八皇后实验报告引言:八皇后问题是一个经典的数学问题,它要求在一个8x8的国际象棋棋盘上放置8个皇后,使得任意两个皇后都不会互相攻击。

这个问题看似简单,但实际上却充满了挑战。

在本次实验中,我们将探索八皇后问题的解法,并通过编写算法来解决这个问题。

一、问题背景:八皇后问题最早由数学家马克斯·贝瑟尔于1848年提出,它是一道经典的递归问题。

在国际象棋中,皇后可以在同一行、同一列或同一对角线上进行攻击,因此我们需要找到一种方法,使得8个皇后彼此之间不会相互攻击。

二、解决方法:为了解决八皇后问题,我们可以使用回溯法。

回溯法是一种穷举搜索的方法,它通过逐步尝试所有可能的解决方案,直到找到符合要求的解。

具体步骤如下:1. 初始化一个8x8的棋盘,并将所有格子标记为无皇后。

2. 从第一行开始,依次尝试在每一列放置一个皇后。

3. 在每一列中,检查当前位置是否符合要求,即与已放置的皇后不在同一行、同一列或同一对角线上。

4. 如果当前位置符合要求,将皇后放置在该位置,并进入下一行。

5. 如果当前位置不符合要求,尝试在下一列放置皇后。

6. 重复步骤3-5,直到找到一个解或者所有可能的位置都已尝试过。

7. 如果找到一个解,将其输出;否则,回溯到上一行,继续尝试下一列的位置。

三、编写算法:基于上述步骤,我们可以编写一个递归函数来解决八皇后问题。

伪代码如下所示:```function solveQueens(board, row):if row == 8:print(board) # 打印解returnfor col in range(8):if isSafe(board, row, col):board[row][col] = 1solveQueens(board, row + 1)board[row][col] = 0function isSafe(board, row, col):for i in range(row):if board[i][col] == 1:return Falseif col - (row - i) >= 0 and board[i][col - (row - i)] == 1:return Falseif col + (row - i) < 8 and board[i][col + (row - i)] == 1:return Falsereturn Trueboard = [[0]*8 for _ in range(8)]solveQueens(board, 0)```四、实验结果:通过运行上述算法,我们得到了八皇后问题的所有解。

数据结构 八皇后问题 报告

数据结构 八皇后问题 报告

数据结构实验报告实验名称:实验2 利用栈结构实现八皇后问题学生姓名:廖宁班级:2009211114班内序号:18学号:09210411日期:2010年11月18日1.实验要求八皇后问题是19世纪著名的数学家高斯于1850年提出的。

他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。

请设计算法打印所有可能的摆放方法。

提示:(1)可以使用递归或非递归两种方法实现。

(2)实现一个关键算法,判断任意两个皇后是否在同一行、同一列和同一斜线上。

2. 程序分析程序工程包含一个模板类函数实现定义的源文件forthelove.cpp和测试源文件sbsuowang.cpp。

2.1 存储结构存储结构为栈。

2.2 关键算法分析(1)判断在第row行第column列摆放皇后是否非法,采取定行不定列的方法,列相等的算法为position[i]=colume,对角线相等有两种情况:一是position在上则row-i=colume-position[i];二是position在下,row-i=position[i]-colume.加入能放皇后,列和对角线上值都不能相等。

具体代码如下:int IsIllegal(int row, int column, const int* position){/int i;for (i=1; i < row; ++i){if ((position[i] == column)|| (row - i == column - position[i])|| (row - i == position[i] - column)){return TRUE;}}return FALSE;}(2)我采用定行尝试列的方法来遍历,记录皇后位置的数组可以和栈数组合二为一,而栈顶指针也可以和行坐标合二为一,这样一来栈帧只要一个列坐标就可以了。

1.伪代码:while(栈不空){if ( 行(即栈顶) <= n && 列<= n ){if ( 当前位置不能放皇后){列++;}else{列入栈(隐含着"行++");列= 1;}}else{if ( 行(即栈顶) > n ){输出位置数组(即栈数组);}列退栈(隐含着"行--");列++;}}//end while具体实现代码:void Queens(int n, void (* Visit)(const int* position)) {//position[n]数组:position[0]为棋盘大小,即n//position[1]~position[n]:下标为行坐标,值为列坐标int* stack = NULL; //栈int top; //栈顶int column; //列stack = (int*)malloc((n + 1) * sizeof(int));stack[0] = n;top = column = 1;while(top > 0){if ((top <= n) && (column <= n)){if (IsIllegal(top, column, stack)){++column;}else{stack[top++] = column;column = 1;}}else{if (top > n){(* Visit)(stack);}column = stack[--top];++column;}}//end whilefree(stack);return;}3. 程序运行结果程序实现八皇后问题:经过测试,程序运行良好,无明显错误。

背包问题数据结构实验报告

背包问题数据结构实验报告

淮阴工学院数据结构课程设计报告选题名称:背包问题求解系(院):计算机工程系专业:计算机科学与技术班级:网络107姓名:蒋为维学号: ********** 指导教师:张亚红张勇军学年学期:2008 ~ 2009 学年第 2 学期2009 年 6 月20 日设计任务书注意:1.任务书格式参照“任务书范例”执行。

2.范例中的红色..文字应根据你所选择的具体课题,修改为对应的内容。

范例中的其它内容不变。

摘要:组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点,这不仅在于其内在的复杂性有着重要的理论价值,同时也在于它们能在现实生活中广泛的应用。

比如资源分配、投资决策、装载设计、公交车调度等一系列的问题都可以归结到组合优化问题中来。

但是,往往由于问题的计算量远远超出了计算机在有效时间内的计算能力,使问题的求解变为异常的困难。

尤其对于NP 完全问题,如何求解其最优解或是近似最优解便成为科学的焦点之一。

背包问题是一个典型的组合优化问题,在计算理论中属于NP-完全问题, 其计算复杂度为)2(O n ,传统上采用动态规划来求解。

设w[i]是经营活动 i 所需要的资源消耗,M 是所能提供的资源总量,p[i]是人们经营活动i 得到的利润或收益,则背包问题就是在资源有限的条件下, 追求总的最大收益的资源有效分配问题。

关键词:背包问题,堆栈,回溯法,递归目录1 需求分析 (1)1.1课程设计(实践周)题目 (1)1.2课程设计(实践周)任务及要求 (1)1.3课程设计(实践周)思想 (1)1.4软硬件运行环境及开发工具 (2)2概要设计 (2)2.1本课题设计所用数据结构以及流程图 (2)2.1.1栈的原理 (2)2.1.2溯法介绍 (3)2.1.3包问题整体流程图 (5)2.2本课题主要设计思想 (6)3代码设计 (6)3.1定义栈和顺序表结构体 (6)3.2栈的初始化 (7)3.3判断栈空 (7)3.4入栈 (7)3.5出栈 (8)3.6输入元素 (8)4调试与操作说明 (9)5总结 (11)6致谢 (12)7参考文献 (13)1需求分析1.1本课程设计(实践周)题目假设有一个能装入总体积为T 的背包和n 件体积分别为w1 , w2 , … , wn 的物品,能否从n 件物品中挑选若干件恰好装满背包,即使w1 +w2 + … + wn=T ,要求找出所有满足上述条件的解。

北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)

北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)
2.程序分析
2.1存储结构
存储结构:栈(递归)
2.2关键算法分析
递归调用摆放皇后
1、关键算法伪代码:
(1).如果输入的row大于皇后的数量,则输出皇后的位置
(2)否则col从0开始递增
(3)检测(row,col)上的点是否符合条件,不符合则col自增,符合则转到下一个皇后的排列
2、代码详细分析:
void SeqStack::PlaceQueen(int row) //摆放皇后
{
for (int col=0;col< n;col++) //遍历0~7,
{
Push(col);
if (Check()) //判断摆放皇后的位置是否合适
{
if (row< n-1) //若还没有放到最后一个,则进行下一个皇后的放置
PlaceQueen(row+1);
else
{
num++; //计数器加1
{
if(top>= m-1) throw "上溢";
top++; //栈顶指针上移
data[top]=x;
}
void SeqStack::Pop() //出栈操作
{
if(Empty()) throw "下溢";
top--; //栈顶指针下移
}
void SeqStack::PlaceQue计放置八皇后,只要修改输入的N,便可显示其他情况的结果。
Print(n); //打印成功的坐标点
}
}
Pop(); //若不符合条件则出栈
}
}
bool SeqStack::Empty()

数据结构实验报告--八皇后

数据结构实验报告--八皇后

数据结构实验报告1.实验要求实验目的:利用栈结构实现八皇后问题八皇后问题如下:八皇后问题是19世纪著名的数学家高斯于1850年提出的。

他的问题是,在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行,同一列,同一斜线上。

实验内容:利用所学的栈结构用递归或非递归解决八皇后问题。

2. 程序分析程序使用程序最主要只是在主函数用了一个递归函数Queen。

Queen函数使用了三个参数m,flag[][],chess[][]。

其中m是行数,flag[][]是判断二维数组何处可以放置皇后,chess[][]是存储字符串的二维数组。

主函数中对Queen函数中的形参数组flag[][],chess[][]进行初始化,在Queen函数中再进行各种操作。

Queen函数执行代码,首先行数m为0,当m小于7时,通过if…else…语句,利用Queen(m+1,f,c)重新执行递归函数到下一行。

2.1 存储结构存储结构:数组存储。

flag[][]数组存储数字判断输出和储能放置皇后,chess[][]数组存储字符串即皇后和非皇后的形状。

2.2 关键算法分析1、关键算法:a.for(i=0;i<8;i++)for(j=0;j<8;j++){f[i][j]=0;c[i][j]='*';说明:对棋盘进行初始化未放置皇后的为“*”b.for(i=0;i<8;i++)for(j=0;j<8;j++){c[i][j]=chess[i][j];f[i][j]=flag[i][j];}说明:对c[][],f[][]进行初始化。

c.for(i=0;i<8;i++)for(j=0;j<8;j++){i f(f[i][j]==0 && (i+j==m+k || m==i || k==j || m-k==i-j))f[i][j]=-1;}c[m][k]='#';说明:已放置皇后的行、列以及对角线都不能再放置皇后。

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

八皇后问题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 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,要求找出所有满足上述条件的解。

例如:当T=10,各件物品的体积{1,8,4,3,5,2}时,可找到下列4组解:(1,4,3,2)(1,4,5)(8,2)(3,5,2)。

2.实现提示可利用回溯法的设计思想来解决背包问题。

首先,将物品排成一列,然后,顺序选取物品装入背包,若已选取第i件物品后未满,则继续选取第i+1件,若该件物品“太大”不能装入,则弃之,继续选取下一件,直至背包装满为止。

如果在剩余的物品中找不到合适的物品以填满背包,则说明“刚刚”装入的物品“不合适”,应将它取出“弃之一边”,继续再从“它之后”的物品中选取,如此重复,直到求得满足条件的解,或者无解。

由于回溯求解的规则是“后进先出”,自然要用到“栈”。

进一步考虑:如果每件物品都有体积和价值,背包又有大小限制,求解背包中存放物品总价值最大的问题解---最优解或近似最优解。

3.题目源代码#define maxsize 1024#define null 0#include"stdio.h"#include"conio.h"#include"stdio.h"typedef struct{int last;int data[maxsize];}seqlist; //定义顺序表结构体typedef struct{int top;int sum;int data[maxsize];}seqstack; //定义栈结构体seqstack *init_seqstack(){seqstack *s;s=new seqstack;if(!s){printf("空间不足");return null;}elses->top=-1;s->sum=0;return s;}} //栈初试化int empty_seqstack(seqstack *s){if (s->top==-1)return 1;elsereturn 0;} //判断空栈int push_seqstack(seqlist *l,int i,seqstack *s) //入栈{if(s->top==maxsize-1)return 0;else{s->top++;s->data[s->top]=i; //顺序表中第i 个元素,i 入栈s->sum=s->sum+l->data[i]; //栈中sum加和!return 1;}}int pop_seqstack(seqlist *l,seqstack *s,int *x) //出栈{if(empty_seqstack(s))return 0;else{*x=s->data[s->top];s->sum=s->sum-l->data[s->data[s->top]];s->top--;return 1;}}seqlist *init_seqlist(){seqlist *l;int x=1;l=new seqlist;l->last=0;printf("-------------------------------------------\n请依次输入个物品的大小,输入0结束。

\n-------------------------------------------\n");scanf("%d",&x);while(x!=0){l->data[l->last]=x;l->last++;scanf("%d",&x);}return l;}/*创建数组,储存物品体积*/void knapsk(int n,seqlist *l){seqstack *s;int flag=1;int i=0;int t;s=init_seqstack(); //初始化栈命名为Swhile(flag!=0){while(i<=l->last){push_seqstack(l,i,s);if(s->sum==n){printf("-------------------------------------------\n可行的解是:");for(t=0;t<=s->top;t++)printf("%d ",l->data[s->data[t]]);printf("\n");pop_seqstack(l,s,&i);i++;}else{if(s->sum>n){pop_seqstack(l,s,&i);i++;}else}}while(i==l->last+1){flag=pop_seqstack(l,s,&i);i++;if(flag==0)printf("-------------------------------------------\n执行完毕");}}}int main(){int n;seqlist *l;printf("请输入背包体积n的大小,n=?");scanf("%d",&n);l=init_seqlist();knapsk(n,l);return 1;}题目3 农夫过河问题的求解一个农夫带着一只狼、一只羊和一棵白菜,身处河的南岸。

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

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

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

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

2.实现提示求解这个问题的简单方法是一步一步进行试探,每一步搜索所有可能的选择,对前一步合适的选择后再考虑下一步的各种方案。

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

可用4位二进制数顺序分别表示农夫、狼、白菜和羊的位置。

用0表在南岸,1表示在北岸。

例如,整数5 (0101)表示农夫和白菜在南岸,而狼和羊在北岸。

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

总状态共16种(0000到1111),(或者看成16个顶点的有向图)可采用广度优先或深度优先的搜索策略---得到从0000到1111的安全路径。

以广度优先为例:整数队列---逐层存放下一步可能的安全状态;Visited[16]数组标记该状态是否已访问过,若访问过,则记录前驱状态值---安全路径。

相关文档
最新文档