算法实验二
计算机图形学实验二:直线的生成算法的实现

实验二: 直线的生成算法的实现班级 08信计2班学号 20080502055 姓名分数一、实验目的和要求:1.理解直线生成的原理;2.掌握几种常用的直线生成算法;3.利用C实现直线生成的DDA算法。
二、实验内容:1.了解直线的生成原理2、掌握几种基本的直线生成算法: DDA画线法、中点画线法、Bresenham画线法。
3、仿照教材关于直线生成的DDA算法, 编译程序。
4.调试、编译、运行程序。
三、实验过程及结果分析1.直线DDA算法:算法原理:已知过端点P0(x0,y0), P1(x1,y1)的直线段L(P0,P1), 斜率为k=(y1-y0)/(x1-x0), 画线过程从x的左端点x0开始, 向x右端点步进, 步长为1个像素, 计算相应的y坐标为y=kx+B。
计算y i+1 = kx i+B=kx i +B+kx=y i +kx当x=1,yi+1=yi+k, 即当x每递增1, y递增k。
由计算过程可知, y与k可能为浮点数, 需要取y整数, 源程序中round(y)=(int)(y+0.5)表示y四舍五入所得的整数值。
(1)程序代码:#include"stdio.h"#include"graphics.h"void linedda(int x0,int y0,int x1,int y1,int color){int x,dy,dx,y;float m;dx=x1-x0;dy=y1-y0;m=dy/dx;y=y0;for(x=x0;x<=x1;x++){putpixel(x,(int)(y+0.5),color);y+=m;setbkcolor(7);}}main(){int a,b,c,d,e;int graphdriver=DETECT;int graphmode=0;initgraph(&graphdriver,&graphmode,"");a=100;b=100;c=200;d=300;e=5;linedda(a,b,c,d,e);getch();closegraph();}运行结果:2.中点画线算法:假定所画直线的斜率为k∈[0,1], 如果在x方向上增量为1, 则y方向上的增量只能在0~1之间。
实验二带优先级的时间片轮换的进程调度算法的实现

•
struct pcb *p;
•
for (i=0;i<MAXPIOR;i++)
•
{p=array[i];
•
while (p!=NULL)
•
{printf("id:%d,state:%d,pior:%d,life:%d\n",p->ident,p->state,p->pior,p->life);
•
p=p->next;
• {int i=0,ii=0;
• for (i=0;i<7;i++)
•
if (stricmp(str,command[i])==0)
•
break;
• switch(i)
•
{case 0:printf("thank you for using the program!\n");exit(0);
•
break;
•{
•
int i=MAXPIOR-1,pior=0,t;
•
struct pcb *pp,*qq,*pr,*r;
•
do
•
{
•
while (i>=0 && array[i]==NUf (i<0)
•
{
•
printf("NO process,please create it! \n");
第1个,再降低其优先级,插入到相应的队列中。 C)ps 查看当前进程状态 D)sleep 命令将进程挂起 E)awake 命令唤醒1个被挂起的进程 F)kill 命令杀死进程 G)quit命令退出 (4)选用面向对象的编程方法。
操作系统实验二:银行家算法

操作系统实验⼆:银⾏家算法实验⼆银⾏家算法⼀、实验⽬的1、了解什么是操作系统安全状态和不安全状态;2、了解如何避免系统死锁;3、理解银⾏家算法是⼀种最有代表性的避免死锁的算法,掌握其实现原理及实现过程。
⼆、实验内容根据银⾏家算法的基本思想,编写和调试⼀个实现动态资源分配的模拟程序,并能够有效避免死锁的发⽣。
三、实验原理进程申请资源时,系统通过⼀定的算法判断本次申请是否不可能产⽣死锁(处于安全状态)。
若可能产⽣死锁(处于不安全状态),则暂不进⾏本次资源分配,以避免死锁。
算法有著名的银⾏家算法。
1、什么是系统的安全状态和不安全状态?所谓安全状态,是指如果系统中存在某种进程序列<P1,P2,…,Pn>,系统按该序列为每个进程分配其所需要的资源,直⾄最⼤需求,则最终能使每个进程都可顺利完成,称该进程序列<P1,P2,…,Pn,>为安全序列。
如果不存在这样的安全序列,则称系统处于不安全状态。
2、银⾏家算法把操作系统看作是银⾏家,操作系统管理的资源相当于银⾏家管理的资⾦,进程向操作系统请求分配资源相当于⽤户向银⾏家贷款。
为保证资⾦的安全,银⾏家规定:(1) 当⼀个顾客对资⾦的最⼤需求量不超过银⾏家现有的资⾦时就可接纳该顾客;(2) 顾客可以分期贷款,但贷款的总数不能超过最⼤需求量;(3) 当银⾏家现有的资⾦不能满⾜顾客尚需的贷款数额时,对顾客的贷款可推迟⽀付,但总能使顾客在有限的时间⾥得到贷款;(4) 当顾客得到所需的全部资⾦后,⼀定能在有限的时间⾥归还所有的资⾦。
操作系统按照银⾏家制定的规则设计的银⾏家算法为:(1)进程⾸次申请资源的分配:如果系统现存资源可以满⾜该进程的最⼤需求量,则按当前的申请量分配资源,否则推迟分配。
(2)进程在执⾏中继续申请资源的分配:若该进程已占⽤的资源与本次申请的资源之和不超过对资源的最⼤需求量,且现存资源能满⾜该进程尚需的最⼤资源量,则按当前申请量分配资源,否则推迟分配。
(3)⾄少⼀个进程能完成:在任何时刻保证⾄少有⼀个进程能得到所需的全部资源⽽执⾏到结束。
实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理,学习如何使用时间片轮转算法进行进程调度,并了解时间片大小对进程调度的影响。
二、实验原理时间片轮转算法是一种公平的进程调度算法,它采用循环队列的形式,将所有需要运行的进程按照到达时间排序,并将它们按照轮转的方式依次执行,每个进程在一个时间片内执行一定的时间(时间片大小),然后被暂停并放在队列的末尾等待下一次调度。
当一个进程的时间片用完后,它会被暂停并放在队列的最后,而在这个时间片内没有执行完的进程会被暂停并放到队列的开头,以便继续下一轮的运行。
这样一直循环下去,直到所有进程都运行完毕。
三、实验步骤1.设定进程数量和时间片大小。
2.定义进程结构体,包括进程ID、到达时间、服务时间、剩余时间等信息。
3.初始化所有进程,并按照到达时间排序。
4.创建一个循环队列,并将所有已到达的进程入队。
5.按照时间片大小循环执行以下步骤:a.从队列中取出一个进程,执行一次时间片大小的时间。
b.更新队列中所有进程的剩余时间。
c.如果剩余时间大于0,将进程放入队尾。
d.如果剩余时间等于0,表示进程执行完毕,将其从队列中移除。
e.输出每个时间片的调度情况。
6.统计平均等待时间和平均周转时间,并输出结果。
四、实验结果本次实验我们设置了4个进程,并且时间片大小为3、以下是每个时间片的调度情况:时间片1:进程1执行,剩余时间为2时间片2:进程2执行,剩余时间为4时间片3:进程3执行,剩余时间为5时间片4:进程1执行,剩余时间为1时间片5:进程2执行,剩余时间为3时间片6:进程3执行,剩余时间为4时间片7:进程4执行,剩余时间为2时间片8:进程1执行,剩余时间为0,进程1执行完毕时间片9:进程2执行,剩余时间为2时间片10:进程3执行,剩余时间为3时间片11:进程4执行,剩余时间为1时间片12:进程2执行,剩余时间为1时间片13:进程3执行,剩余时间为2时间片14:进程4执行,剩余时间为0,进程4执行完毕时间片15:进程2执行,剩余时间为0,进程2执行完毕时间片16:进程3执行,剩余时间为1时间片17:进程3执行,剩余时间为0根据以上调度情况,我们可以计算出平均等待时间和平均周转时间。
实验二 一般信道容量迭代算法

实验二 一般信道容量迭代算法1. 实验目的掌握一般离散信道的迭代运算方法。
2. 实验要求1) 理解和掌握信道容量的概念和物理意义2) 理解一般离散信道容量的迭代算法3) 采用Matlab 编程实现迭代算法4) 认真填写试验报告3.算法步骤①初始化信源分布),,,,,(21)0(p p p p P ri ⋯⋯⋯⋯=(一般初始化为均匀分布),置迭代计数器k=0,设信道容量相对误差门限为δ,δ>0,可设-∞=C )0(; ②∑=i k i ij k i ij k ji p p p p )()()(ϕ s j r i ,⋯⋯=⋯⋯=,1;,,1 ③∑∑∑⎪⎭⎪⎬⎫⎪⎩⎪⎨⎧⎥⎦⎤⎢⎣⎡⎥⎦⎤⎢⎣⎡=+i k ji j ij k ji j ij k i p p p ϕϕ)()()1(ln exp ln exp r i ,,1⋯⋯= ④⎪⎭⎪⎬⎫⎪⎩⎪⎨⎧⎥⎦⎤⎢⎣⎡=∑∑+ik ji j ij k p C ϕ)()1(ln exp ln ⑤如果δ≤-++C C Ck k k )1()()1(,转向⑦; ⑥置迭代序号k k →+1,转向②; ⑦输出p k i )1(+和C k )(1+的结果;⑧停止。
4.代码P=input('转移概率矩阵P=')e=input('迭代精度e=')[r,s]=size(P);n=0;C=0;C_k=0;C_k1=0;X=ones(1,r)/r;A=zeros(1,r);B=zeros(r,s);%初始化各变量while(1)n=n+1;for i=1:rfor j=1:sB(i,j)=log(P(i,j)/(X*P(:,j))+eps);if P(i,j)==0B(i,j)=0;elseendendA(1,i)=exp(P(i,:)*B(i,:)');endC_k=log2(X*A');C_k1=log2(max(A));if (abs(C_0-C_1)<e) C=C_0; %检验是否满足迭代精度 fprintf('迭代次数n=\n',n)%满足则输出相关的被求量fprintf('信道容量:C=\n',C)disp('最佳分布P(x)=');disp(X);break; else %不满足则继续迭代X=(X.*A)/(X*A');continue;endend5.计算下列信道的信道容量例一:0.980.02 0.050.95⎡⎤⎢⎥⎣⎦P =0.9800 0.02000.0500 0.950e =1.0000e-005迭代次数: n=5信道容量: C=0.785847比特/符号最佳分布P(x)=0.5129 0.4871例二:0.60.4 0.010.99⎡⎤⎢⎥⎣⎦P =0.6000 0.40000.0100 0.9900e =1.0000e-005迭代次数: n=17信道容量: C=0.368768比特/符号最佳分布P(x)=0.4238 0.5762例三:0.790.160.05 0.050.150.8⎡⎤⎢⎥⎣⎦P =0.7900 0.1600 0.05000.0500 0.1500 0.8000e =1.0000e-005迭代次数: n=6信道容量: C=0.571215比特/符号最佳分布P(x)=0.5009 0.4991.思考题:迭代精度指的是什么?它对计算结果的影响?迭代精度小数点的位数与迭代次数相同,迭代精度越小,信道容量越大。
实验二:图形填充算法实验报告

《计算机图形学》实验报告(实验二:图形填充算法)一、实验目的及要求用两种方法做图形的填充算法!二、理论基础1.边填充算法对于每一条扫描线和每条多边形的交点(x1,y1),将该扫描线上的交点右方的所有像素取补。
2.种子填充算法利用栈来实现种子填充算法。
种子像素入栈,当栈非空时重复执行如下步骤:将栈顶像素出栈,将出栈像素置成多边形色,按左,上,右,下顺序检查与出栈像素相邻的四个像素,若其中某个像素不再边界且未置成多边形,则把该像素入栈!三、算法设计与分析1、边填充算法void CEdge_mark_fillView::OnDraw(CDC* pDC){CEdge_mark_fillDoc* pDoc = GetDocument();ASSERT_V ALID(pDoc);int d[500][500]={0};int inside;int x,y;Bresenham(80,101,100,400,d);Bresenham(100,300,290,400,d);Bresenham(292,400,382,50,d);Bresenham(380,50,202,150,d);Bresenham(200,150,82,101,d);for(y=0;y<500;y++){inside=0;for(x=0;x<500;x++){if(d[x][y]==1)if(d[x+1][y]!=1){inside=!(inside);}if(inside!=0)pDC->SetPixel(x,y,12);}}}2、种子填充int x=299,y=51;COLORREF oldcolor;COLORREF newcolor;oldcolor=RGB(256,256,256);newcolor=RGB(123,123,123);pDC->MoveTo (40,40);pDC->LineTo (80,40);pDC->LineTo (70,80);pDC->LineTo (40,40);FloodFill(51,51,RGB(255,255,255),RGB(0,0,255));pDC->LineTo (40,40);void CMyView::FloodFill(int x,int y,COLORREF oldcolor,COLORREF newcolor) {CDC* pDC;pDC=GetDC();if(pDC->GetPixel(x,y)==oldcolor){pDC->SetPixel(x,y,newcolor);FloodFill(x,y-1,oldcolor,newcolor);FloodFill(x,y+1,oldcolor,newcolor);FloodFill(x-1,y,oldcolor,newcolor);FloodFill(x+1,y,oldcolor,newcolor);}四、程序调试及结果的分析1、2、四、实验心得及建议由于很多不会,所以这次没能按时当堂完成,下来花了不少时间才弄出来,第二种尤其比较麻烦,在同学的帮助下才做出来了。
实验二时间片轮转RR进程调度算法
实验二时间片轮转RR进程调度算法一: 需求分析(1)程序的设计的任务和目的:设计程序模拟进程的时间片轮转RR调度过程。
假设有n 个进程分别在T1, …,Tn时刻到达系统, 它们需要的服务时间分别为S1, …,Sn。
分别利用不同的时间片大小q, 采用时间片轮转RR进程调度算法进行调度, 计算每个进程的完成时间、周转时间和带权周转时间, 并且统计n个进程的平均周转时间和平均带权周转时间。
(2)通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。
(3)输入的形式和输入值的范围为避免测试时频繁输入数据, 将测试数据放在txt文件中采用读文件方法读取数据。
在同目录下的txt文件中输入数据, 第一行为进程到达时间, 中间用空格隔开, 第二行为进程服务时间, 不同进程的服务时间之间用空格隔开。
(2) 输出的形式输出每个时刻的进程运行状态, 并且输出计算出来的每个进程的周转时间、带权周转时间、所有进程的平均周转时间以及带权平均周转时间。
(详见运行截图)(3) 程序所能达到的功能;详见运行结果截图2、概要设计使用链表创建队列, 用链表方法实现时间片轮转调度。
主要有主函数, 时间片轮转调度函数void RR(int*ArrivalTime,int*ServiceTime,int n,int q,LinkQueue &Q)和输出函数voidprint(int n,int array[]), void print(int n,double array[]);三: 详细设计时间片轮转算法流程图:程序主要设计思想:(1)创建进程, 使用链表的方法, 链表中的每个结点相当于一个进程。
(2)读入文件中进程数据(进程的到达时间和服务时间)。
(3)创建一个进程单链表, 作为进程队列。
(4)请用户输入时间片大小。
(5)创建执行队列。
(6)定义时间轴, 初始化时间轴和执行队列。
实验二存储器的分配与回收算法实现
实验二存储器的分配与回收算法实现一、实验目的1.学习存储器的分配与回收算法;2.实现动态存储管理的相关算法。
二、实验原理在计算机系统中,存储器是一项重要的资源。
为了有效地利用存储器资源,需要设计合理的存储器管理算法来进行存储器的分配与回收。
常用的存储器管理算法有以下几种:1. 首次适应算法(First Fit):分配内存时从链表的头部开始查找第一个满足要求的空闲内存单元。
2. 最佳适应算法(Best Fit):分配内存时从整个链表中找到最小的满足要求的空闲内存单元。
3. 最坏适应算法(Worst Fit):分配内存时从整个链表中找到最大的满足要求的空闲内存单元。
4. 循环首次适应算法(Next Fit):分配内存时从上一次分配结束的位置开始查找第一个满足要求的空闲内存单元。
5. 最近最少使用策略(Least Recently Used, LRU):当内存不足时,将最近最久未使用的页面置换出去。
6.先进先出策略(FIFO):将最先进入缓冲区的页面置换出去。
三、实验步骤1.首先,我们需要定义一个数据结构来表示存储器块,该数据结构包含以下字段:-起始地址:表示该存储器块的起始地址;-大小:表示该存储器块的大小;-状态:表示该存储器块的使用状态(空闲/已分配);-下一存储器块地址:指向链表中下一个存储器块的地址。
2.然后,创建一个链表来表示存储器块的集合,链表的每个节点表示一个存储器块。
3. 实现首次适应算法(First Fit):-遍历链表,找到第一个大小大于等于所需内存的空闲存储器块;-将该存储器块标记为已分配,并更新链表中该存储器块的状态;-如果找不到满足要求的存储器块,则表示存储器不足,分配失败。
4. 实现最佳适应算法(Best Fit):-遍历链表,找到大小最小的满足要求的空闲存储器块;-将该存储器块标记为已分配,并更新链表中该存储器块的状态;-如果找不到满足要求的存储器块,则表示存储器不足,分配失败。
实验2 对称加密算法:DES
实验1-2 对称密码算法DES一.实验原理信息加密根据采用的密钥类型可以划分为对称密码算法和非对称密码算法。
对称密码算法是指加密系统的加密密钥和解密密钥相同,或者虽然不同,但是可以从其中任意一个推导出另一个,更形象的说就是用同一把钥匙开锁和解锁。
在对称密码算法的发展历史中曾出现过多种优秀的算法,包括DES、3DES、AES等。
下面我们以DES算法为例介绍对称密码算法的实现机制。
DES算法是有美国IBM公司在20世纪70年代提出,并被美国政府、美国国家标准局和美国国家标准协会采纳和承认的一种标准加密算法。
它属于分组加密算法,即明文加密和密文解密过程中,信息都是按照固定长度分组后进行处理的。
混淆和扩散是它采用的两个最重要的安全特性,混淆是指通过密码算法使明文和密文以及密钥的关系非常复杂,无法从数学上描述或者统计。
扩散是指明文和密钥中每一位信息的变动,都会影响到密文中许多位信息的变动,从而隐藏统计上的特性,增加密码安全。
DES将明文分成64比特位大小的众多数据块,即分组长度为64位。
同时用56位密钥对64位明文信息加密,最终形成64位的密文。
如果明文长度不足64位,则将其扩展为64位(例如补零等方法)。
具体加密过程首先是将输入的数据进行初始换位(IP),即将明文M 中数据的排列顺序按一定的规则重新排列,生成新的数据序列,以打乱原来的次序。
然后将变换后的数据平分成左右两部分,左边记为L0,右边记为R0,然后对R0施行在子密钥(由加密密钥产生)控制下的变换f,结果记为f(R0 ,K1),再与L0做逐位异或运算,其结果记为R1,R0则作为下一轮的L1。
如此循环16轮,最后得到L16、R16,再对L16、R16施行逆初始置换IP-1,即可得到加密数据。
解密过程与此类似,不同之处仅在于子密钥的使用顺序正好相反。
DES全部16轮的加密过程如图1-1所示。
DES的加密算法包括3个基本函数:1.初始换位(IP)它的作用是把输入的64位数据块的排列顺序打乱,每位数据按照下面换位规则重新组合。
实验二银行家算法实验报告
实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。
二、实验过程1、阅读银行家算法的相关理论知识。
2、编写银行家算法的代码实现。
3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。
三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。
2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。
根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。
3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。
银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。
四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。
在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
17学年—18学年第 1学期算法设计与实践实验报告专业名称:数字媒体技术课程名称:算法设计与实践实验题目:3.5 设有n种不同面值的硬币,第i种硬币的币值是vk(其中v1=1),重量是wi,i=1,2……n,且现在购买某些总价值为y的商品,需要用这些硬币付款,如果每种钱币使用的个数不限,那么如何选择付款的方法是的付出钱币的总重量最轻?问题的实例:V1=1, v2=4 ,v3=6 ,v4=8 ,w1=1,w2=2,w3=4,w4=6,y=123.10 把0-1背包问题加以推广,设有n种物品,第i种物品的价值是vi,重量wi,体积是ci,且装入背包的重量限制是W,体积是V,问如何选择装入背包的物品使得其总重不超过W,总体积不超过V且价值达到最大?实验环境: Visual Studio 2015实验程序:3.5// Money.cpp : 定义控制台应用程序的入口点。
//#include<iostream>using namespace std;#define MAX_NUM 20int main(){int weight[MAX_NUM] = { 0,1,2,4,6 };int value[MAX_NUM] = { 0,1,4,6,8 };int y = 12;int n = 5;int F[MAX_NUM][MAX_NUM] = { 0 };int t[MAX_NUM][MAX_NUM] = { 0 };int i, j;//初始化for (int j = 1; j <= y; j++) {F[1][j] = j*weight[1];t[1][j] = 1;}//迭代更新for (int i = 2; i <= n; i++) {for (int j = 1; j <= y; j++) {F[i][j] = F[i - 1][j];t[i][j] = t[i - 1][j];if (F[i][j - value[i]] + weight[i] <= F[i - 1][j]) {F[i][j] = F[i][j - value[i]] + weight[i];t[i][j] = i;}}}printf("钱币的总重量为:%d", F[5][12]);system("pause");}3.10// backpakage.cpp : 定义控制台应用程序的入口点。
//#include"stdafx.h"#include<iostream>using namespace std;const int N = 4;template<class Type>int Knapsack(int n, Type c, Type v[], Type w[], int **p, int x[]); template<class Type>void Traceback(int n, Type w[], Type v[], Type **p, int *head, int x[]);int main(){int c = 8;int v[] = { 0,2,1,4,3 }, w[] = { 0,1,4,2,3 };//下标从1开始int x[N + 1];int **p = new int *[50];for (int i = 0;i<50;i++){p[i] = new int[2];}cout <<"待装物品重量分别为:"<< endl;for (int i = 1; i <= N; i++){cout << w[i] <<" ";}cout << endl;cout <<"待装物品价值分别为:"<< endl;for (int i = 1; i <= N; i++){cout << v[i] <<" ";}cout << endl;cout <<"背包能装的最大价值为:"<< Knapsack(N, c, v, w, p, x) << endl; cout <<"背包装下的物品编号为:"<< endl;for (int i = 1; i <= N; i++){if (x[i] == 1){cout << i <<" ";}}cout << endl;for (int i = 0;i<50;i++){delete p[i];}delete[] p;system("pause");return 0;}template<class Type>int Knapsack(int n, Type c, Type v[], Type w[], int **p, int x[]){ int *head = new int[n + 2];head[n + 1] = 0;p[0][0] = 0;//p[][0]存储物品重量p[0][1] = 0;//p[][1]存储物品价值,物品n的更新点(0,0)// left 指向p[i+1]的第一个更新点,right指向最后一个int left = 0, right = 0, next = 1;//next即下一个更新点要存放的位置head[n] = 1;//head[n]用来指向第n个物品第一个更新点的位置for (int i = n; i >= 1; i--){int k = left;//k指向p[ ]中更新点,移动k来判断p[]与p[]+(w v)中的受控点for (int j = left; j <= right; j++){if (p[j][0] + w[i]>c) break;//剩余的空间不能再装入i,退出for循环;Type y = p[j][0] + w[i], m = p[j][1] + v[i];//计算p[ ]+(w v)//若p[k][0]较小则(p[k][0] p[k][1])一定不是受控点,将其作为p[i]的更新点存储while (k <= right && p[k][0]<y){p[next][0] = p[k][0];p[next++][1] = p[k++][1];}//如果 p[k][0]==y而m<p[k][1],则(y m)为受控点不存if (k <= right && p[k][0] == y){if (m<p[k][1]) { //对(p[k][0] p[k][1])进行判断m = p[k][1];}k++;}// 若p[k][0]>=y且m> =p[k][1],判断是不是当前i的最后一个更新点的受控点//若不是则为i的更新点存储if (m>p[next - 1][1]){p[next][0] = y;p[next++][1] = m;}//若是,则对下一个元素进行判断。
while (k <= right && p[k][1] <= p[next - 1][1]){k++;}}while (k <= right){p[next][0] = p[k][0];p[next++][1] = p[k++][1];//将i+1剩下的更新点作为做为i的更新点存储}left = right + 1;right = next - 1;// 第i-1个物品第一个更新点的位置 head[0]指第0个物品第一个更新点的位置head[i - 1] = next;}Traceback(n, w, v, p, head, x);return p[next - 1][1];}//x[]数组存储对应物品0-1向量,0不装入背包,1表示装入背包template<class Type>void Traceback(int n, Type w[], Type v[], Type **p, int *head, int x[]){//初始化j,m为最后一个更新点对应的第0列及第1列//如上例求出的最后一个更新点为(8 15)j=8,m=15Type j = p[head[0] - 1][0], m = p[head[0] - 1][1];for (int i = 1; i <= n; i++){x[i] = 0;// 初始化数组;for (int k = head[i + 1]; k <= head[i] - 1;k++) { // 初始k指向p[2]的第一个更新点(0 0)//判断物品i是否装入,如上例与更新点(6 9)相加等于(8 15)所以1装入if (p[k][0] + w[i] == j && p[k][1] + v[i] == m) {x[i] = 1;//物品i被装入,则x[i]置1j = p[k][0];// j和m值置为满足if条件的更新点对应的值m = p[k][1];// 如上例j=6,m=9break;//再接着判断下一个物品}}}}实验结果:(截图)实验总结:3.5 实验:1、由线性条件约束的线性函数取最大或最小的问题2、 Fk(y):装前 k 种物品, 总重、价值不超过 y, 背包的最小质量3、 ik(y):装前 k 种物品, 总价值不超过 y, 背包达最小质量时装入物品的最大标号4、确定递推方程、边界条件、标记函数3.10实验:例:n=5,c=10,w={2,2,6,5,4},v={6,3,5,4,6}。
更新点的计算过程如下:初始时p[6]={(0,0)},(w5,v5)=(4,6)。
因此,q[6]=p[6]⊕(w5,v5)={(4,6)}。
p[5]={(0,0),(4,6)}。
q[5]=p[5]⊕(w4,v4)={(5,4),(9,10)}。
从更新点p[5]与q[5]的并集p[5]∪q[5]={(0,0),(4,6),(5,4),(9,10)}中看到更新点(5,4)受控于更新点(4,6)。
将受控更新点(5,4)清除后,得到p[4]={(0,0),(4,6),(9,10)}q[4]=p[4]⊕(6,5)={(6,5),(10,11)}p[3]={(0,0),(4,6),(9,10),(10,11)}q[3]=p[3]⊕(2,3)={(2,3),(6,9)}p[2]={(0,0),(2,3),(4,6),(6,9),(9,10),(10,11)}q[2]=p[2]⊕(2,6)={(2,6),(4,9),(6,12),(8,15)}p[1]={(0,0),(2,6),(4,9),(6,12),(8,15)}p[1]的最后的那个更新点(8,15)给出所求的最优值为m(1,c)=15。