用Container实现Solaris 10上的动态资源分配 (2010-01-20 10:38)
分类：Solaris
本文介绍了在Solaris 10中如何运用虚拟化技术来实现动态CPU资源管理。
关键字：Solaris 10， Container, 资源管理，resource management, CMT
Solaris 10中提供了一项强大的虚拟化技术：Container（容器），通过使用Container，我们可以在一个操作系统实例中虚拟出多个运行环境(Zone)，每个Zone有自己的文件系统和网络地址，各个Zone中运行的应用互相不影响，从而实现应用级的隔离，并提高了安全性。如下图所示，在一个Solaris 10 的操作系统中，划分了3个Container，分别运行App Server, Web Server和Database Server。
Container的使用非常简单，通常只需要5-10分钟的配置即可，所以Container 的虚拟化技术得到了广泛的应用。
资源管理的作用
在缺省的情况下，各个Container都可以看见物理机器上的所有CPU 和内存，也就是说物理机上的所有CPU和内存在各个Container中是共享的。在实际运用中，往往需要对各个Container使用的资源加以指定，以便确保一些关键应用的资源。另外一种场景是需要动态调节各个Container中的资源，例如，在月末做报表时，希望临时给数据库的Zone多分配一些CPU资源，在月末压力高峰之后，就可以恢复成原来的CPU资源。动态资源调整（Dynamic Reconfiguration）的功能在中高端服务器上（如E25K，M4000-M9000等）可由硬件实现，在其他中低端类型的服务器中，我们可以用Container 来实现。
Container
Solaris 10 的Container 包括两层功能：Zone和Resource Management(RM)。Zone是指隔离的虚拟运行环境，RM是以前版本的Solaris就有的功能，可以结合Zone来动态分配资源。本文以T5220为例子加以说明，在实际中对所有运行Solaris10的多处理器机器都适用，包括X86机器。T5220 有一个UltraSPARC T2处理器，可以拥有8个核心（cores），每个核心有8个硬件线程，因此，T5220可以拥有64个硬件线程，在操作系统中可以看到有64个物理CPU，如
# psrinfo
0 on-line since 04/08/2009 14:22:42
1 on-line since 04/08/2009 14:22:45
2 on-line since 04/08/2009 14:22:45
3 on-line since 04/08/2009 14:22:45
4 on-line since 04/08/2009 14:22:45
5 on-line since 04/08/2009 14:22:45
6 on-line since 04/08/2009 14:22:45
( 略去部分输出)
61 on-line since 04/08/2009 14:22:45
62 on-line since 04/08/2009 14:22:45
63 on-line since 04/08/2009 14:22:45
创建Zone
1．创建Zone：
# mkdir –p /export/home/zones/zone1
# zonecfg -z zone1
zone1: No such zone configured
Use 'create' to begin configuring a new zone. zonecfg:zone1>create
zonecfg:zone1>set zonepath=/export/home/zones/zone1 zonecfg:zone1>set autoboot=true
zonecfg:zone1>add net
zonecfg:zone1:net>set address=192.168.0.1 zonecfg:zone1:net>set physical=e1000g0 zonecfg:zone1:net>end
zonecfg:zone1>verify
zonecfg:zone1>commit
zonecfg:zone1>exit
2. 查看配置的zone:
# ls -l /etc/zones/*xml 可以看到zone1.xml的配置文件# zoneadm list –cv 可以看到刚刚配置好的zone
3．安装zone：
# zoneadm –z zone1 install
4. 检查zone状态可以看到zone1 的状态为installed：
# zoneadm list –cv
5. 启动zone：
# zoneadm –z zone1 boot
6．首次启动需要初始化服务和配置，可用命令登陆console监控：
# zlogin -C zone1
7. 系统会出现配置界面，如主机名，命名服务等。完成配置后，zone会重新启动，
即可完成系统的启动。
8．如果在zone1里面运行psrinfo命令，可以看到64个CPU，也就是说，global zone和local zone里面的CPU目前是共享的，下一步我们可以
把zone里的资源进一步限定。
CPU资源分配
假定我们需要给这个zone分配8个CPU资源（即一个core），可以用以下资源管理命令：
1．先检查资源管理服务是否启用：
# svcs -a | grep pool
disabled Jan_03 svc:/system/pools:default
disabled Jan_03 svc:/system/pools/dynamic:default
如果显示disabled，则需要启用：
# svcadm enable pools
# svcadm enable pools/dynamic
# svcs -a | grep pool
online Jan_03 svc:/system/pools:default
online Jan_03 svc:/system/pools/dynamic:default
2. 启动资源管理功能和生成基本配置文件：
# pooladm -e
# pooladm -s
3. 创建资源池（pool）：
# poolcfg -dc ‘create pool pool1’
4. 创建CPU集（pset）, 包括8个CPU，其中pset.min和pset.max限定了CPU 的个数：
# poolcfg -dc ‘create pset pset1 ( uint pset.min=8; uint pset.max=8 )’
5. 指定特定的CPU到CPU集中，此步骤可选，如果不指定CPU编号，则系统自动分配CPU。
为了使T5220的分区具有较好的性能，我们把同一个core中的CPU分配到同一个CPU集中：
# poolcfg -dc ‘transfer to pset pset1 ( cpu 0; cpu 1; cpu 2; \
cpu 3; cpu 4; cpu 5; cpu 6; cpu 7)’
6．把资源池pool1和CPU集pset1作关联：
# poolcfg -dc ‘associate pool pool1 ( pset pset1 )’
7．保存配置到文件（save）：
# pooladm -s
8．查看当前CPU资源的配置，可以看到pool1已经关联上pset1，
pset1中有8个CPU（id：0-7），而缺省的pset_default中只有56个CPU 了：
# pooladm
system default
string https://www.doczj.com/doc/5c12580165.html,ment
int system.version 1
boolean system.bind-default true
string system.poold.objectives wt-load
pool pool_default
int pool.sys_id 0
boolean pool.active true
boolean pool.default true
int pool.importance 1
string https://www.doczj.com/doc/5c12580165.html,ment
pset pset_default
pool pool1
int pool.sys_id 2
boolean pool.active true
boolean pool.default false
int pool.importance 1
string https://www.doczj.com/doc/5c12580165.html,ment
pset pset1
pset pset1
int pset.sys_id 1
boolean pset.default false
uint pset.min 8
uint pset.max 8
string pset.units population
uint pset.load 0
uint pset.size 8
string https://www.doczj.com/doc/5c12580165.html,ment
cpu
int cpu.sys_id 5
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 4
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 7
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 6
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 1
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 0
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 3
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 2
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
pset pset_default
int pset.sys_id -1
boolean pset.default true
uint pset.min 1
uint pset.max 65536
string pset.units population
uint pset.load 807
uint pset.size 56
string https://www.doczj.com/doc/5c12580165.html,ment
cpu
int cpu.sys_id 13
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 12
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 15
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 14
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line cpu
int cpu.sys_id 9
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 8
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 11
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 10
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 21
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 20
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 23
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 22
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 17
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 16
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 19
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 18
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 29
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 28
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 31
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 30
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 25
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 24
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 27
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 26
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 53
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 52
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 55
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 54
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 49
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 48
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 51
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 50
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 61
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 60
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 63
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 62
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 57
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 56
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 59
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 58
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 37
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 36
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 39
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 38
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 33
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 32
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 35
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 34
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line cpu
int cpu.sys_id 45
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 44
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 47
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 46
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 41
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 40
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 43
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
cpu
int cpu.sys_id 42
string https://www.doczj.com/doc/5c12580165.html,ment
string cpu.status on-line
配置Zone的CPU资源
此时，如果在Zone1中运行psrinfo命令，会发现只有56个CPU了（8-63），原因是zone1缺省情况下使用了pool_default这个资源池。我们用zonecfg命令，把pool1分配给zone1:
# zonecfg -z zone1
zonecfg:zone1>set pool=pool1
zonecfg:zone1>commit
zonecfg:zone1>exit
# zoneadm –z zone1 reboot
在Zone1重新启动后，我们在这个zone里可以看到只有8个CPU了：
Zone1# psrinfo
0 on-line since 04/08/2009 14:22:42
1 on-line since 04/08/2009 14:22:45
2 on-line since 04/08/2009 14:22:45
3 on-line since 04/08/2009 14:22:45
4 on-line since 04/08/2009 14:22:45
5 on-line since 04/08/2009 14:22:45
6 on-line since 04/08/2009 14:22:45
7 on-line since 04/08/2009 14:22:45
动态分配CPU资源
如果需要改变zone1的CPU资源的分配配置，例如需要增加CPU到16个，可以通过重新配置pset1来实现，注意，这个操作可以在不停止zone 的情况下进行：
1）先取消原来pset1的配置：
# poolcfg –dc ‘destroy pset pset1’
2）此时zone1中的CPU数恢复到64个，我们再用命令创建一个包含16个CPU 的pset1,
命令和前述的过程差不多：
# poolcfg -dc 'create pool pool1'
# poolcfg -dc 'create pset pset1 ( uint pset.min=16; uint pset.max=16 )' # poolcfg -dc 'transfer to pset pset1 ( cpu 0; cpu 1; cpu 2; cpu 3;\ cpu 4; cpu 5; cpu 6; cpu 7)'
# poolcfg -dc 'transfer to pset pset1 ( cpu 8; cpu 9; cpu 10; cpu 11; \ cpu 12; cpu 13; cpu 14; cpu 15)'
# poolcfg -dc 'associate pool pool1 ( pset pset1 )'
# pooladm –s
3）这时，在zone1中的CPU数目改为16个。
这样，我们就在Solaris 10中实现了通常由硬件实现的CPU资源动态管理功能。
动态规划是用空间换时间的一种方法的抽象。其关键是发现子问题和记录其结果。然后利用这些结果减轻运算量。 比如01背包问题。 因为背包最大容量M未知。所以，我们的程序要从1到M一个一个的试。比如，开始任选N件物品的一个。看对应M的背包，能不能放进去，如果能放进去，并且还有多的空间，则，多出来的空间里能放N-1物品中的最大价值。怎么能保证总选择是最大价值呢？看下表。 测试数据： 10,3 3,4 4,5 5,6 c[i][j]数组保存了1,2,3号物品依次选择后的最大价值. 这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3则里面放4.这样,这一排背包容量为 4,5,6,....10的时候，最佳方案都是放4.假如1号物品放入背包.则再看2号物品.当背包容量为3的时候，最佳方案还是上一排的最价方案c为4.而背包容量为5的时候，则最佳方案为自己的重量5.背包容量为7的时候，很显然是5加上一个值了。加谁??很显然是7-4=3的时候.上一排c3的最佳方案是4.所以。 总的最佳方案是5+4为9.这样.一排一排推下去。最右下放的数据就是最大的价值了。(注意第3排的背包容量为7的时候,最佳方案不是本身的6.而是上一排的9.说明这时候3号物品没有被选.选的是1,2号物品.所以得9.) 从以上最大价值的构造过程中可以看出。 f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}这就是书本上写的动态规划方程.这回清楚了吗?
下面是实际程序: #include
实验五可变分区存储管理方式的内存分配和回收 一．实验目的 通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解，熟悉可变分区存储管理的内存分配和回收。 二．实验属性 设计 三．实验内容 1．确定内存空间分配表； 2．采用最优适应算法完成内存空间的分配和回收； 3．编写主函数对所做工作进行测试。 四．实验背景材料 实现可变分区的分配和回收，主要考虑的问题有三个：第一，设计记录内存使用情况的数据表格，用来记录空闲区和作业占用的区域；第二，在设计的数据表格基础上设计内存分配算法；第三，在设计的数据表格基础上设计内存回收算法。 首先，考虑第一个问题，设计记录内存使用情况的数据表格，用来记录空间区和作业占用的区域。 由于可变分区的大小是由作业需求量决定的，故分区的长度是预先不固定的，且分区的个数也随内存分配和回收变动。总之，所有分区情况随时可能发生变化，数据表格的设计必须和这个特点相适应。由于分区长度不同，因此设计的表格应该包括分区在内存中的起始地址和长度。由于分配时空闲区有时会变成两个分区：空闲区和已分分区，回收内存分区时，可能会合并空闲分区，这样如果整个内存采用一张表格记录己分分区和空闲区，就会使表格操作繁琐。分配内存时查找空闲区进行分配，然后填写己分配区表，主要操作在空闲区；某个作业执行完后，将该分区变成空闲区，并将其与相邻的空闲区合并，主要操作也在空闲区。由此可见，内存的分配和回收主要是对空闲区的操作。这样为了便于对内存空间的分配和回收，就建立两张分区表记录内存使用情况，一张表格记录作业占用分区的“己分分区表”；一张是记录空闲区的“空闲区表”。这两张表的实现方法一般有两种：一种是链表形式，一种是顺序表形式。在实验中，采用顺序表形式，用数组模拟。由于顺序表的长度必须提前固定，所以无论是“已分分区表”还是“空闲区表”都必须事先确定长度。它们的长度必须是系统可能的最大项数。 “已分分区表”的结构定义 #define n 10 //假定系统允许的最大作业数量为n struct { float address; //已分分区起始地址 float length; //已分分区长度、单位为字节 int flag; //已分分区表登记栏标志，“0”表示空栏目，实验中只支持一个字符的作业名 }used_table[n]; //已分分区表 “空闲区表”的结构定义 #define m 10 //假定系统允许的空闲区最大为m struct
01背包问题，是用来介绍动态规划算法最经典的例子，网上关于01背包问题的讲解也很多，我写这篇文章力争做到用最简单的方式，最少的公式把01背包问题讲解透彻。 01背包的状态转换方程f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ), f[i-1,j] } f[i,j]表示在前i件物品中选择若干件放在承重为j 的背包中，可以取得的最大价值。 Pi表示第i件物品的价值。 决策：为了背包中物品总价值最大化，第i件物品应该放入背包中吗？ 题目描述： 有编号分别为a,b,c,d,e的五件物品，它们的重量分别是2,2,6,5,4，它们的价值分别是6,3,5,4,6，现在给你个承重为10的背包，如何让背包里装入的物品具有最 首先要明确这张表是从右到左,至底向上生成的。 为了叙述方便，用e10单元格表示e行10列的单元格，这个单元格的意义是用来表示只有物品e时，有个承重为10的背包，那么这个背包的最大价值是6，因为e物品的重量是4，背包装的了，把e装进去后价值为6。然后是e9单元格表示背包承重9，只有物品e, e装进去后，背包价值为6，接着是e8, e7单元格，一直到e3单元格表示背包承重3，但物品e承重4，装不了，所以e3=0, 对于d10单元格，表示只有物品e，d时,承重为10的背包,所能装入的最大价值，是10，因为物品e,d这个背包都能装进去。对于承重为9的背包，d9=10,是怎么得出的呢？ 根据01背包的状态转换方程，需要考察两个值， 一个是f[i-1,j],对于这个例子来说就是e9的值6，另一个是f[i-1,j-Wi]+Pi； 在这里， f[i-1,j]表示我有一个承重为9的背包，当只有物品e可选时，这个背包能装入的最大价值 f[i-1,j-Wi]表示我有一个承重为4的背包（等于当前背包承重减去物品d的重量），当只有物品e可选时，这个背包能装入的最大价值 f[i-1,j-Wi]就是指单元格e4值为6，Pi指的是d物品的价值，即4 由于f[i-1,j-Wi]+Pi = 6 + 4 = 10 大于f[i-1,j] = 6，所以物品d应该放入承重为9的背包，所以d9=10.
用动态规划法求解资源分配问题 1.某市电信局有四套通讯设备，准备分给甲、乙、丙三个地区支局，事先调查 了各地区支局的经营情况，并对各种分配方案作了经济效益的估计，如表所示，其中设备数为0时的收益，指已有的经营收益，问如何分配这四套设备，使总的收益最大？ 解：分三个阶段1,2,3k =分别对应给甲、乙、丙三个地区支局分配设备， 0,1,2,3,4k s =表示在第k 阶段分配的设备套数， ()k k x s 表示第k 阶段分配k s 套设备所产生的收益 ()k k f s 表示将k s 套设备分配给第k 阶段直到第3阶段所产生的收益 用逆推法得到基本递推方程 1144()max{()()},1,2,3 ()0 k k k k k k f s x s f s k f s ++=+=?? =? 当3k =时 33333(0)48,(1)64,(2)68,(3)78,(4)78f f f f f ===== 当2k =时 223(0)max{(0)(00)}max{4840}88f x f =+-=+= 23223(0)(1)6440(1)max max 104(1)(0)4248x f f x f ++???? ===????++???? 2322323(0)(2)6840(2)max (1)(1)max 64421085048(2)(0)x f f x f x f ++???????? =+=+=???????? ++????
2323 22323(0)(3)4078(1)(2)6842(3)max max 118(2)(1)64506048(3)(0)x f x f f x f x f ++????????++????===????++????????++???? 23232232323(0)(4)4078(1)(3)4278(4)max (2)(2)max 68501246064(3)(1)6648(4)(0)x f x f f x f x f x f ++????????++???????? =+=+=????????++????+????+???? 当1k =时 112(0)max{(0)(0)}max{3888}126f x f =+=+= 12112(1)(0)4188(1)max max 140(0)(1)38102x f f x f ++????===????++???? 1211212(2)(0)4888(2)max (1)(1)max 4110414638108(0)(2)x f f x f x f ++???? ???? =+=+=???????? ++???? 1212 11212(3)(0)6088(2)(1)48104(3)max max 156(1)(2)4110838118(0)(3)x f x f f x f x f ++???? ????++????===????++????????++???? 12121121212(4)(0)6688(3)(1)60104(4)max (2)(2)max 4810816441118(1)(3)38124(0)(4)x f x f f x f x f x f ++????????++???????? =+=+=????????++????+?+??????? 故最大收益为164，具体分配方案为甲3套，乙0套，丙1套。
《动态分配内存与数据结构》习题 学号姓名 一、选择题 1、是一种限制存取位置的线性表，元素的存取必须服从先进先出的规则。 A．顺序表B．链表C．栈D．队列 2、是一种限制存取位置的线性表，元素的存取必须服从先进后出的规则。 A．顺序表B．链表C．栈D．队列 3、与顺序表相比，链表不具有的特点是。 A．能够分散存储数据，无需连续内存空间 B．插入和删除无需移动数据 C．能够根据下标随机访问 D．只要内存足够，没有最大长度的限制 4、如果通过new运算符动态分配失败，返回结果是。 A．-1 B．0 C．1D．不确定 5、实现深复制中，不是必须自定义的。 A．构造函数B．复制构造函数 C．析构函数D．复制赋值操作符函数 6、分析下列代码是否存在问题，选择合适的选项：。 int main(void) { int *p = new int [10]; p = new int [10]; delete [] p; p = NULL; return 0; } A．没有问题 B．有内存泄漏 C．存在空悬指针 D．存在重复释放同一空间 7、通过new运算符动态分配的对象，存储于内存中的。 A．全局变量与静态变量区 B．代码区 C．栈区 D．堆区 8、下列函数中，可以是虚函数。 A．构造函数 B．析构函数 C．静态成员函数 D．友元函数 9、关于通过new运算符动态创建的对象数组，下列判断中是错误的。 A. 动态创建的对象数组只能调用默认构造函数 B. 动态创建的对象数组必须调用delete []动态撤销 C. 动态创建的对象数组的大小必须是常数或常变量 D. 动态创建的对象数组没有数组名 10、顺序表不具有的特点是 A. 元素的存储地址连续 B. 存储空间根据需要动态开辟，不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置有关 11、假设一个对象Ob1的数据成员是指向动态对象的指针，如果采用浅复制的方式复制该对象得到对象Ob2，那么在析构对象Ob1和对象Ob2时会的问题。 A. 有重复释放 B. 没有 C. 内存泄漏 D. 动态分配失败 12、假设对5个元素A、B、C、D、E进行压栈或出栈的操作，压栈的先后顺序是ABCDE，则出栈的先后顺序不可能是。 A. ABCDE B. EDCBA C. EDBCA D. BCADE 13、假设对4个元素A、B、C、D、E进行压栈或出栈的操作，压栈的先后顺序是ABCD，则出栈的先后顺序不可能是。 A. ABCD B. DCBA C. BCAD D. DCAB 14、通过new运算符动态创建的对象的存放在中。 A. 代码区 B. 栈区 C. 自由存储区 D. 全局数据区 15、链表不具有的特点是。 A. 元素的存储地址可以不连续 B. 存储空间根据需要动态开辟，不会溢出 C. 可以直接随机访问元素 D. 插入和删除元素的时间开销与位置无关 16、有关内存分配和释放的说法，下面当中错误的是 A．new运算符的结果只能赋值给指针变量 B．动态创建的对象数组必须调用delete []动态撤销 C．用new分配的空间位置是在内存的栈区 D．动态创建的对象数组没有数组名 17、关于栈，下列哪项不是基本操作 A．删除栈顶元素 B．删除栈底元素 C．判断栈是否为空 D．把栈置空 18、关于链表，说法错误的是
0/1 背包问题动态规划详解及 C 代码动态规划是用空间换时间的一种方法的抽象。其关键是发现子问题和记录其结果。然后利用这些结果减轻运算量。 比如01 背包问题。 /* 一个旅行者有一个最多能用M 公斤的背包，现在有N 件物品， 它们的重量分别是W1，W2，...,Wn, 它们的价值分别为P1,P2,...,Pn. 若每种物品只有一件求旅行者能获得最大总价值。 输入格式： M,N W1,P1 W2,P2 输出格式： X*/ 因为背包最大容量M未知。所以，我们的程序要从1到M —个的试。比如，开始任选N 件物品的一个。看对应M 的背包，能不能放进去，如果能放进去，并且还有多的空间，则，多出来的空间里能放N-1 物品中的最大价值。怎么能保证总选择是最大价值呢？看下表。 测试数据： 10,3 3,4 4,5
5,6 c[i][j] 数组保存了1,2,3号物品依次选择后的最大价值. 这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3 则里面放 4. ...................................................... "这样,这一排背包容量为4,5,6, 10 的时候，最佳方案都是放 4."假如1 号物品放入背包.则再看2 号物品.当背包容量为3 的时候，最佳方案还是上一排的最价方案c 为 4." 而背包容量为5 的时候，则最佳方案为自己的重量 5. "背包容量为7 的时候，很显然是5加上一个值了。加谁??很显然是7-4=3 的时候.上一排c3的最佳方案是 4."所以。总的最佳方案是5+4为 9."这样.一排推下去。最右下放的数据就是最大的价值了。(注意第3排的背包容量为7 的时候,最佳方案不是本身的 6. "而是上一排的 9."说明这时候3号物品没有被选.选的是1,2号物品.所以得 9.") 从以上最大价值的构造过程中可以看出。 f(n, m)二max{f( n-1,m), f(n-1,m-w[ n] )+P( n,m)}这就是书本上写的动态规划方程. 这回清楚了吗? 下面是实际程序(在VC 6."0环境下通过) : #include
关于求解0/1背包问题的动态规划算法 摘要：本文通过研究动态规划原理，提出了根据该原理解决０／１背包问题的方法与算法实现， 并对算法的正确性作了验证．观察程序运行结果，发现基于动态规划的算法能够得到正确的决策方案且比穷举法有效． 关键字：动态规划；０／１背包；约束条件；序偶；决策序列；支配规则 1、引 言 科学研究与工程实践中，常常会遇到许多优化问题，而有这么一类问题，它们的活动过程可以分为若干个阶段，但整个过程受到某一条件的限制。这若干个阶段的不同决策的组合就构成一个完整的决策。0/1背包问题就是一个典型的在资源有限的条件下，追求总的收益最大的资源有效分配的优化问题。 对于0/1背包问题，我们可以这样描述：设有一确定容量为C 的包及两个向量C ’=（S 1，S 2，……，S n ）和P=（P 1，P 2，……，P N ），再设X 为一整数集合，即X=1，2，3，……，N ，X 为SI 、PI 的下标集，T 为X 的子集，那么问题就是找出满足约束条件∑S i 〈=C ，使∑PI 获得最大的子集T 。在实际运用中，S 的元素可以是N 个经营项目各自所消耗的资源，C 可以是所能提供的资源总量，P 的元素可是人们从各项项目中得到的利润。 0/1背包问题是工程问题的典型概括，怎么样高效求出最优决策，是人们关心的问题。 2、求解问题的动态规划原理与算法 2．1动态规划原理的描述 求解问题的动态规划有向前处理法向后处理法两种，这里使用向前处理法求解0/1背包问题。对于0/1背包问题，可以通过作出变量X 1，X 2，……，X N 的一个决策序列来得到它的解。而对于变量X 的决策就是决定它是取0值还是取1值。假定决策这些X 的次序为X n ，X N-1，……，X 0。在对X 0做出决策之后，问题处于下列两种状态之一：包的剩余容量是M ，没任何效益；剩余容量是M-w ，效益值增长了P 。显然，之后对X n-1，Xn-2，……，X 1的决策相对于决策X 所产生的问题状态应该是最优的，否则X n ，……，X 1就不可能是最优决策序列。如果设F j （X ）是KNAP （1，j ，X ）最优解的值，那么F n （M ）就可表示为 F N （M ）=max(f n (M),f n-1(M-w n )+p n )} （1） 对于任意的f i (X),这里i>0，则有 f i (X)=max{f i-1(X),f i-1(X-w i )+p i } （2） 为了能由前向后推而最后求解出F N （M ），需从F 0（X ）开始。对于所有的X>=0,有F 0（X ）=0，当X<0时，有F 0（X ）等于负无穷。根据（2），可求出0〈X 〈W 1和X 〉=W 1情况下F 1（X ）的值。接着由（2）不断求出F 2，F 3，……，F N 在X 相应取值范围内的值。 2．2 0/1背包问题算法的抽象描述 (1)初始化各个元素的重量W[i]、效益值P[i]、包的最大容量M ； (2)初始化Ｓ0； (3)生成S i ；
实验报告 实验课程名称：动态内存分配算法 年12月1日
实验报告 一、实验内容与要求 动态分区分配又称为可变分区分配，它是根据进程的实际需要，动态地为之分配内存空间。在实验中运用了三种基于顺序搜索的动态分区分配算法，分别是1.首次适应算法2.循环首次适应算法3.最佳适应法3.最坏适应法分配主存空间。 二、需求分析 本次实验通过C语言进行编程并调试、运行，显示出动态分区的分配方式，直观的展示了首次适应算法循环首次适应算法、最佳适应算法和最坏适应算法对内存的释放和回收方式之间的区别。 首次适应算法 要求空闲分区链以地址递增的次序链接，在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止，然后在按照作业的大小，从该分区中划出一块内存空间，分配给请求者，余下的空余分区仍留在空链中。 优点：优先利用内存中低址部分的空闲分区，从而保留了高址部分的大空闲区，为以后到达的大作业分配大的内存空间创造了条件。 缺点：低址部分不断被划分，会留下许多难以利用的、很小的空闲分区即碎片。而每次查找又都是从低址部分开始的，这无疑又会增加查找可用空闲分区时的开销。
循环首次适应算法 在为进程分配内存空间时，不是每次都从链首开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直到找到一个能满足要求的空闲分区。 优点：该算法能使内存中的空闲分区分布得更均匀，从而减少了查找空闲分区时的开销。 最佳适应算法 该算法总是把能满足要求、又是最小的空闲分区分配给作业，避免大材小用，该算法要求将所有的空闲分区按其容量以从小到大的顺序形成一空闲分区链。 缺点：每次分配后所切割下来的剩余部分总是最小的，这样，在存储器中会留下许多难以利用的碎片。 最坏适应算法 最坏适应算法选择空闲分区的策略正好与最佳适应算法相反：它在扫描整个空闲分区或链表时，总会挑选一个最大的空闲区，从中切割一部分存储空间给作业使用。该算法要求，将所有的空闲分区，按其容量以大到小的顺序形成一空闲分区链。查找时，只要看第一个分区能否满足作业要求即可。 优点：可使剩下的空闲区不至于太小，产生碎片的可能性最小，对中小作业有利，同时，最坏适应算法查找效率很高。 缺点：导致存储器中缺乏大的空闲分区 三、数据结构 为了实现动态分区分配算法，系统中配置了相应的数据结构，用以描述空闲分区和已分配分区的情况，常用的数据结构有空闲分区表和空闲分区链 流程图
动态规划求解资源分配 实验目标： （1）掌握用动态规划方法求解实际问题的基本思路。 （2）进一步理解动态规划方法的实质，巩固设计动态规划算法的基本步骤。 实验任务： （1）设计动态规划算法求解资源分配问题，给出算法的非形式描述。 （2）在Windows环境下用C语言实现该算法。计算10个实例，每个实例中n=30，m=10，C i j为随机产生于范围（0，103）内的整数。记录各实例的数据及执行结果（即最优分配方案、最优分配方案的值）、运行时间。 （3）从理论上分析算法的时间和空间复杂度，并由此解释相应的实验结果。 实验设备及环境： PC；C/C++等编程语言。 实验主要步骤： (1)认真阅读实验目的与实验任务，明确本次实验的内容； (2)分析实验中要求求解的问题，根据动态规划的思想，得出优化方程； (3)从问题出发，设计出相应的动态规划算法，并根据设计编写程序实现算法； (4)设计实验数据并运行程序、记录运行的结果； (5)分析算法的时间和空间复杂度，并由此解释释相应的实验结果； 问题描述：资源分配问题 某厂根据计划安排，拟将n台相同的设备分配给m个车间，各车间获得这种设备后，可以为国家提供盈利C i j(i台设备提供给j号车间将得到的利润，1≤i≤n，1≤j≤m) 。问如何分配，才使国家得到最大的盈利？ 1.问题分析： 本问题是一简单资源分配问题，由于具有明显的最优子结构，故可以使用动态规划求解，用状态量f[i][j]表示用i台设备分配给前j个车间的最大获利，那么显然有f[i][j] = max{ f[k][j–1] + c[i-k][j] }，0<=k<=i。再用p[i][j]表示获得最优解时第j号车间使用的设备数为i-p[i][j]，于是从结果倒推往回求即可得到分配方案。程序实现时使用顺推，先枚举车间数，再枚举设备数，再枚举状态转移时用到的设备数，简单3重for循环语句即可完成。时间复杂度为O(n^2*m)，空间复杂度为O(n*m)，倘若此题只需求最大获利而不必求方案，则状态量可以减少一维，空间复杂度优化为O(n)。
0/1背包问题动态规划详解及C代码 动态规划是用空间换时间的一种方法的抽象。其关键是发现子问题和记录其结果。然后利用这些结果减轻运算量。 比如01背包问题。 /*一个旅行者有一个最多能用M公斤的背包，现在有N件物品， 它们的重量分别是W1，W2，...,Wn, 它们的价值分别为P1,P2,...,Pn. 若每种物品只有一件求旅行者能获得最大总价值。 输入格式： M,N W1,P1 W2,P2 ...... 输出格式： X*/ 因为背包最大容量M未知。所以，我们的程序要从1到M一个的试。比如，开始任选N件物品的一个。看对应M的背包，能不能放进去，如果能放进去，并且还有多的空间，则，多出来的空间里能放N-1物品中的最大价值。怎么能保证总选择是最大价值呢？看下表。 测试数据： 10,3 3,4
4,5 5,6 c[i][j]数组保存了1,2,3号物品依次选择后的最大价值. 这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3则里面放 4."这样,这一排背包容量为4,5,6,....10的时候，最佳方案都是放 4."假如1号物品放入背包.则再看2号物品.当背包容量为3的时候，最佳方案还是上一排的最价方案c为 4."而背包容量为5的时候，则最佳方案为自己的重量 5."背包容量为7的时候，很显然是5加上一个值了。加谁??很显然是7-4=3的时候.上一排c3的最佳方案是 4."所以。总的最佳方案是5+4为 9."这样.一排推下去。最右下放的数据就是最大的价值了。(注意第3排的背包容量为7的时候,最佳方案不是本身的 6."而是上一排的 9."说明这时候3号物品没有被选.选的是1,2号物品.所以得 9.") 从以上最大价值的构造过程中可以看出。 f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}这就是书本上写的动态规划方程.这回清楚了吗? 下面是实际程序（在VC 6."0环境下通过）: #include
动态内存分配 一、实验目的 动态分区分配是根据进程的实际需要，动态地为之分配内存空间，而在分配时，须按照一定的分配算法，从空闲分区表或空闲分区链中选出一分区分配给该作业。在本实验中运用了四种分配算法，分别是1.首次适应算法，2.循环首次适应算法，3.最坏适应算法4.最佳适应算法。 二、实验要求及功能介绍 1．实验要求 1.在实现关于内存管理的内存首选适应算法和最佳适用算法。 2.实现关于内存管理的内存动态分区分配布局初始化。 3.实现关于内存管理的内存动态分区分配申请分配。 4.实现关于内存管理的内存回收等基本功能操作函数。 2．功能介绍 （1）首次适应算法 在首次适应算法中，是从已建立好的数组中顺序查找，直至找到第一个大小能满足要求的空闲分区为止，然后再按照作业大小，从该分区中划出一块内存空间分配给请求者，余下的空间令开辟一块新的地址，大小为原来的大小减去作业大小，若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。 （2）循环首次适应算法 该算法是由首次适应算法演变而成，在为进程分配内存空间时，不再是每次都从第一个空间开始查找，而是从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，从中划出一块与请求大小相等的内存空间分配给作业，为实现本算法，设置一个全局变量f，来控制循环查找，当f%N==0时，f=0；若查找结束都不能找到一个满足要求的分区，则此次内存分配失败。 （3）最坏适应算法 最坏适应分配算法是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最大的空闲分区分配给作业。 （4）最佳适应算法 最坏适应分配算法是每次为作业分配内存时，扫描整个数组，总是把能满足条件的，又是最小的空闲分区分配给作业。 三、实验流程图
动态规划之-0-1背包问题及改进
有N件物品和一个容量为V的背包。第i件物品的重量是w[i]，价值是v[i]。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。在选择装入背包的物品时，对于每种物品i，只能选择装包或不装包，不能装入多次，也不能部分装入，因此成为0-1背包问题。 形式化描述为：给定n个物品，背包容量C >0,重量第i件物品的重量w[i]>0, 价值v[i] >0 , 1≤i≤n.要求找一n元向量(X1,X2,…,X n,), X i∈{0,1}, 使得∑（w[i] * Xi）≤C,且∑ v[i] * Xi达最大.即一个特殊的整数规划问题。 数学描述为： 求解最优值：
设最优值m(i,j)为背包容量为j、可选择物品为i，i+1，……，n时的最优值(装入包的最大价值)。所以原问题的解为m(1，C) 将原问题分解为其子结构来求解。要求原问题的解m(1，C)，可从m(n，C)，m(n-1，C)，m(n-2，C).....来依次求解，即可装包物品分别为（物品n）、（物品n-1，n）、（物品n-2，n-1，n）、……、（物品1，物品2，……物品n-1，物品n）。最后求出的值即为最优值m(1，C)。 若求m(i,j)，此时已经求出m(i+1,j)，即第i+1个物品放入和不放入时这二者的最大值。 对于此时背包剩余容量j=0,1,2,3……C，分两种情况： (1)当w[i] > j，即第i个物品重量大于背包容量j时，m(i,j)=m(i+1,j) (2)当w[i] <= j，即第i个物品重量不大于背包容量j时，这时要判断物品i放入和不放入对m的影响。 若不放入物品i，则此时m(i,j)=m(i+1,j) 若放入物品i，此时背包
0-1背包问题举例： 设n=6，c=20， w={4，5，3，8，6，10}, v={20，10，8，18，15，12} 解： p[7]={(0,0)} q[7]=p[7]⊕(10,12)={ (10,12)} p[6]={(0,0), (10,12)} q[6]=p[6]⊕(6,15)={ (6,15),(16, 27)} p[5]= {(0,0), (6,15),(16, 27)} q[5]=p[5]⊕(8,18)={ (8,18),(14, 33)} p[4]= {(0,0), (6,15), (8,18),(14, 33) } q[4]=p[4]⊕(3,8)={(3,8),(9,23),(11,26),(17, 41)} p[3]= {(0,0),(3,8),(6,15),(8,18),(9,23),(11,26),(14, 33),(17, 41)} q[3]=p[3]⊕(5,10)={(5,10),(8,18),(11,25),(13, 28),(14,33),(16,36),(19, 43)} p[2]= {(0,0),(3,8),(5,10),(6,15),(8,18),(9,23),(11,26),(13, 28),(14, 33),(16,36),(17, 41),(19,43)} q[2]=p[2]⊕(4,20)={(4,20),(7,28),(9,30),(10,35),(12,38),(13,43),(15,46),(17, 48),(18, 53),(20,56)} p[1]={(0,0),(3,8),(4,20),(7,28),(9,30),(10,35),(12,38),(13,43),(15,46),(17, 48),(18, 53),(20,56)} 构造最优解： X={1，1，1，1
动态分配内存算法以及源程序讲解 整体思路： 动态分区管理方式将内存除操作系统占用区域外的空间看成一个大的空闲区。当作业要求装入内存时，根据作业需要内存空间的大小查询内存中的各个空闲区，当从内存空间中找到一个大于或等于该作业大小的内存空闲区时，选择其中一个空闲区，按作业需求量划出一个分区装人该作业，作业执行完后，其所占的内存分区被收回，成为一个空闲区。如果该空闲区的相邻分区也是空闲区，则需要将相邻空闲区合并成一个空闲区。 设计所采用的算法： 采用最优适应算法，每次为作业分配内存时，总是把既能满足要求、又是最小的空闲分区分配给作业。但最优适应算法容易出现找到的一个分区可能只比作业所需求的长度略大一点的情行，这时，空闲区分割后剩下的空闲区就很小以致很难再使用，降低了内存的使用率。为解决此问题，设定一个限值minsize，如果空闲区的大小减去作业需求长度得到的值小于等于minsize，不再将空闲区分成己分分区和空闲区两部分，而是将整个空闲区都分配给作业。 内存分配与回收所使用的结构体： 为便于对内存的分配和回收，建立两张表记录内存的使用情况。一张为记录作业占用分区的“内存分配表”，内容包括分区起始地址、长度、作业名/标志（为0时作为标志位表示空栏目）；一张为记录空闲区的“空闲分区表”，内容包括分区起始地址、长度、标志（0表空栏目，1表未分配）。两张表都采用顺序表形式。 关于分配留下的内存小碎片问题： 当要装入一个作业时，从“空闲分区表”中查找标志为“1”（未分配）且满足作业所需内存大小的最小空闲区，若空闲区的大小与作业所需大小的差值小于或等于minsize，把该分区全部分配给作业，并把该空闲区的标志改为“0”（空栏目）。同时，在已分配区表中找到一个标志为“0”的栏目登记新装人作业所占用分区的起始地址，长度和作业名。若空闲区的大小与作业所需大小的差值大于minsize。则把空闲区分成两部分，一部分用来装入作业，另外一部分仍为空闲区。这时只要修改原空闲区的长度，且把新装人的作业登记到已分配区表中。 内存的回收： 在动态分区方式下回收内存空间时，先检查是否有与归还区相邻的空闲区（上邻空闲区，
如对你有帮助，请购买下载打赏，谢谢！ 动态规划求解资源分配 姓名：白云志 班级：计算机1103 学号：27 实验目标： （1）掌握用动态规划方法求解实际问题的基本思路。（2）进一步理解动态规划方法的实质，巩固设计动态规划算法的基本步骤。 实验任务： （1）设计动态规划算法求解资源分配问题，给出算法的非形式描述。 （2）在Windows环境下用C语言实现该算法。计算10个实例，每个实例中n=30，m=10，C i j为随机产生于范围（0，103）内的整数。记录各实例的数据及执行结果（即最优分配方案、最优分配方案的值）、运行时间。 （3）从理论上分析算法的时间和空间复杂度，并由此解释相应的实验结果。实验设备及环境： PC；C/C++等编程语言。 实验主要步骤： (1)认真阅读实验目的与实验任务，明确本次实验的内容； (2)分析实验中要求求解的问题，根据动态规划的思想，得出优化方程； (3)从问题出发，设计出相应的动态规划算法，并根据设计编写程序实现算法； (4)设计实验数据并运行程序、记录运行的结果； (5)分析算法的时间和空间复杂度，并由此解释释相应的实验结果； 问题描述：资源分配问题 某厂根据计划安排，拟将n台相同的设备分配给m个车间，各车间获得这种设备后，可以为国家提供盈利C i j(i台设备提供给j号车间将得到的利润，1≤i≤n，1≤j≤m) 。问如何分配，才使国家得到最大的盈利？ 1.问题分析： 本问题是一简单资源分配问题，由于具有明显的最优子结构，故可以使用动态规划求解，用状态量f[i][j]表示用i台设备分配给前j个车间的最大获利，那么显然有f[i][j] = max{ f[k][j–1] + c[i-k][j] }，0<=k<=i。再用p[i][j]表示获得最优解时第j号车间使用的设备数
实验二用动态规划实现0-1背包问题 一．实验目的 1.熟悉动态规划法的基本原理。 2.通过本次实验加深对动态规划的理解。 二．实验内容及要求 内容：.给定n种物品和一个背包。物品i的重量是w，其价值为v，背包容量为 c。问应该如何选择装入背包的物品，使得装入背包中物品的总价值最大? 要求：使用动态规划算法编程，求解0-1背包问题 三．程序列表 （1） #include
int sum=0; for(int k=n;k>=1;k--) { if(optp[k][m]==optp[k-1][m]) x[k]=0; else { x[k]=1; m=m-w[k]; sum=sum+w[k]; } } x[1]=optp[1][m]?1:0; cout<<"最大总重量:"< 动态规划求解资源分配 姓名：白云志 班级：计算机1103 学号：1111610427 实验目标： （1）掌握用动态规划方法求解实际问题的基本思路。 （2）进一步理解动态规划方法的实质，巩固设计动态规划算法的基本步骤。 实验任务： （1）设计动态规划算法求解资源分配问题，给出算法的非形式描述。 （2）在Windows环境下用C语言实现该算法。计算10个实例，每个实例中n=30，m=10，C i j为随机产生于范围（0，103）内的整数。记录各实例的数据及执行结果（即最优分配方案、最优分配方案的值）、运行时间。 （3）从理论上分析算法的时间和空间复杂度，并由此解释相应的实验结果。 实验设备及环境： PC；C/C++等编程语言。 实验主要步骤： (1)认真阅读实验目的与实验任务，明确本次实验的内容； (2)分析实验中要求求解的问题，根据动态规划的思想，得出优化方程； (3)从问题出发，设计出相应的动态规划算法，并根据设计编写程序实现算法； (4)设计实验数据并运行程序、记录运行的结果； (5)分析算法的时间和空间复杂度，并由此解释释相应的实验结果； 问题描述：资源分配问题 某厂根据计划安排，拟将n台相同的设备分配给m个车间，各车间获得这种设备后，可以为国家提供盈利C i j(i台设备提供给j号车间将得到的利润，1≤i≤n，1≤j≤m) 。问如何分配，才使国家得到最大的盈利？ 1.问题分析： 本问题是一简单资源分配问题，由于具有明显的最优子结构，故可以使用动态规划求解，用状态量f[i][j]表示用i台设备分配给前j个车间的最大获利，那么显然有f[i][j] = max{ f[k][j–1] + c[i-k][j] }，0<=k<=i。再用p[i][j]表示获得最优解时第j号车间使用的设备数为i-p[i][j]，于是从结果倒推往回求即可得到分配方案。程序实现时使用顺推，先枚举车间数，再枚举设备数，再枚举状态转移时用到的设备数，简单3重for循环语句即可完成。时间复杂度为O(n^2*m)，空间复杂度为O(n*m)，倘若此题只需求最大获利而不必求方案，则状态量可以减少一维，空间复杂度优化为O(n)。 程序代码： Keil51动态内存分配问题经验 动态内存一般分配在堆中，而静态的内存一般分配在栈中；Keil51中提供了一个建立堆的函数，就是init_mempool（首地址，大小），首地址被定义为xdata 的地址空间，这个函数可以在xdata中定义一个可以动态分配的堆；因为在51中，data区域的空间太小，要动态分配空间，考虑到程序的运行，是不合理的，所以必须在xdata中建立可以动态分配的堆。 STC12C5A60S2内部集成了256字节的RAM，存储类型为data，地址是00H~FFH。其中低128字节是工作寄存器组，包括R0~R7，地址为00H~1FH，20H~2FH地址区为位寻址区，30H~7FH为普通RAM区；高128字节为普通的RAM区。内部RAM中，30H~FFH都是普通用户RAM和堆栈区，可以用来进行内存分配，总共208字节；实际在程序运行中，要在这208字节分配一个堆栈进行动态的内存分配，对于其他的程序运行会有很多不便。 STC12C5A60S2可用的内部扩展RAM的地址空间是：0x000~0x3ff这一地址空间，存储类型为xdata，这部分空间总共占1K字节，可以用来作为堆栈区，进行内存动态分配。 STC12C5A60S2可以扩展64K外部xdata，在没有进行扩展外部存储器的情况下，最好使用上述内部扩展的1K字节，地址为0x000~0x3ff的存储器。 对于其他的51单片机，用户可以参考芯片手册查看系统内部的以及扩展的RAM空间大小和地址，确定data和xdata范围，根据需要自行定义。 目前，我使用STC12C5A60S2总结了两种动态定义的方式。 方式一：给定地址区域 init_mempool(0x0000,0x03ff);//内部扩展1K字节的空间， //都可以作为堆栈空间进行内存分配； 数据结构： typedef struct STU{ uint8id; struct STU*next; }*PSTU,STU_t; 注意：一定在使用init_mempool函数之后使用malloc calloc，，realloc realloc，，free等 malloc，，calloc 函数，因为只有先确定了堆，才能在堆中执行相应的操作； 定义并分配堆空间： PSTU stu； init_mempool(0x0100,500);//内部只能用0x300~0x3ff这一地址空间； 初始化： stu=(PSTU)malloc(sizeof(STU_t)); stu->id=8; stu->next=NULL; 函数：void insertlist(PSTU phead,uint8pos,PSTU stu); 方式二：让系统随机分配动态规划_求解资源分配_实验报告
C51单片机动态内存分配
相关主题
文本预览