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

合集下载

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

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

数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河实验报告:数据结构与算法专题实验报告实验题目:八皇后问题的求解与背包问题的求解实验目的: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]='#';说明:已放置皇后的行、列以及对角线都不能再放置皇后。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

算法背包实验报告

算法背包实验报告

一、实验背景背包问题(Knapsack problem)是组合优化领域中的一个经典问题,它来源于日常生活中物品选择与装载的问题。

0-1背包问题是指给定一组物品,每个物品都有一定的重量和价值,选择一部分物品装入背包,使得背包总重量不超过给定限制,且物品总价值最大。

本实验旨在通过实现动态规划算法解决0-1背包问题,并分析其时间复杂度和空间复杂度。

二、实验目的1. 理解动态规划算法的基本思想和解决问题的步骤。

2. 掌握动态规划算法在解决0-1背包问题中的应用。

3. 分析0-1背包问题的数学模型,并建立求解最优值的递归关系式。

4. 对比不同背包问题的求解方法,分析其优缺点。

三、实验原理0-1背包问题的数学模型如下:设背包容量为C,物品集合为I,第i个物品的重量为w(i),价值为v(i),则0-1背包问题的目标函数为:Maximize Σ(v(i) x(i)),其中x(i) ∈ {0, 1}。

约束条件为:Σ(w(i) x(i)) ≤ C。

动态规划算法通过将问题分解为子问题,并存储子问题的解,以避免重复计算。

对于0-1背包问题,其状态可以表示为:dp[i][j] = max(dp[i-1][j], dp[i-1][j-w(i)] + v(i)),其中i表示物品编号,j表示剩余容量。

当i=0或j-w(i)<0时,dp[i][j] = 0。

四、实验过程1. 设计数据结构:定义物品类,包含物品编号、重量和价值属性。

2. 生成测试数据:随机生成一定数量的物品,并设置背包容量。

3. 实现动态规划算法:根据上述原理,实现0-1背包问题的动态规划算法。

4. 测试算法:使用测试数据验证算法的正确性。

5. 分析算法性能:分析算法的时间复杂度和空间复杂度。

五、实验结果与分析1. 算法正确性:通过测试数据验证,算法能够正确求解0-1背包问题。

2. 时间复杂度:动态规划算法的时间复杂度为O(nC),其中n为物品数量,C为背包容量。

农夫过河 实验报告

农夫过河 实验报告

农夫过河实验报告
实验报告:农夫过河
实验目的:
1. 了解农夫过河问题的规则和约束条件;
2. 分析农夫过河问题的求解思路;
3. 实现农夫过河问题的求解算法。

实验原理:
农夫过河问题是一种经典的逻辑推理问题,涉及农夫、狼、羊和菜四个角色过河的情景。

根据约束条件,农夫每次只能带一种物品过河,而且农夫不能将狼和羊、羊和菜同时留在岸边,否则会发生危险。

实验步骤:
1. 设计数据结构表示问题的状态,如使用二进制位表示农夫、狼、羊和菜的位置;
2. 使用递归算法实现问题的解法,通过深度优先搜索遍历所有可能的状态,并根据约束条件进行剪枝;
3. 运行程序,输出农夫过河的解答序列。

实验结果:
根据实验步骤中的算法和程序设计,成功地求解了农夫过河问题,并输出了正确的解答序列。

实验结果表明,农夫可以经过
一系列合法的操作,将狼、羊和菜都安全地带过河。

实验结论:
通过本次实验,我们深入理解了农夫过河问题的规则和约束条件,并成功地实现了问题的求解算法。

实验结果表明,农夫过河问题有多种可能的解法,但只有符合约束条件的解才是正确的解答。

这个经典的逻辑推理问题在计算机科学中具有重要的意义,可以用于教学和娱乐等领域。

数据结构八皇后问题实验报告

数据结构八皇后问题实验报告

八皇后问题一.八皇后问题简述:在8*8的国际象棋棋盘上放置8个皇后,使任意两个皇后不能互相攻击,即任何行任何列或对角线(与水平轴的夹角为45°或135°的斜线)上不得有两个或两个以上的皇后,这样的一个格局称为问题的一个解。

请求八皇后问题的算法。

二.解决思路:先声明我们根据条件可以知道皇后肯定是每行都有且只有一个所以我们创建一个数组x[t]让数组角标表示八皇后的行,用这个角标对应的数组值来确定这个皇后在这行的那一列。

我们用递归来做:这问题要求皇后所在的位置必须和其他皇后的位置不在同一行、列还有把两个皇后看成点其|斜率|=1;所以我们就要写这个限定条件用一个函数来实现:函数内对每一个已经放好的皇后的位置进行判断,所以就要有个循环。

我们既然是用递归来解决问题那就要把这个问题分成一个个相同的小问题来实现。

不难发现我们要在8*8的方格里放好8个皇后那我们就要知道在8(列)*7(行)是怎么放的在有我们事先写好的判断函数放好最后行就搞定了;以此类推我们要知道8*7的怎么方的我们就要知道8*6是怎么样的就好了,所以我们是以一行怎么放作为一个单元。

我们就去建一个可以放好一行的函数backtrack(int t)里面的t表示是第几行,在main函数调用的时候第一次传进来的是0也就是从第一行开始判断。

我们就开始写函数体了:每一行有8个位置可以放,每一个位置我们都要去判断一下所以我们就用循环来搞定。

在这个循环里面我们让x[t]=i也就是从这一行的第一个开始判断。

放好后就要去判断是否符合条件。

如果符合条件我们就在调用这个函数本身backtrack 不过传进去的参数是t+1也就是下一行的意思。

在进行判断下一行之前我们要判断一下t是不是等于8也就是已经是最后一行了,如果是最后一行了我们就可以将其进行输出。

打印8*8的矩阵(提示在写一个函数)皇后的位置用1表示出来没有的用0表示。

三.代码与注解:#include <math.h>#include <stdio.h>#include <time.h>#include<string.h>#include<conio.h> //用getch()要调用的头文件#include <stdlib.h> //要用system函数要调用的头文件int SUM=0; //统计有多少种可能int shezhi(){ //设置为N皇后问题int N;printf("这是一个N皇后问题...\n请输入N=");scanf("%d",&N);return N;}void Print(int N,int x[]) //印出結果{int MAX=N;for(int i=0;i<MAX;i++){for(int j=0;j<MAX;j++)if(j==x[i])printf("@");elseprintf("*");printf("\n");}SUM++; //打印一种情况统计一次printf("\n");}int Judge(int k,int x[]) //判断是否在同一直、橫、斜线上有其它棋子{int i;for(i=0;i<k;i++)if( abs(k-i)==abs(x[i]-x[k]) || x[i]==x[k] ) //函数名: abs; 功能: 求整数的绝对值 ;return 0;return 1;}void backtrack(int t,int N,int x[]) // 把棋子放到棋盘上{ int MAX=N;int i;for(i=0;i<MAX;i++){x[t]=i;if(Judge(t,x)){if(t==MAX-1){Print(MAX,x); // 找到其中一种放法,印出結果}else backtrack(t+1,N,x);}}}void Introduce(){printf("1.设置为N皇后问题。

农夫过河报告(最终版)

农夫过河报告(最终版)

农夫过河算法实验报告――数据结构项目课研究课题组长:崔俊组员:李琦、郑鸿飞、王琅辉、张育博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的状态。

农夫过河实验报告

农夫过河实验报告

“数据结构与算法综合实验”课程设计报告题目:农夫过河问题学院计算机科学技术年级2014级专业计算机科学与技术学号********姓名高晗日期2016年3月30日星期三成绩评语黑龙江大学计算机科学技术学院、软件学院《数据结构与算法综合实验》报告1.系统概述(1)一个农夫带着一只狼、一只羊和一棵白菜,身处河的南岸,他要把这些东西全部运到北岸。

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

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

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

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

(2)为农夫过河问题抽象数据模型,体会数据模型在求解问题中的重要作用。

(3)掌握顺序表和队列的逻辑结构和存储结构。

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

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

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

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

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

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

(4)实验运行环境为VC++6.0.3.系统概要设计(1)数据结构设计要模拟农夫过河的问题,用四位二进制数顺序分别表示农夫,狼,羊,白菜的位置。

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

则问题的初始状态是整数(二进制数表示为0000);问题的终结状态是整数15(二进制表示为1111)。

算法背包问题实验报告

算法背包问题实验报告

一、实验目的1. 掌握动态规划的基本思想和应用场景。

2. 理解并实现0-1背包问题的动态规划解法。

3. 比较贪心算法在解决背包问题时的适用性和局限性。

4. 分析不同算法的时间复杂度和空间复杂度。

二、实验原理背包问题是一种典型的组合优化问题,它描述为:给定一组物品,每种物品都有一定的重量和价值,在限定的最大承重(背包容量)下,如何选择物品使得背包内物品的总价值最大。

三、实验内容本实验主要涉及以下内容:1. 0-1背包问题动态规划解法- 使用二维数组实现动态规划算法,记录每个子问题的最优解。

- 使用一维数组优化空间复杂度,通过滚动数组的方式实现。

2. 贪心算法解决背包问题- 分析贪心算法在解决背包问题时的适用性和局限性。

3. 比较两种算法的性能- 通过实际数据和测试案例,比较动态规划算法和贪心算法在解决背包问题时的运行时间和结果。

四、实验过程1. 0-1背包问题动态规划解法- 二维数组实现:- 定义一个二维数组dp,其中dp[i][j]表示前i个物品放入容量为j的背包中的最大价值。

- 遍历所有物品和背包容量,根据物品是否放入背包更新dp数组。

- 最终dp[m][W]即为最大价值。

- 一维数组实现:- 定义一个一维数组dp,其中dp[j]表示容量为j的背包中的最大价值。

- 遍历所有物品,对于每个物品,从背包容量开始倒序遍历,更新dp数组。

- 最终dp[W]即为最大价值。

2. 贪心算法解决背包问题- 根据物品价值与重量的比例,选择价值最大的物品放入背包。

- 重复上述步骤,直到背包容量达到上限。

3. 比较两种算法的性能- 使用一组测试案例,包括不同数量的物品和不同的背包容量。

- 分别使用动态规划算法和贪心算法求解背包问题,记录运行时间和结果。

- 比较两种算法在解决背包问题时的性能。

五、实验结果与分析1. 动态规划算法- 在测试案例中,动态规划算法在所有情况下都能找到最大价值。

- 时间复杂度为O(nW),空间复杂度为O(nW)或O(W),其中n为物品数量,W为背包容量。

(2023)八皇后问题实验报告(一)

(2023)八皇后问题实验报告(一)

(2023)八皇后问题实验报告(一)实验背景八皇后问题,是一道经典的数学问题,简要地说:在一个 8x8 的国际象棋棋盘上摆放 8 个皇后,使其不能互相攻击。

即任意两个皇后都不能处于同一行、同一列或同一斜线上。

实验目的1.理解并掌握八皇后问题的基础算法;2.利用Python编写程序,解决八皇后问题;3.掌握递归算法与回溯算法的基本思想;4.分析算法时间复杂度,理解优化算法的重要性。

实验步骤1.利用递归算法,枚举每一行中皇后的位置;2.每一行都有8个候选位置,依次尝试每个位置是否可行;3.如果某个位置可行,继续对下一行进行递归;4.如果都不可行,则回溯到上一行,重新选择位置;5.直到第8行所有位置都选择完成,输出结果。

程序实现及结果def conflict(pos, i):for j in range(i):if abs(pos[i] - pos[j]) in (0, i - j):return Truereturn Falsedef queen(num =8, pos = ()):for i in range(num):if not conflict(pos, i):if len(pos) == num -1:yield (i, )else:for result in queen(num, pos + (i, )):yield (i, ) + resultfor solution in list(queen(8)):print(solution)程序输出结果为所有可能的八皇后问题解决方案,共计92种:(0, 4, 7, 5, 2, 6, 1, 3)(0, 5, 7, 2, 6, 3, 1, 4)…(7, 3, 0, 2, 5, 1, 6, 4)(7, 4, 2, 0, 6, 1, 3, 5)结论与分析1.通过本实验,我们深入地理解了递归算法与回溯算法的基本思想,并将其应用到八皇后问题的解决中;2.程序的输出结果表明:八皇后问题有92种可能的解决方案;3.根据算法的时间复杂度分析,当八皇后问题的规模更大时,应该采用更高效的算法进行优化;4.进一步研究表明,通过基因算法等优化算法可以提高八皇后问题的解决效率。

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

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

淮阴工学院数据结构课程设计报告选题名称:背包问题求解系(院):计算机工程系专业:计算机科学与技术班级:网络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 ,要求找出所有满足上述条件的解。

算法快速排序01背包N皇后问题实验报告

算法快速排序01背包N皇后问题实验报告

算法分析与设计实验报告姓名:专业班级学号:学院:信息科学与工程实验一:快速排序实验实验目的理解递归算法的思想和递归程序的执行过程,并能熟练编写递归程序。

掌握分治算法的思想,对给定的问题能设计出分治算法予以解决。

实验预习内容编程实现讲过的例题:二分搜索、合并排序、快速排序。

对本实验中的问题,设计出算法并编程实现。

试验内容和步骤快速排序快速排序:在待排序的数组的n个元素中取一个元素(一般取第一个),将其移动到这样的位置:在其之前的元素的值都小于它,在其之后的元素都大于它,这样是一趟快速排序;然后对数组的两个部分进行同样的操作,直到每部分只有一个记录为止;总之,每趟使表的第一个元素放在适当位置,将表两分,再对两子表进行同样的递归划分,直至划分的子表长度为1。

一、递归程序执行的过程1 实现快速排序的实现基于分治法,具体分为三个步骤。

假设待排序的序列为L[m..n]。

分解:序列L[m .. n]被划分成两个可能为空的子序列L[m .. pivot-1]和L[pivot+1 .. n],使L[m .. pivot-1]的每个元素均小于或等于L[pivot],同时L[pivot+1.. n]的每个元素均大于L[pivot]。

其中L[pivot]称为这一趟分割中的主元(也称为枢轴、支点)。

解决:通过递归调用快速排序,对子序列L[m .. pivot-1]和L[pivot+1 .. r]排序。

合并:由于两个子序列是就地排序的,所以对它们的合并不需要操作,整个序列L[m .. n]已排好序。

2.概述快速排序(Quick Sort)是一种有效的排序算法。

虽然算法在最坏的情况下运行时间为O(n^2),但由于平均运行时间为O(nlogn),并且在内存使用、程序实现复杂性上表现优秀,尤其是对快速排序算法进行随机化的可能,使得快速排序在一般情况下是最实用的排序方法之一。

快速排序被认为是当前最优秀的内部排序方法。

3.性质内部排序快速排序是一种内部排序方法。

八皇后数据结构实验报告 完整版

八皇后数据结构实验报告 完整版

数据结构实验报告——八皇后问题实验目的:熟练掌握栈操作的基本算法实现。

实现功能:利用回溯法和栈来实现八皇后问题:在8×8的国际象棋棋盘上, 安放8个皇后, 要求没有一个皇后能够“吃掉”任何其他一个皇后, 即没有两个或两个以上的皇后占据棋盘上的同一行、同一列或同一对角线。

设计思路:数据结构:enum boolean { false , true }enum boolean a[9] , b[17] , c[17] ;//检查皇后之间是否冲突//皇后位置安全性可用逻辑表达式: a[ j ] && b[ i+j ] && c[ i-j+9 ]int s[9];//s[1..8]表示顺序栈, 栈的下标值表示皇后所在的行号, 栈的内容是皇后所在的列号。

该算法抽象描述如下:置当前行当前列均为1;while(当前行号≤8){ 检查当前行, 从当前列起逐列试探, 寻找安全列号;if ( 找到安全列号)放置皇后, 将列号记入栈中, 并将下一行置成当前行, 第一列置为当前列;else退栈回溯到上一行, 移去该行已放置的皇后, 以该皇后所在列的下一列作为当前列;} 结束程序。

程序流程图:源程序:#include<stdio.h>enum boolean {FALSE,TRUE}; //声明全局变量enum boolean a[9],b[17],c[17];int s[9];int num=0;//函数声明void print();void movequeen();void eightqueen();void main(){ //主函数eightqueen();printf("共有%d种解法\n",num);}void print() //输出函数{int k;printf("\n");printf("NO.%d\n",++num);printf("行号: 1 2 3 4 5 6 7 8\n");printf("列号:");for(k=1;k<=8;k++)printf("%3d",s[k]);printf("\n");}void movequeen(int i,int j){a[j]=TRUE;b[i+j]=TRUE;c[i-j+9]=TRUE;}void eightqueen()//算法函数{int i,j;for(i=2;i<=16;i++){if(i>=2&&i<=9)a[i-1]=TRUE;b[i]=TRUE;c[i]=TRUE;}i=1;j=1;while(i>=1){while(j<=8){if(a[j]&&b[i+j]&&c[i-j+9])break;j++;}if(j<=8){a[j]=FALSE;b[i+j]=FALSE;c[i-j+9]=FALSE;s[i]=j;if(i==8){num++;print();movequeen(i,j);i--;j=s[i];movequeen(i,j);j++;}else {i++;j=1;}}else{i--;if(i>=1){j=s[i];movequeen(i,j);j++;}}}}实验心得:通过本次实验大大的提高了我个人的动手能力, 对VC编程更加的熟练, 这个程序也一定程度的锻炼了我的思考能力, 对于八皇后问题的逻辑编排, 全局处理, 细节完善等方面都有一个深刻的认识。

  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]数组标记该状态是否已访问过,若访问过,则记录前驱状态值---安全路径。

相关文档
最新文档