[汇总]蛮力法、动态规划法、回溯法和分支限界法求解01背包问题
回溯法解决0-1背包问题
回溯法解决0-1背包问题问题描述： 有n件物品和⼀个容量为c的背包。
第i件物品的价值是v[i]，重量是w[i]。
求解将哪些物品装⼊背包可使价值总和最⼤。
所谓01背包，表⽰每⼀个物品只有⼀个，要么装⼊，要么不装⼊。
回溯法： 01背包属于找最优解问题，⽤回溯法需要构造解的⼦集树。
在搜索状态空间树时，只要左⼦节点是可⼀个可⾏结点，搜索就进⼊其左⼦树。
对于右⼦树时，先计算上界函数，以判断是否将其减去，剪枝啦啦！上界函数bound():当前价值cw+剩余容量可容纳的最⼤价值<=当前最优价值bestp。
为了更好地计算和运⽤上界函数剪枝，选择先将物品按照其单位重量价值从⼤到⼩排序，此后就按照顺序考虑各个物品。
#include <stdio.h>#include <conio.h>int n;//物品数量double c;//背包容量double v[100];//各个物品的价值double w[100];//各个物品的重量double cw = 0.0;//当前背包重量double cp = 0.0;//当前背包中物品价值double bestp = 0.0;//当前最优价值double perp[100];//单位物品价值排序后int order[100];//物品编号int put[100];//设置是否装⼊//按单位价值排序void knapsack(){int i,j;int temporder = 0;double temp = 0.0;for(i=1;i<=n;i++)perp[i]=v[i]/w[i];for(i=1;i<=n-1;i++){for(j=i+1;j<=n;j++)if(perp[i]<perp[j])//冒泡排序perp[],order[],sortv[],sortw[]{temp = perp[i];perp[i]=perp[i];perp[j]=temp;temporder=order[i];order[i]=order[j];order[j]=temporder;temp = v[i];v[i]=v[j];v[j]=temp;temp=w[i];w[i]=w[j];w[j]=temp;}}}//回溯函数void backtrack(int i){double bound(int i);if(i>n){bestp = cp;return;}if(cw+w[i]<=c){cw+=w[i];cp+=v[i];put[i]=1;backtrack(i+1);cw-=w[i];cp-=v[i];}if(bound(i+1)>bestp)//符合条件搜索右⼦数backtrack(i+1);}//计算上界函数double bound(int i){double leftw= c-cw;double b = cp;while(i<=n&&w[i]<=leftw){leftw-=w[i];b+=v[i];i++;}if(i<=n)b+=v[i]/w[i]*leftw;return b;}int main(){int i;printf("请输⼊物品的数量和容量：");scanf("%d %lf",&n,&c);printf("请输⼊物品的重量和价值：");for(i=1;i<=n;i++){printf("第%d个物品的重量：",i);scanf("%lf",&w[i]);printf("价值是：");scanf("%lf",&v[i]);order[i]=i;}knapsack();backtrack(1);printf("最有价值为：%lf\n",bestp);printf("需要装⼊的物品编号是：");for(i=1;i<=n;i++){if(put[i]==1)printf("%d ",order[i]);}return 0;}时间复杂度分析： 上界函数bound()需要O(n)时间，在最坏的情况下有O(2^n)个右⼦结点需要计算上界，回溯算法backtrack需要的计算时间为O(n2^n)。
用蛮力法、动态规划法和贪心法求解0-1背包问题
实验项目三 用蛮力法、动态规划法和贪心法求解0/1背包问题实验目的1、学会背包的数据结构的设计，针对不同的问题涉及到的对象的数据结构的设计也不同；2、对0-1背包问题的算法设计策略对比与分析。
实验内容：0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中。
在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi 表示物品i 装入背包的情况，则当xi =0时，表示物品i 没有被装入背包，xi =1时，表示物品i 被装入背包。
根据问题的要求，有如下约束条件和目标函数：于是，问题归结为寻找一个满足约束条件式1，并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。
背包的数据结构的设计：typedef struct object{int n;//物品的编号⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1）∑=n i iix v 1m ax （式2）int w;//物品的重量int v;//物品的价值}wup;wup wp[N];//物品的数组，N为物品的个数int c;//背包的总重量1、蛮力法蛮力法是一种简单直接的解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。
蛮力法的关键是依次处理所有的元素。
用蛮力法解决0/1背包问题，需要考虑给定n个物品集合的所有子集，找出所有可能的子集（总重量不超过背包容量的子集），计算每个子集的总价值，然后在他们中找到价值最大的子集。
所以蛮力法解0/1背包问题的关键是如何求n个物品集合的所有子集，n个物品的子集有2的n次方个，用一个2的n次方行n列的数组保存生成的子集，以下是生成子集的算法：void force(int a[][4])//蛮力法产生4个物品的子集{int i,j;int n=16;int m,t;for(i=0;i<16;i++){ t=i;for(j=3;j>=0;j--){m=t%2;a[i][j]=m;t=t/2;}}for(i=0;i<16;i++)//输出保存子集的二维数组{for(j=0;j<4;j++){printf("%d ",a[i][j]);}printf("\n");}｝以下要依次判断每个子集的可行性，找出可行解:void panduan(int a[][4],int cw[])////判断每个子集的可行性，如果可行则计算其价值存入数组cw,不可行则存入0{int i,j;int sw,sv;for(i=0;i<16;i++){sw=0;sv=0;for(j=0;j<4;j++){sw=sw+wp[j].w*a[i][j];sv=sv+wp[j].v*a[i][j];}if(sw<=c)cw[i]=sv;elsecw[i]=0;}在可行解中找出最优解，即找出可行解中满足目标函数的最优解。
分支界限方法01背包问题解题步骤
分支界限方法是一种用于解决优化问题的算法。
在动态规划算法中，分支界限方法被广泛应用于解决01背包问题。
01背包问题是一个经典的动态规划问题，其解题步骤如下：1. 确定问题：首先需要明确01背包问题的具体描述，即给定一组物品和一个背包，每个物品有自己的价值和重量，要求在不超过背包容量的情况下，选取尽可能多的物品放入背包，使得背包中物品的总价值最大。
2. 列出状态转移方程：对于01背包问题，可以通过列出状态转移方程来描述问题的求解过程。
假设dp[i][j]表示在前i个物品中，背包容量为j时能够获得的最大价值，则状态转移方程可以表示为：dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])3. 初始化边界条件：在动态规划中，需要对状态转移方程进行初始化，一般情况下，dp数组的第一行和第一列需要单独处理。
对于01背包问题，可以初始化dp数组的第一行和第一列为0。
4. 利用分支界限方法优化：针对01背包问题，可以使用分支界限方法来优化动态规划算法的效率。
分支界限方法采用广度优先搜索的思想，在每一步选择最有希望的分支，从而减少搜索空间，提高算法的效率。
5. 实际解题步骤：根据上述步骤，实际解决01背包问题的步骤可以概括为：确定问题，列出状态转移方程，初始化边界条件，利用分支界限方法优化，最终得到问题的最优解。
分支界限方法在解决01背包问题时起到了重要的作用，通过合理的剪枝策略，可以有效地减少动态规划算法的时间复杂度，提高问题的求解效率。
分支界限方法也可以应用于其他优化问题的求解过程中，在算法设计和实现中具有重要的理论和实际意义。
在实际应用中，分支界限方法需要根据具体问题进行灵活选择和调整，结合动态规划和剪枝策略，以便更好地解决各类优化问题。
掌握分支界限方法对于解决复杂问题具有重要的意义，也是算法设计和优化的关键技术之一。
分支界限方法在解决01背包问题的过程中，具有重要的作用。
01背包各种算法代码实现总结（穷举，贪心，动态，递归，回溯，分支限界）
01背包各种算法代码实现总结（穷举，贪⼼，动态，递归，回溯，分⽀限界）2020-05-22所有背包问题实现的例⼦都是下⾯这张图01背包实现之——穷举法：1.我的难点：（1）在⽤穷举法实现代码的时候，我⾃⼰做的时候认为最难的就是怎么将那么多种情况表⽰出来，⼀开开始想⽤for循环进⾏多次嵌套，但是太⿇烦，⽽且还需要不断的进⾏各种标记。
我现在的⽔平实在太菜，然后就在⼀篇中看到⼀个特别巧妙的枚举算法,如下所⽰：int fun(int x[n]){int i;for(i=0;i<n;i++)if(x[i]!=1) {x[i]=1; return;}//从遇到的第⼀位开始，若是0，将其变成1，然后结束for循环，得到⼀种解法else x[i]=0;return;//从第⼀位开始，若是1，将其变成0，然后继续循环，若再循环的时候遇到0，则将其变为1，结束循环。
得到另⼀种解法。
} 虽然我现在也不知道为什么会这样，但是确实是个很好的规律，找到这个规律后，就可以很轻松的⾃⼰写出各种排列情况，以后遇到排列的问题，就⽤这个⽅法。
语⾔不好描述，上图⽚演⽰（是歪的，凑活看吧。
）：（2）算法思想：x[i]的值为0/1，即选或者不选w[i]的值表⽰商品i的重量v[i]的值表⽰商品的价值所以这个算法最核⼼的公式就是tw=x[1]*w[1]+x[2]*w[2]+.......+x[n]*w[n]tv=x[1]*w[1]+x[2]*v[2]+......+x[n]*v[n]tv1:⽤于存储当前最优解limit:背包容量如果 tw<limit&&tv>tv1 则可以找到最优解2.代码实现（借鉴）#include<stdio.h>#include<iostream>using namespace std;#define n 4void possible_solution(int x[n]){int i;for(i=0;i<4;i++) //n=4,有2^4-1种解法if(x[i]!=1){x[i]=1;return; //从遇到的第⼀位开始，若是0，将其变成1，然后结束循环，得到⼀种解法}elsex[i]=0;return;//从第⼀位开始，若是1，将其变成0，然后继续循环，若再循环的时候遇到0，则将其变为1，结束循环。
分支限界法解决01背包问题
分⽀限界法解决01背包问题1. 问题描述设有n个物体和⼀个背包,物体i的重量为wi价值为pi ,背包的载荷为M, 若将物体i（1<= i <=n）装⼊背包,则有价值为pi . ⽬标是找到⼀个⽅案, 使得能放⼊背包的物体总价值最⾼.设N=3, W=(16,15,15), P=(45,25,25), C=30（背包容量）2. 队列式分⽀限界法可以通过画分⽀限界法状态空间树的搜索图来理解具体思想和流程每⼀层按顺序对应⼀个物品放⼊背包（1）还是不放⼊背包（0）步骤：①⽤⼀个队列存储活结点表，初始为空② A为当前扩展结点，其⼉⼦结点B和C均为可⾏结点，将其按从左到右顺序加⼊活结点队列，并舍弃A。
③按FIFO原则，下⼀扩展结点为B，其⼉⼦结点D不可⾏，舍弃；E可⾏，加⼊。
舍弃B④ C为当前扩展结点，⼉⼦结点F、G均为可⾏结点，加⼊活结点表，舍弃C⑤扩展结点E的⼉⼦结点J不可⾏⽽舍弃；K为可⾏的叶结点，是问题的⼀个可⾏解，价值为45⑥当前活结点队列的队⾸为F, ⼉⼦结点L、M为可⾏叶结点，价值为50、25⑦ G为最后⼀个扩展结点，⼉⼦结点N、O均为可⾏叶结点，其价值为25和0⑧活结点队列为空，算法结束，其最优值为50注：活结点就是不可再进⾏扩展的节点，也就是两个⼉⼦还没有全部⽣成的节点3. 优先队列式分⽀限界法3.1 以活结点价值为优先级准则步骤：①⽤⼀个极⼤堆表⽰活结点表的优先队列，其优先级定义为活结点所获得的价值。
初始为空。
②由A开始搜索解空间树，其⼉⼦结点B、C为可⾏结点，加⼊堆中，舍弃A。
③B获得价值45，C为0. B为堆中价值最⼤元素，并成为下⼀扩展结点。
④ B的⼉⼦结点D是不可⾏结点，舍弃。
E是可⾏结点，加⼊到堆中。
舍弃B。
⑤ E的价值为45，是堆中最⼤元素，为当前扩展结点。
⑥ E的⼉⼦J是不可⾏叶结点，舍弃。
K是可⾏叶结点，为问题的⼀个可⾏解价值为45。
⑦继续扩展堆中唯⼀活结点C，直⾄存储活结点的堆为空，算法结束。
蛮力法、动态规划法 求解01背包问题
else
v[i][j]=v[i-1][j];
}
else v[i][j]=v[i-1][j];
}
return v[n][m];
}
int main()
{
int m,n;int i,j;
cout<<"请输入背包的承重量:"<<endl;
2)复杂度分析:2n
2、动态规划法
1)基本思想:Dynamic programming is a technique for solving problems with overlapping subproblems.The function:
V(i,0)=V(0,j)=0;(1)
V(i-1,j)j<w
if (cur_weight <= capacity && cur_value > max_value) {
max_value = cur_value;
}
return;
}
c[d] = 0;
MFKnapsack(capacity, values, weights, c,
d + 1, max_value);
cout << MFKnapsack(capacity, values, weights, n) << endl;
return 0;
}
(2)Dynamic Programming
#include<iostream.h>
#include<string.h>
int v[10][100];//对应每种情况的最大价值
用动态规划法与回溯法实现0-1背包问题的比较
用动态规划法与回溯法实现0-1背包问题的比较用动态规划法与回溯法实现0-1背包问题的比较1背包问题0-1背包问题：给定n种物品和一背包。
物品i的重量是Wi，其价值为Vi，背包的容量为C。
问应如何选择装入背包中物品，使得装入背包中物品的总价值最大？对于一个实例：物品种类N=4，背包容量C=10，物品重量数组W={3，5，2，1}，相应价值数组V={9，10，7，4}。
找一个n 元0-1向量（x1，x2，x3….xn）xi∈{0,1},1≤i≤n.使得，达到最大。
下面分别以动态规划法和回溯法来解决这个实例。
2动态规划法动态规划法的基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
用一个表来保存记录所有已解决的子问题的答案，在需要的时候再找出已求得的答案，避免重复的计算。
动态规划法适用于解最优化问题。
通常可按以下4个步骤：(1)找出最优解的性质并刻画其结构特征。
(2)递归的定义最优解。
(3)以自底向上的方式计算出最优值。
(4)根据计算最优值时到得的信息，构造最优解。
对于所给0-1背包问题的子问题：，的最优值为m（i，j），即m（i，j）是背包容量为j，可悬着物品为i,i+1,….,n时0-1背包问题的最优值。
由于0-1背包问题的最优子结构性质，可以建立计算m（i，j）的如下递归式：（1.1）（1.2）从上面算法的执行过程中可以看出假设有Q（n）个子问题,每一个子问题最多需要m次决策,则计算的频率为nm,回溯的频率为n，那么整个过程的算法的时间复杂度为T（n）=nm+n，即为Q （nm）。
3回溯法。
回溯法在包含问题的所有解的解空间树中,按照深度优先的策略,从根结点出发搜索解空间树。
回溯算法搜索至解空间树的任一结点时,总是先判断该结点是否肯定不包含问题的解。
如果肯定不包含,则跳过对以该结点为根的子树的系统搜索,逐层向其祖先结点回溯。
否则,进入该子树,继续按深度优先的策略进行搜索。
实验项目三 用蛮力法、动态规划法和贪心法求解背包问题
实验项目三 用蛮力法、动态规划法和贪心法求解0/1背包问题实验目的1、学会背包的数据结构的设计，针对不同的问题涉及到的对象的数据结构的设计也不同；2、对0-1背包问题的算法设计策略对比与分析。
实验内容：0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中。
在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi 表示物品i 装入背包的情况，则当xi =0时，表示物品i 没有被装入背包，xi =1时，表示物品i 被装入背包。
根据问题的要求，有如下约束条件和目标函数：于是，问题归结为寻找一个满足约束条件式1，并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。
背包的数据结构的设计：typedef struct object{int n;//物品的编号int w;//物品的重量int v;//物品的价值}wup;wup wp[N];//物品的数组，N 为物品的个数int c;//背包的总重量1、蛮力法蛮力法是一种简单直接的解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。
蛮力法的关键是依次处理所有的元素。
用蛮力法解决0/1背包问题，需要考虑给定n 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包容量的子集），计算每个子集的总价值，然后在他们中找到价值最大的子集。
所以蛮力法解0/1背包问题的关键是如何求n 个物品集合的所有子集，n 个物品的子集有2的n 次方个，用一个2的n 次方行n 列的数组保存生成的子集，以下是生成子集的算法：⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1）∑=ni i i x v 1max （式2）void force(int a[16][4])//蛮力法产生4个物品的子集{int i,j;int n=16;int m,t;for(i=0;i<16;i++){ t=i;for(j=3;j>=0;j--){m=t%2;a[i][j]=m;t=t/2;}}for(i=0;i<16;i++)//输出保存子集的二维数组{for(j=0;j<4;j++){printf("%d ",a[i][j]);}printf("\n");}｝以下要依次判断每个子集的可行性，找出可行解:void panduan(int a[][4],int cw[])////判断每个子集的可行性，如果可行则计算其价值存入数组cw,不可行则存入0{int i,j;int n=16;int sw,sv;for(i=0;i<16;i++){sw=0;sv=0;for(j=0;j<4;j++){sw=sw+wp[j].w*a[i][j];sv=sv+wp[j].v*a[i][j];}if(sw<=c)cw[i]=sv;elsecw[i]=0;}在可行解中找出最优解，即找出可行解中满足目标函数的最优解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
[汇总]蛮力法、动态规划法、回溯法和分支限界法求解01背包问题一、实验内容:分别用蛮力法、动态规划法、回溯法和分支限界法求解0/1背包问题。
C注:0/1背包问题:给定种物品和一个容量为的背包，物品的重量ni是，其价值为，背包问题是如何使选择装入背包内的物品，使得装入背wvii 包中的物品的总价值最大。
其中，每种物品只有全部装入背包或不装入背包两种选择。
二、所用算法的基本思想及复杂度分析:1.蛮力法求解0/1背包问题:1)基本思想:对于有n种可选物品的0/1背包问题，其解空间由长度为n的0-1向量组成,可用子集数表示。
在搜索解空间树时，深度优先遍历，搜索每一个结点，无论是否可能产生最优解，都遍历至叶子结点，记录每次得到的装入总价值，然后记录遍历过的最大价值。
2)代码:#include<iostream>#include<algorithm>using namespace std;#define N 100 //最多可能物体数 struct goods //物品结构体{int sign; //物品序号int w; //物品重量int p; //物品价值}a[N];bool m(goods a,goods b){return (a.p/a.w)>(b.p/b.w); }int max(int a,int b){return a<b?b:a;}int n,C,bestP=0,cp=0,cw=0;int X[N],cx[N];/*蛮力法求解0/1背包问题*/int Force(int i){if(i>n-1){if(bestP<cp&&cw+a[i].w<=C){for (int k=0;k<n;k++) X[k]=cx[k];//存储最优路径bestP=cp;}return bestP;}cw=cw+a[i].w;cp=cp+a[i].p;cx[i]=1; //装入背包Force(i+1);cw=cw-a[i].w;cp=cp-a[i].p;cx[i]=0; //不装入背包Force(i+1);return bestP;}int KnapSack1(int n,goods a[],int C,int x[]) { Force(0);return bestP;}int main(){goods b[N];printf("物品种数n: ");scanf("%d",&n); //输入物品种数printf("背包容量C: ");scanf("%d",&C); //输入背包容量for (int i=0;i<n;i++) //输入物品i的重量w及其价值v {printf("物品%d的重量w[%d]及其价值v[%d]:",i+1,i+1,i+1);scanf("%d%d",&a[i].w,&a[i].p);b[i]=a[i];}int sum1=KnapSack1(n,a,C,X);//调用蛮力法求0/1背包问题printf("蛮力法求解0/1背包问题:\nX=[ ");for(i=0;i<n;i++)cout<<X[i]<<" ";//输出所求X[n]矩阵printf("] 装入总价值%d\n",sum1);bestP=0,cp=0,cw=0;//恢复初始化}3)复杂度分析:n蛮力法求解0/1背包问题的时间复杂度为:。
T(n),O(2)2.动态规划法求解0/1背包问题:1)基本思想:令表示在前个物品中能够装入容量为的V(i,j)i(1,i,n)j(1,j,C)背包中的物品的最大值，则可以得到如下动态函数:V(i,0),V(0,j),0V(i,1,j)(j,w),i V(i,j),,,,VijVijwvjwmax(,1,),(,1,,)，(,)iii, 按照下述方法来划分阶段:第一阶段，只装入前1个物品，确定在各种情况下的背包能够得到的最大价值;第二阶段，只装入前2个物品，确定在各种情况下的背包能够得到的最大价值;以此类推，直到第个n C阶段。
最后，便是在容量为的背包中装入个物品时取得的最nV(n,C) 大价值。
2)代码:#include<iostream>#include<algorithm>using namespace std;#define N 100 //最多可能物体数struct goods //物品结构体{int sign; //物品序号int w; //物品重量int p; //物品价值}a[N];bool m(goods a,goods b){return (a.p/a.w)>(b.p/b.w);}int max(int a,int b){return a<b?b:a;}int n,C,bestP=0,cp=0,cw=0;int X[N],cx[N];int KnapSack2(int n,goods a[],int C,int x[]) {int V[N][10*N];for(int i=0;i<=n;i++) //初始化第0列V[i][0]=0;for(int j=0;j<=C;j++) //初始化第0行V[0][j]=0;for(i=1;i<=n;i++) //计算第i行，进行第i次迭代for(j=1;j<=C;j++)if(j<a[i-1].w)V[i][j]=V[i-1][j];elseV[i][j]=max(V[i-1][j],V[i-1][j-a[i-1].w]+a[i-1].p); j=C; //求装入背包的物品for (i=n;i>0;i--){if (V[i][j]>V[i-1][j]){x[i-1]=1;j=j-a[i-1].w;}else x[i-1]=0;}return V[n][C]; //返回背包取得的最大价值}int main(){goods b[N];printf("物品种数n: ");scanf("%d",&n); //输入物品种数printf("背包容量C: ");scanf("%d",&C); //输入背包容量for (int i=0;i<n;i++) //输入物品i的重量w及其价值v{printf("物品%d的重量w[%d]及其价值v[%d]: ",i+1,i+1,i+1); scanf("%d%d",&a[i].w,&a[i].p);b[i]=a[i];}int sum2=KnapSack2(n,a,C,X);//调用动态规划法求0/1背包问题printf("动态规划法求解0/1背包问题:\nX=[ ");for(i=0;i<n;i++)cout<<X[i]<<" ";//输出所求X[n]矩阵printf("] 装入总价值%d\n",sum2);for (i=0;i<n;i++){a[i]=b[i];}//恢复a[N]顺序}3)复杂度分析:动态规划法求解0/1背包问题的时间复杂度为:。
T(n),O(n，C)3.回溯法求解0/1背包问题:1)基本思想:回溯法:为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。
这种具有限界函数的深度优先生成法称为回溯法。
对于有n种可选物品的0/1背包问题，其解空间由长度为n的0-1可用子集数表示。
在搜索解空间树时，只要其左儿子结点是一向量组成, 个可行结点，搜索就进入左子树。
当右子树中有可能包含最优解时就进入右子树搜索。
2)代码:#include<iostream>#include<algorithm>using namespace std;#define N 100 //最多可能物体数struct goods //物品结构体{int sign; //物品序号int w; //物品重量int p; //物品价值}a[N];bool m(goods a,goods b){return (a.p/a.w)>(b.p/b.w);}int max(int a,int b){return a<b?b:a;}int n,C,bestP=0,cp=0,cw=0;int X[N],cx[N];int BackTrack(int i){if(i>n-1){if(bestP<cp){for (int k=0;k<n;k++) X[k]=cx[k];//存储最优路径bestP=cp;}return bestP;}if(cw+a[i].w<=C){ //进入左子树cw=cw+a[i].w;cp=cp+a[i].p;cx[a[i].sign]=1; //装入背包BackTrack(i+1);cw=cw-a[i].w;cp=cp-a[i].p; //回溯，进入右子树}cx[a[i].sign]=0; //不装入背包BackTrack(i+1);return bestP;}int KnapSack3(int n,goods a[],int C,int x[]) {for(int i=0;i<n;i++){x[i]=0;a[i].sign=i;}sort(a,a+n,m);//将各物品按单位重量价值降序排列BackTrack(0);return bestP;}int main(){goods b[N];printf("物品种数n: ");scanf("%d",&n); //输入物品种数printf("背包容量C: ");scanf("%d",&C); //输入背包容量for (int i=0;i<n;i++) //输入物品i的重量w及其价值v{printf("物品%d的重量w[%d]及其价值v[%d]: ",i+1,i+1,i+1); scanf("%d%d",&a[i].w,&a[i].p);b[i]=a[i];}int sum3=KnapSack3(n,a,C,X);//调用回溯法求0/1背包问题printf("回溯法求解0/1背包问题:\nX=[ ");for(i=0;i<n;i++)cout<<X[i]<<" ";//输出所求X[n]矩阵printf("] 装入总价值%d\n",sum3);for (i=0;i<n;i++){a[i]=b[i];}//恢复a[N]顺序3)复杂度分析:最不理想的情况下，回溯法求解0/1背包问题的时间复杂度为:n。