(完整版)01背包问题

合集下载

01背包问题(回溯法)

01背包问题(回溯法)

01背包问题(回溯法) 回溯法是⼀个既带有系统性⼜带有跳跃性的搜索算法。

它在包含问题的所有解的解空间树中,按深度优先策略,从根结点出发搜索解空间树。

算法搜索⾄解空间树的任意⼀结点时,先判断该结点是否包含问题的解。

如果肯定不包含,则跳过对该结点为根的⼦树搜索,逐层向其祖先结点回溯;否则,进⼊该⼦树,继续按深度优先策略搜索。

问题的解空间⽤回溯法解问题时,应明确定义问题的解空间。

问题的解空间⾄少包含问题的⼀个(最优)解。

对于 n=3 时的 0/1 背包问题,可⽤⼀棵完全⼆叉树表⽰解空间,如图所⽰:求解步骤1)针对所给问题,定义问题的解空间;2)确定易于搜索的解空间结构;3)以深度优先⽅式搜索解空间,并在搜索过程中⽤剪枝函数避免⽆效搜索。

常⽤的剪枝函数:⽤约束函数在扩展结点处剪去不满⾜约束的⼦树;⽤限界函数剪去得不到最优解的⼦树。

回溯法对解空间做深度优先搜索时,有递归回溯和迭代回溯(⾮递归)两种⽅法,但⼀般情况下⽤递归⽅法实现回溯法。

算法描述 解 0/1 背包问题的回溯法在搜索解空间树时,只要其左⼉⼦结点是⼀个可⾏结点,搜索就进⼊其左⼦树。

当右⼦树中有可能包含最优解时才进⼊右⼦树搜索。

否则将右⼦树剪去。

代码:public class Knapsack_Problem01 {double m=100; //背包最⼤容量int n=5; //物品的个数int[] w = {10,20,30,40,50}; //第i个物品的重量int[] v = {20,30,65,40,60}; //第i个物品的价值int[] a = new int[n]; //记录在树中的移动路径,为1的时候表⽰选择该组数据,为0的表⽰不选择该组数据int maxvalue = 0; //背包的最⼤权重值public static void main(String[] args){Knapsack_Problem01 p = new Knapsack_Problem01();p.Search(0);}public void Search(int i) //i表⽰递归深度{if(i>=n){CheckMax();}else {a[i] = 0;Search(i+1);a[i] = 1;Search(i+1);}}public void CheckMax(){int weight = 0;int value = 0;for(int i=0;i<n;i++) //判断是否达到上限{if(a[i] == 1){weight = weight + w[i];value = value + v[i];}}if(weight <= m){if(value >= maxvalue){maxvalue = value;System.out.print("最⼤价值是:" + maxvalue +" ");System.out.print("所选取的物品为(1代表选中,0代表不选中): ");for(int j=0;j<n;j++){System.out.print(a[j]);System.out.print(' ');}System.out.print('\n');}}}}。

贪心算法-01背包问题

贪心算法-01背包问题

贪⼼算法-01背包问题1、问题描述:给定n种物品和⼀背包。

物品i的重量是wi,其价值为vi,背包的容量为C。

问:应如何选择装⼊背包的物品,使得装⼊背包中物品的总价值最⼤?形式化描述:给定c >0, wi >0, vi >0 , 1≤i≤n.要求找⼀n元向量(x1,x2,…,xn,), xi∈{0,1}, ∋ ∑ wi xi≤c,且∑ vi xi达最⼤.即⼀个特殊的整数规划问题。

2、最优性原理:设(y1,y2,…,yn)是 (3.4.1)的⼀个最优解.则(y2,…,yn)是下⾯相应⼦问题的⼀个最优解:证明:使⽤反证法。

若不然,设(z2,z3,…,zn)是上述⼦问题的⼀个最优解,⽽(y2,y3,…,yn)不是它的最优解。

显然有∑vizi > ∑viyi (i=2,…,n)且 w1y1+ ∑wizi<= c因此 v1y1+ ∑vizi (i=2,…,n) > ∑ viyi, (i=1,…,n)说明(y1,z2, z3,…,zn)是(3.4.1)0-1背包问题的⼀个更优解,导出(y1,y2,…,yn)不是背包问题的最优解,⽭盾。

3、递推关系:设所给0-1背包问题的⼦问题的最优值为m(i,j),即m(i,j)是背包容量为j,可选择物品为i,i+1,…,n时0-1背包问题的最优值。

由0-1背包问题的最优⼦结构性质,可以建⽴计算m(i,j)的递归式:注:(3.4.3)式此时背包容量为j,可选择物品为i。

此时在对xi作出决策之后,问题处于两种状态之⼀:(1)背包剩余容量是j,没产⽣任何效益;(2)剩余容量j-wi,效益值增长了vi ;使⽤递归C++代码如下:#include<iostream>using namespace std;const int N=3;const int W=50;int weights[N+1]={0,10,20,30};int values[N+1]={0,60,100,120};int V[N+1][W+1]={0};int knapsack(int i,int j){int value;if(V[i][j]<0){if(j<weights[i]){value=knapsack(i-1,j);}else{value=max(knapsack(i-1,j),values[i]+knapsack(i-1,j-weights[i]));}V[i][j]=value;}return V[i][j];}int main(){int i,j;for(i=1;i<=N;i++)for(j=1;j<=W;j++)V[i][j]=-1;cout<<knapsack(3,50)<<endl;cout<<endl;}不使⽤递归的C++代码:简单⼀点的修改//3d10-1 动态规划背包问题#include <iostream>using namespace std;const int N = 4;void Knapsack(int v[],int w[],int c,int n,int m[][10]);void Traceback(int m[][10],int w[],int c,int n,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 m[10][10];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;Knapsack(v,w,c,N,m);cout<<"背包能装的最⼤价值为:"<<m[1][c]<<endl;Traceback(m,w,c,N,x);cout<<"背包装下的物品编号为:"<<endl;for(int i=1; i<=N; i++){if(x[i]==1){cout<<i<<" ";}}cout<<endl;return 0;}void Knapsack(int v[],int w[],int c,int n,int m[][10]){int jMax = min(w[n]-1,c);//背包剩余容量上限范围[0~w[n]-1] for(int j=0; j<=jMax;j++){m[n][j]=0;}for(int j=w[n]; j<=c; j++)//限制范围[w[n]~c]{m[n][j] = v[n];}for(int i=n-1; i>1; i--){jMax = min(w[i]-1,c);for(int j=0; j<=jMax; j++)//背包不同剩余容量j<=jMax<c{m[i][j] = m[i+1][j];//没产⽣任何效益}for(int j=w[i]; j<=c; j++) //背包不同剩余容量j-wi >c{m[i][j] = max(m[i+1][j],m[i+1][j-w[i]]+v[i]);//效益值增长vi }}m[1][c] = m[2][c];if(c>=w[1]){m[1][c] = max(m[1][c],m[2][c-w[1]]+v[1]);}}//x[]数组存储对应物品0-1向量,0不装⼊背包,1表⽰装⼊背包void Traceback(int m[][10],int w[],int c,int n,int x[]){for(int i=1; i<n; i++){if(m[i][c] == m[i+1][c]){x[i]=0;}else{x[i]=1;c-=w[i];}}x[n]=(m[n][c])?1:0;}运⾏结果:算法执⾏过程对m[][]填表及Traceback回溯过程如图所⽰:从m(i,j)的递归式容易看出,算法Knapsack需要O(nc)计算时间; Traceback需O(n)计算时间;算法总体需要O(nc)计算时间。

动态规划——01背包问题

动态规划——01背包问题

动态规划——01背包问题⼀、最基础的动态规划之⼀01背包问题是动态规划中最基础的问题之⼀,它的解法完美地体现了动态规划的思想和性质。

01背包问题最常见的问题形式是:给定n件物品的体积和价值,将他们尽可能地放⼊⼀个体积固定的背包,最⼤的价值可以是多少。

我们可以⽤费⽤c和价值v来描述⼀件物品,再设允许的最⼤花费为w。

只要n稍⼤,我们就不可能通过搜索来遍查所有组合的可能。

运⽤动态规划的思想,我们把原来的问题拆分为⼦问题,⼦问题再进⼀步拆分直⾄不可再分(初始值),随后从初始值开始,尽可能地求取每⼀个⼦问题的最优解,最终就能求得原问题的解。

由于不同的问题可能有相同的⼦问题,⼦问题存在⼤量重叠,我们需要额外的空间来存储已经求得的⼦问题的最优解。

这样,可以⼤幅度地降低时间复杂度。

有了这样的思想,我们来看01背包问题可以怎样拆分成⼦问题:要求解的问题是:在n件物品中最⼤花费为w能得到的最⼤价值。

显然,对于0 <= i <= n,0 <= j <= w,在前i件物品中最⼤花费为j能得到的最⼤价值。

可以使⽤数组dp[n + 1][w + 1]来存储所有的⼦问题,dp[i][j]就代表从前i件物品中选出总花费不超过j时的最⼤价值。

可知dp[0][j]值⼀定为零。

那么,该怎么递推求取所有⼦问题的解呢。

显⽽易见,要考虑在前i件物品中拿取,⾸先要考虑前i - 1件物品中拿取的最优情况。

当我们从第i - 1件物品递推到第i件时,我们就要考虑这件物品是拿,还是不拿,怎样收益最⼤。

①:⾸先,如果j < c[i],那第i件物品是⽆论如何拿不了的,dp[i][j] = dp[i - 1][j];②:如果可以拿,那就要考虑拿了之后收益是否更⼤。

拿这件物品需要花费c[i],除去这c[i]的⼦问题应该是dp[i - 1][j - c[i]],这时,就要⽐较dp[i - 1][j]和dp[i - 1][j - c[i]] + v[i],得出最优⽅案。

01背包问题动态规划算法

01背包问题动态规划算法

01背包问题动态规划算法
01背包问题是求在限定条件下,在一定的容量内最优装载物品,使得总价值最大。

动态规划算法是一种用于解决多阶段决策问题的途径,其特点是将原问题划分成若干子问题,每个子问题只求解一次,保存子问题的解,避免了重复计算。

01背包问题动态规划算法的步骤如下:
1、确定状态:物品的种数i (i=1,2,…n),背包的容量j (j=0,1,2,…V)。

2、确定状态转移方程:f[i][j]=max{f[i-1][j],f[i-1][j-wi]+vi}。

3、确定初始状态:f[i][0]=0,f[0][j]=0。

4、确定输出:最后f[n][V]即为最优解。

5、根据状态转移方程从左到右,从上到下进行迭代计算。

01背包问题(01knapsackproblem)

01背包问题(01knapsackproblem)

01背包问题(01knapsackproblem)0 / 1 背包问题(0 / 1 knapsack problem)背包问题(Knapsack problem)是⼀种组合优化的问题。

问题可以描述为:给定⼀组物品,每种物品都有⾃⼰的重量和价格,在限定的总重量内,我们如何选择,才能使得物品的总价格最⾼。

问题的名称来源于如何选择最合适的物品放置于给定背包中。

相似问题经常出现在商业、[组合数学],[计算复杂性理论]、[密码学]和[应⽤数学]等领域中。

也可以将背包问题描述为,即在总重量不超过W的前提下,总价值是否能达到V。

1、题⽬描述假设商店中有如下3个商品,他们的重量和价格如下:索引重量价值011500143000232000假如你是⼀个⼩偷,你有⼀个重量为4的包,每个商品只能偷⼀次,请问你怎么偷才会使得最后的价值最⼤?2、分析这种问题⼀般可以⽤动态规划很好地解决。

但是如果我不⽤动态规划,⽽是⽤搜索所有情况来解决也可以,每个商品都有偷或不偷的选项,所以n个商品就有n^2种情况,所以⽤遍历的⽅法时间复杂度为O(n^2) n为商品的数量现在我们假设B(k, w)表⽰的是前k个商品,在背包容量为w的情况下能偷的最⾼价值当现在⾯对的第k个物品重量太重时:B(k, w) = B(k-1, w),代表我在多了⼀个物品的选择的情况下,仍然和没有这件物品时的选择⼀样,所以结果也⼀样(因为我偷不了或者我不偷的情况)当第k个物品的重量我可以接受时:B(k, w) = B(k-1, w - 这件物品的重量) + 这件物品的价值代表我如果偷了这件物品,那剩下的w - 这件物品重量的空间可以容纳的最⼤价值就是在上⼀次选择时B(k-1, w - 这件物品的重量)的值。

再加上这件物品的价值就是我偷了这件物品的最⼤值。

所以,在衡量⼀个B(k, w)时,⾸先看⼀下能不能偷,能得话看⼀下偷还是不偷两个的最⼤值,就是B(k, w)的值,所以我们回到上⾯的问题,问题的解就是B(2,4)的值我们⽤⼆维数组 dp[][]来表⽰整个的过程可选商品 \ 背包容量012340号商品(1,1500)015001500150015000 ~ 1号商品(4,3000)015001500150030000 ~ 2号商品(3,2000)01500150020003500如图中加粗数字1500代表的是在有前两个商品,背包容量为2时可以偷的最⼤价值为1500图中加粗数字3000,即在有前2个商品,背包重量为4时,可以偷的最⼤价值为3000,这个数是这样算的:第⼆个商品(1号)重量为4,正好满⾜,如果偷的话所以价值为3000 + 0 = 3000如果不偷的话价值和只有1个商品,背包容量为4的价值⼀样,1500取最⼤值为3000所以问题的关键就在构建这个⼆维数组3、实现/*** 时间复杂度:O(n * capacity) n为商品数量,capacity为包的⼤⼩* 空间复杂度:O(n * capacity) 可以优化为capacity*/public class Main{/*** 0/1 背包问题* @param w w[i]代表i号物品的重量(从0开始)* @param v v[i]代表i号物品的价值(从0开始)* @param capacity 代表包的最⼤容量* @return 可以偷的商品的最⼤值*/public static int knapsack(int[] w, int[] v, int capacity){int goods = w.length; // 商品数int[][] dp = new int[goods][capacity + 1];// 初始化第⼀⾏,因为第⼀⾏上层没有元素了,即只有第⼀个商品时for(int j = 1; j <= capacity; j++){if(j >= w[0]) dp[0][j] = v[0];}// 前i个商品, 背包容量为j时偷得最⼤价值for(int i = 1; i < goods; i++) {for(int j = 1; j < capacity + 1; j++) {// 如果容量不够放下第i个商品if(w[i] > j) {dp[i][j] = dp[i-1][j];} else { // 如果可以放下这件商品dp[i][j] =Math.max(dp[i-1][j], v[i] + dp[i-1][j-w[i]]);}}}// System.out.println(Arrays.deepToString(dp));return dp[goods - 1][capacity];}}⽤滚动数组优化空间复杂度:因为如果我们从后往前构建每⼀⾏,那上⼀⾏保留的就可以在构建时候⽤/*** 时间复杂度:O(n * capacity) n为商品数量,capacity为包的⼤⼩* 空间复杂度:O(capacity)*/public class Main{/*** 0/1 背包问题* @param w w[i]代表i号物品的重量(从0开始)* @param v v[i]代表i号物品的价值(从0开始)* @param capacity 代表包的最⼤容量* @return 可以偷的商品的最⼤值*/public static int knapsack(int[] w, int[] v, int capacity){int goods = w.length; // 商品数int[] dp = new int[capacity + 1];// 前i个商品, 背包容量为j时偷得最⼤价值for(int i = 0; i < goods; i++) {for(int j = capacity; j > 0; j--) {// 如果能装下就更新,装不下就不更新(上⼀⾏的值)if(j - w[i] >= 0) {dp[j] = Math.max(dp[j], v[i] + dp[j - w[i]]);}}}return dp[capacity];}}。

5.5动态规划求解01背包问题

5.5动态规划求解01背包问题
xn-1: 若xn=0,则判断(Pl,Wl)∈ Sn-2?,以确定Xn-1的值 若xn=1,则依据(Pl-pn,Wl-wn)∈ Sn-2?,以判断Xn-1的值
xn-2,…,x1将依次推导得出
例2的解向量推导
S0={(0,0)}
S1={(0,0),(1,2)}
S2={(0,0),(1,2), (2,3),(3,5)}
● Si的构造
记S1i 是fi-1(X-wi)+pi的所有序偶的集合,则
S1i {( P,W ) | (P pi ,W wi ) S i1}
其中,Si-1是fi-1的所有序偶的集合
Si的构造:由Si-1和 S1i 按照支配规则合并而成。
支配规则:如果Si-1和S1i 之一有序偶(Pj,Wj),另一有(Pk,Wk),
5.5动态规划求解 0/1背包问题
1.问题描述 背包容量M,n个物品,分别具有效益值P1…Pn,物
品重量w1…wn,从n个物品中,选择若干物品放入 背包,物品要么整件放入背包,要么不放入。怎 样决策可以使装入背包的物品总效益值最大?
形式化描述:
目标函数:
约束条件:
max pixi
1i j
wixi M
1in
xi
0或1,
pi
0, wi
0,1
i
n
0/1背包问题:KNAP(1,n,M)
❖ 0/1背包问题:M=6,N=3,W=(3,3,4),P=(3,3,5) ❖ 贪心法:p3/w3 > p1/w1 > p2/w2 ❖ 贪心解 ∑P=5(0,0,1) ❖ 最优解是:∑P=6(1,1,0)
❖ 贪心法求解0/1背包问题不一定得到最优解! ❖ 动态规划求解的问题必须满足最优化原理

动规-背包九讲完整版

动规-背包九讲完整版
如果并没有要求必须把背包装满,而是只希望价格尽量大,初始化时应该将 f[0..V]全部设 为 0。
为什么呢?可以这样理解:初始化的 f 数组事实上就是在没有任何物品可以放入背包时的合 法状态。如果要求背包恰好装满,那么此时只有容量为 0 的背包可能被价值为 0 的 nothing“恰好装满”,其它容量的背包均没有合法的解,属于未定义的状态,它们的值就都 应该是-∞了。如果背包并非必须被装满,那么任何容量的背包都有一个合法解“什么都不 装”,这个解的价值为 0,所以初始时状态的值也就全部为 0 了。
前言
本篇文章是我(dd_engi)正在进行中的一个雄心勃勃的写作计划的一部分,这个计划的内容是 写作一份较为完善的 NOIP 难度的动态规划总结,名为《解动态规划题的基本思考方式》。现 在你看到的是这个写作计划最先发布的一部分。
背包问题是一个经典的动态规划模型。它既简单形象容易理解,又在某种程度上能够揭示动 态规划的本质,故不少教材都把它作为动态规划部分的第一道例题,我也将它放在我的写作 计划的第一部分。
这个小技巧完全可以推广到其它类型的背包问题,后面也就不再对进行状态转移之前的初始 化进行讲解。
小结
01 背包问题是最基本的背包问题,它包含了背包问题中设计状态、方程的最基本思想,另 外,别的类型的背包问题往往也可以转换成 01 背包问题求解。故一定要仔细体会上面基本思 路的得出方法,状态转移方程的意义,以及最后怎样优化的空间复杂度。
感谢 XiaQ,它针对本文的第一个 beta 版发表了用词严厉的六条建议,虽然我只认同并采纳 了其中的两条。在所有读者几乎一边倒的赞扬将我包围的当时,你的贴子是我的一剂清醒 剂,让我能清醒起来并用更严厉的眼光审视自己的作品。
当然,还有用各种方式对我表示鼓励和支持的几乎无法计数的同学。不管是当面赞扬,或是 在论坛上回复我的贴子,不管是发来热情洋溢的邮件,或是在即时聊天的窗口里竖起大拇 指,你们的鼓励和支持是支撑我的写作计划的强大动力,也鞭策着我不断提高自身水平,谢 谢你们!

动态规划01背包问题

动态规划01背包问题
最终,f[n][W]就是最优解,其中 n 是物品的总数,W 是背包 的容量。
01 背包问题的时间复杂度为 O(nW),空间复杂度为 O(nW)。
• 选择放入第 i 个物品。此时,背包的剩余容量为 j-w[i], 所以 f[i][j] = f[i-1][j-w[i]] + v[i]。 • 不选择放入第 i 个物品。此时,f[i][j] = f[i-1][j]。
综上所述,状态转移方程为:
f[i][j] = max(f[i-1][j], f[i-1][j-w[i]] + v[i])
01 背包问题是一种经典的动态规划问题,其目的是在限制条 件下,使得背包内的物品价值最大。
在 01 背包问题中,每种物品都有其体积和价值。同时,背 包也有一定的容量限制。问题的目标是在不超过背包容量的 前提下,使得背包内物品的价值最大。
为了解决 [j]表示前 i 个物品放入一个容量为 j 的背包可以获得的最大价值。然后,我们考虑第 i 个物品的 选择情况,其中有两种情况:
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

01背包问题,是用来介绍动态规划算法最经典的例子,网上关于01背包问题的讲解也很多,我写这篇文章力争做到用最简单的方式,最少的公式把01背包问题讲解透彻。

01背包的状态转换方程f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ), f[i-1,j] }
只要你能通过找规律手工填写出上面这张表就算理解了01背包的动态规划算法。

首先要明确这张表是至底向上,从左到右生成的。

为了叙述方便,用e2单元格表示e行2列的单元格,这个单元格的意义是用来表示只有物品e时,有个承重为2的背包,那么这个背包的最大价值是0,因为e物品的重量是4,背包装不了。

对于d2单元格,表示只有物品e,d时,承重为2的背包,所能装入的最大价值,仍然是0,因为物品e,d都不是这个背包能装的。

同理,c2=0,b2=3,a2=6。

对于承重为8的背包,a8=15,是怎么得出的呢?
根据01背包的状态转换方程,需要考察两个值,
一个是f[i-1,j],对于这个例子来说就是b8的值9,另一个是f[i-1,j-Wi]+Pi;
在这里,
f[i-1,j]表示我有一个承重为8的背包,当只有物品b,c,d,e四件可选时,这个背包能装入的最大价值
f[i-1,j-Wi]表示我有一个承重为6的背包(等于当前背包承重减去物品a的重量),当只有物品b,c,d,e四件可选时,这个背包能装入的最大价值
f[i-1,j-Wi]就是指单元格b6,值为9,Pi指的是a物品的价值,即6
由于f[i-1,j-Wi]+Pi = 9 + 6 = 15 大于f[i-1,j] = 9,所以物品a应该放入承重为8的背包
以下是actionscript3 的代码
public function get01PackageAnswer(bagItems:Array,bagSize:int):Array
{
var bagMatrix:Array=[];
var i:int;
var item:PackageItem;
for(i=0;i<bagItems.length;i++)
{
bagMatrix[i] = [0];
}
for(i=1;i<=bagSize;i++)
{
for(var
j:int=0;j<bagItems.length;j++)
{
item = bagItems[j] as PackageItem;
if(item.weight > i)
{
//i背包转不下item
if(j==0)
{
bagMatrix[j][i] = 0;
}
else
{
bagMatrix[j][i]=bagMatrix[j-1][i];
}
}
else
{
//将item装入背包后的价值总和
var itemInBag:int;
if(j==0)
{
bagMatrix[j][i] = item.value;
continue;
}
else
{
itemInBag = bagMatrix[j-1][i-item.weight]+item.value;
}
bagMatrix[j][i] = (bagMatrix[j-1][i] > itemInBag ? bagMatrix[j-1][i] : itemInBag)
}
}
}
//find answer
var answers:Array=[];
var curSize:int = bagSize;
for(i=bagItems.length-1;i>=0;i--)
{
item = bagItems[i] as PackageItem;
if(curSize==0)
{
break;
}
if(i==0 && curSize > 0)
{
answers.push();
break;
}
if(bagMatrix[i][curSize]-bagMatrix[i-1][curSize-item.weight ]==item.value)
{
answers.push();
curSize -= item.weight;
}
}
return answers;
}
PackageItem类
public class PackageItem
{
public var name:String;
public var weight:int;
public var value:int;
public function PackageItem(name:String,weight:int,value:int)
{
= name;
this.weight = weight;
this.value = value;
}
}
测试代码
var
nameArr:Array=['a','b','c','d','e'];
var weightArr:Array=[2,2,6,5,4];
var valueArr:Array=[6,3,5,4,6];
var bagItems:Array=[];
for(var
i:int=0;i<nameArr.length;i++)
{
var bagItem:PackageItem = new PackageItem(nameArr[i],weightArr[i],valueArr[i]);
bagItems[i]=bagItem;
}
var arr:Array = ac.get01PackageAnswer(bagItems,10);。

相关文档
最新文档