遗传算法的01背包问题(c语言)
01背包问题回溯法c语言
01背包问题回溯法c语言01背包问题是一个经典的动态规划问题，可以使用回溯法来解决。
在C语言中，我们可以通过递归的方式来实现回溯法解决01背包问题。
首先，让我们来看一下01背包问题的描述：给定n个物品，每个物品有一个重量和一个价值。
现在有一个背包，它能够容纳一定的重量，问如何选择装入背包的物品，使得背包中物品的总价值最大。
接下来，让我们来看一下如何使用回溯法来解决这个问题。
我们可以定义一个递归函数来尝试将每个物品放入背包或者不放入背包，然后找出最优解。
以下是一个简单的C语言代码示例：c.#include <stdio.h>。
#define N 5 // 物品的数量。
#define W 10 // 背包的容量。
int weight[N] = {2, 2, 6, 5, 4}; // 每个物品的重量。
int value[N] = {6, 3, 5, 4, 6}; // 每个物品的价值。
int maxValue = 0; // 最大的总价值。
void backtrack(int index, int currentWeight, int totalValue) {。
if (index == N || currentWeight == W) {。
if (totalValue > maxValue) {。
maxValue = totalValue;}。
return;}。
// 不放入背包。
backtrack(index + 1, currentWeight, totalValue); // 放入背包。
if (currentWeight + weight[index] <= W) {。
backtrack(index + 1, currentWeight +weight[index], totalValue + value[index]);}。
}。
int main() {。
backtrack(0, 0, 0);printf("背包能够容纳的最大总价值为，%d\n", maxValue);return 0;}。
c语言-01背包问题
c语⾔-01背包问题01背包问题问题：有N件物品和⼀个容量为V的背包。
第i件物品的费⽤是c[i]，价值是w[i]。
求解将哪些物品装⼊背包可使价值总和最⼤。
分析：这是最基础的背包问题，特点是：每种物品仅有⼀件，可以选择放或不放。
⽤⼦问题定义状态：即f[i][v]表⽰前i件物品恰放⼊⼀个容量为v的背包可以获得的最⼤价值。
则其状态转移⽅程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}这个⽅程⾮常重要，基本上所有跟背包相关的问题的⽅程都是由它衍⽣出来的。
所以有必要将它详细解释⼀下：“将前i件物品放⼊容量为v的背包中”这个⼦问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为⼀个只牵扯前i-1件物品的问题。
如果不放第i件物品，那么问题就转化为“前i-1件物品放⼊容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放⼊剩下的容量为v-c[i]的背包中”，此时能获得的最⼤价值就是f[i-1][v-c[i]]再加上通过放⼊第i件物品获得的价值w[i]。
优化：以上⽅法的时间和空间复杂度均为O(VN)，其中时间复杂度应该已经不能再优化了，但空间复杂度却可以优化到O。
先考虑上⾯讲的基本思路如何实现，肯定是有⼀个主循环i=1..N，每次算出来⼆维数组f[i][0..V]的所有值。
那么，如果只⽤⼀个数组 f[0..V]，能不能保证第i次循环结束后f[v]中表⽰的就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1] [v-c[i]]两个⼦问题递推⽽来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1] [v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V..0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态 f[i-1][v-c[i]]的值。
遗传算法的01背包问题c语言
遗传算法的01背包问题(c语言)基于遗传算法的0-1背包问题的求解摘要：一、前言组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点，这不仅在于其内在的复杂性有着重要的理论价值，同时也在于它们能在现实生活中广泛的应用。
比如资源分配、投资决策、装载设计、公交车调度等一系列的问题都可以归结到组合优化问题中来。
但是，往往由于问题的计算量远远超出了计算机在有效时间内的计算能力，使问题的求解变为异常的困难。
尤其对于NP完全问题，如何求解其最优解或是近似最优解便成为科学的焦点之一。
遗传算法已经成为组合优化问题的近似最优解的一把钥匙。
它是一种模拟生物进化过程的计算模型，作为一种新的全局优化搜索算法，它以其简单、鲁棒性强、适应并行处理以及应用范围广等特点，奠定了作为21世纪关键智能计算的地位。
背包问题是一个典型的组合优化问题，在计算理论中属于NP-完全问题，其n O(2)，传统上采用动态规划来求解。
设w[i]是经营活动 i 所需计算复杂度为要的资源消耗，M是所能提供的资源总量，p[i]是人们经营活动i得到的利润或收益，则背包问题就是在资源有限的条件下，追求总的最大收益的资源有效分配问题。
二、问题描述背包问题( Knapsack Problem)的一般提法是：已知n个物品的重量（weight）p?00w?，背包的容量（及其价值（或收益profit）分别为contain）假和i i c?0，如何选择哪些物品装入背包可以使得在背包的容量约束限制之设设为i内所装物品的价值最大？该问题的模型可以表示为下述0/1整数规划模型：n?x)x?c,?,xf max(x目标函数：ii12n1?i遗传算法的01背包问题(c语言)?p?wx?s.t iii?（*）1?i?x?{0,1}(i?1,2,?n)?i xx?1x?0时n?则表示不将为0-1决策变量，时表示将物品装入背包中，式中i iii其装入背包中。
三、求解背包问题的一般方法解决背包问题一般是采取动态规划、递归回溯法和贪心方法。
01背包问题c语言代码回溯法
以下是使用C语言实现01背包问题的回溯法代码：```c#include <stdio.h>#include <stdlib.h>// 初始化背包struct knapsack {int maxWeight; // 背包最大承重int *items; // 物品数组int n; // 物品数量};// 定义物品重量、价值和数量int weights[] = {2, 2, 6, 5, 4};int values[] = {6, 3, 5, 4, 6};int quantities[] = {3, 2, 2, 1, 1};// 初始化背包最大承重和当前承重int maxWeight = 10;int currentWeight = 0;// 初始化最大价值为0int maxValue = 0;// 遍历物品数组void traverseItems(struct knapsack *knapsack, int index) { // 对于每个物品，遍历其数量for (int i = 0; i < knapsack->quantities[index]; i++) {// 如果当前物品可以放入背包装且当前承重不超过背包最大承重，计算放入该物品后的总价值，并更新最大价值if (currentWeight + weights[index] <= knapsack->maxWeight) {int currentValue = values[index] * knapsack->quantities[index];if (currentValue > maxValue) {maxValue = currentValue;}}// 回溯，将当前物品从背包装中移除，递归地尝试下一个物品knapsack->quantities[index]--;if (index < knapsack->n - 1) {traverseItems(knapsack, index + 1);}knapsack->quantities[index]++; // 恢复物品数量，以便下次遍历尝试放入其他物品}}// 主函数int main() {// 初始化背包装和物品数组struct knapsack knapsack = {maxWeight, weights, 5};knapsack.items = (int *)malloc(sizeof(int) * knapsack.n);for (int i = 0; i < knapsack.n; i++) {knapsack.items[i] = values[i] * quantities[i]; // 根据价值和数量计算物品价值，并存储在物品数组中}knapsack.n = quantities[4]; // 由于最后一个物品的数量为1，因此只需遍历前n-1个物品即可得到所有可能的结果// 使用回溯法求解01背包问题，返回最大价值traverseItems(&knapsack, 0);printf("The maximum value is %d.\n", maxValue);free(knapsack.items); // 释放内存空间return 0;}```希望以上信息能帮助到你。
c语言算法--贪婪算法---01背包问题
c语言算法--贪婪算法---0/1背包问题在0 / 1背包问题中，需对容量为c 的背包进行装载。
从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。
对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高，即n ?i=1pi xi 取得最大值。
约束条件为n ?i =1wi xi≤c 和xi?[ 0 , 1 ] ( 1≤i≤n)。
在这个表达式中，需求出xt 的值。
xi = 1表示物品i 装入背包中，xi =0 表示物品i 不装入背包。
0 / 1背包问题是一个一般化的货箱装载问题，即每个货箱所获得的价值不同。
货箱装载问题转化为背包问题的形式为：船作为背包，货箱作为可装入背包的物品。
例1-8 在杂货店比赛中你获得了第一名，奖品是一车免费杂货。
店中有n 种不同的货物。
规则规定从每种货物中最多只能拿一件，车子的容量为c，物品i 需占用wi 的空间，价值为pi 。
你的目标是使车中装载的物品价值最大。
当然，所装货物不能超过车的容量，且同一种物品不得拿走多件。
这个问题可仿照0 / 1背包问题进行建模，其中车对应于背包，货物对应于物品。
0 / 1背包问题有好几种贪婪策略，每个贪婪策略都采用多步过程来完成背包的装入。
在每一步过程中利用贪婪准则选择一个物品装入背包。
一种贪婪准则为：从剩余的物品中，选出可以装入背包的价值最大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。
这种策略不能保证得到最优解。
例如，考虑n=2, w=[100,10,10], p =[20,15,15], c = 1 0 5。
当利用价值贪婪准则时，获得的解为x= [ 1 , 0 , 0 ]，这种方案的总价值为2 0。
而最优解为[ 0 , 1 , 1 ]，其总价值为3 0。
另一种方案是重量贪婪准则是：从剩下的物品中选择可装入背包的重量最小的物品。
遗传算法介绍及在01背包问题的应用
遗传算法介绍及在01背包问题的应⽤遗传算法背景：最优化问题确定或⼏乎确定的⽅式寻找充满随机性的启发式⽅法，例如遗传算法遗传算法原理：进化论的物竞天择，适者⽣存基本概念：基因和染⾊体: 基因是不能分割的最⼩单位，染⾊体⼀组基因的组合，实例⽤基因表⽰遗传特征，简单⼀般就是以基因作为遗传特征种群和个体遗传和变异遗传不是平稳的，有⼀定概率变异，可能变好，可能变坏基因交叉，基因突变：变化太频繁⽆法收敛到近似最优解，变化频率太底也不⾏，⽆法保证种群多样性，可能收敛到局部最优解。
选择：根据个体的适应度，按照⼀定规则种群中选择优良个体遗传到下⼀代。
适应度：个体对环境的适应程度。
流程：算法设计：1. 基因的编码： 01背包问题可以采⽤ 01编码2. 适应度评估函数背包问题可以根据基因101001，计算出对应的价值，价值越⼤越好3. 遗传算⼦设计a) 选择算⼦ i. ⽐例选择：⼜称轮盘赌选择，按种群⽐例来确定 ii. 随机竞争选择每次随机选择两个或多个，取适应度⾼的。
iii. 最佳保留选择选择最好的替换最差的，⽽且不参与交叉和变异 iv. 排序选择 v. 确定式采样选择 b) 交叉算⼦ i. 单点交叉随机选择1个点，随机概率交换这个点的⽚段 ii. 两点交叉与多点交叉随机选择两个点或多个点，随机概率交换每个点的⽚段 iii. 均匀交叉⼀致交叉，基因上每个点都按照相同概率互换基因⽚段 iv. 算术交叉⽤于浮点数编码表⽰的基因，线性组合产⽣ c) 变异算⼦ i. 单点变异随机选择⼀个点，随机概率变异 ii. 固定位置变异⼀个或⼏个固定位置，随机变异 iii. 均匀变异每个⽚段，使⽤均匀分布的随机数，以⼩的随机概率进⾏变异 iv. 边界变异如果基因编码规则有边界值（最⼤最⼩），根据规则选⼀个替换成边界值 v. ⾼斯变异4. 运算参数种群⼤⼩M，交叉概率Pc，变异概率Pm，进化迭代次数T01背包问题遗传算法的应⽤：Weight = { 35, 30, 60, 50, 40, 10, 25 }; Value = { 10, 40, 30, 50, 35, 40, 30 };TEST_ROUND = 500; 测试次数OBJ_COUNT = 7;CAPACITY = 150;背包重量POPULATION_SIZE = 32; 种群个数MAX_GENERATIONS = 100;//500; 种群迭代次数P_XOVER = 0.8; 交叉编译概率P_MUTATION = 0.15; 变异概率选择算⼦采⽤轮盘赌策略交叉算⼦：两点交叉，随机个数的基因位进⾏交换（1~7的随机数），交换的位置也是随机等概率选择变异算⼦：对随机个数的基因位进⾏变异每个位置被交换的概率是相等的结果统计正确的次数：success 495github。
遗传算法的0-1背包问题(c语言)
基于遗传算法的0-1背包问题的求解摘要：一、前言组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点，这不仅在于其内在的复杂性有着重要的理论价值，同时也在于它们能在现实生活中广泛的应用。
比如资源分配、投资决策、装载设计、公交车调度等一系列的问题都可以归结到组合优化问题中来。
但是，往往由于问题的计算量远远超出了计算机在有效时间内的计算能力，使问题的求解变为异常的困难。
尤其对于NP 完全问题，如何求解其最优解或是近似最优解便成为科学的焦点之一。
遗传算法已经成为组合优化问题的近似最优解的一把钥匙。
它是一种模拟生物进化过程的计算模型，作为一种新的全局优化搜索算法，它以其简单、鲁棒性强、适应并行处理以及应用范围广等特点，奠定了作为21世纪关键智能计算的地位。
背包问题是一个典型的组合优化问题，在计算理论中属于NP-完全问题， 其计算复杂度为)2(O n ，传统上采用动态规划来求解。
设w[i]是经营活动 i 所需要的资源消耗，M 是所能提供的资源总量，p[i]是人们经营活动i 得到的利润或收益，则背包问题就是在资源有限的条件下， 追求总的最大收益的资源有效分配问题。
二、问题描述背包问题( Knapsack Problem)的一般提法是：已知n 个物品的重量（weight ）及其价值（或收益profit ）分别为0>i w 和0>i p ，背包的容量（contain ）假设设为0>i c ，如何选择哪些物品装入背包可以使得在背包的容量约束限制之内所装物品的价值最大？该问题的模型可以表示为下述0/1整数规划模型：目标函数：∑==ni i i n x c x x x f 121),,(max Λ⎪⎩⎪⎨⎧=∈≤∑=),2,1(}1,0{t .s 1n i x p x w i n i i i i Λ （*）式中i x 为0-1决策变量，1=i x 时表示将物品i 装入背包中，0=i x 时则表示不将其装入背包中。
C语言动态规划之背包问题详解
C语⾔动态规划之背包问题详解01背包问题给定n种物品，和⼀个容量为C的背包，物品i的重量是w[i],其价值为v[i]。
问如何选择装⼊背包的物品，使得装⼊背包中的总价值最⼤？（⾯对每个武平，只能有选择拿取或者不拿两种选择，不能选择装⼊某物品的⼀部分，也不能装⼊物品多次）声明⼀个数组f[n][c]的⼆维数组，f[i][j]表⽰在⾯对第i件物品，且背包容量为j时所能获得的最⼤价值。
根据题⽬要求进⾏打表查找相关的边界和规律根据打表列写相关的状态转移⽅程⽤程序实现状态转移⽅程真题演练：⼀个旅⾏者有⼀个最多能装M公⽄的背包，现在有n件物品，它们的重量分别是W1、W2、W3、W4、…、Wn。
它们的价值分别是C1、C3、C2、…、Cn,求旅⾏者能获得最⼤价值。
输⼊描述：第⼀⾏：两个整数，M（背包容量，M<= 200)和N（物品数量，N<=30);第2…N+1⾏：每⾏两个整数Wi，Ci，表⽰每个物品的质量与价值。
输出描述：仅⼀⾏，⼀个数，表⽰最⼤总价值样例：输⼊：10 42 13 34 57 9输出：12解题步骤定义⼀个数组dp[i][j]表⽰容量为j时，拿第i个物品时所能获取的最⼤价值。
按照题⽬要求进⾏打表，列出对应的dp表。
W[i]（质量）V[i]（价值）01234567891000000000000210011111111133001334444444500135568899790013556991012对于⼀个动态规划问题设置下标时最好从0开始，因为动态规划经常会和上⼀个状态有关系！从上⾯的dp表可以看出来对于⼀个物品我们拿还是不难需要进⾏两步来判断。
第⼀步：判断背包当前的容量j是否⼤于物品当前的质量，如果物品的质量⼤于背包的容量那么就舍弃。
第⼆步：如果背包可以装下这个物品，就需要判断装下该物品获取的最⼤价值是不是⼤于不装下这个物品所获取的最⼤价值，如果⼤于那么就把东西装下！根据这样的思想我们可以得到状态转移⽅程：如果单签背包的容量可以装下物品:dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);如果当前背包的容量装不下该物品:dp[i][j]=dp[i-1][j];#include <stdio.h>int max(const int a,const int b){return a>b ? a:b;}int main(){int w[35]={0},v[35]={0},dp[35][210]={0};int n,m;scanf("%d %d",&m,&n);int i,j;for(i=1;i<=n;i++){scanf("%d %d",&w[i],&v[i]);}for(i=1;i<=n;i++){for(j=1;j<=m;j++){if(j>=w[i])//如果当前背包的容量⼤于商品的质量{dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);//判断是否应该拿下}else//⼤于背包的当前容量{dp[i][j]=dp[i-1][j];}}}for(int k=0;k<=n;k++){for(int l=0;l<=m;l++){printf("%d ",dp[k][l]);}printf("\n");}printf("%d\n",dp[n][m]);}通过运⾏以上程序可以看到最终的输出dp表和我们的预期是相符合的！但是并没有结束，动态规划有⼀个后⽆效性原则(当前状态只与前⼀个状态有关)。
遗传算法求解0-1背包问题(步骤)(精)
遗传算法求解0-1背包问题。
（步骤）#include "iostream.h"#include "iomanip.h"#include "stdlib.h"#include "math.h"#include "time.h"//定义问题的最大规模#define max 100//问题规模，即共有多少个包int packageNum;//每个包的重量int packageWeight[max];//每个包的价值int packageValue[max];//约束，背包的最大容量int limitWeight;//群体的规模int colonySize;//colonyState[i][k] 表示一个染色体//colonyState[1...colonySize][ 0|1 ] 表示一代群体int colonyState[max][2][max];// currAge 表示当前代的编号// (currAge+1)%2 表示下一代的编号int currAge = 0;//个体评价信息表typedef struct tagIndividualMsg{int index;int value;} IndividualMsg;IndividualMsg individualMsg[max];//////////////////////////////////////////////////////////// // 函数声明void printColonyState( int nextAge );//////////////////////////////////////////////////////////// //初始化群体void colonyInit(){int i , j;int w;for( i = 0 ; i < colonySize ; i++ ){//保证找到一个符合约束的染色体w = limitWeight + 1;while( w > limitWeight ){w = 0;for( j = 0 ; j < packageNum && w <= limitWeight ; j++ ){colonyState[i][currAge][j] = rand() % 2;w += packageWeight[j] * colonyState[i][currAge][j];}}}}//对个体进行评价int cmp( const void *a , const void *b ){IndividualMsg *x = (IndividualMsg *)a;IndividualMsg *y = (IndividualMsg *)b;return y->value - x->value;}void individualEstimate(){int i , j;for( i = 0 ; i < colonySize ; i++ ){individualMsg[i].index = i;individualMsg[i].value = 0;for( j = 0 ; j < packageNum ; j++ )individualMsg[i].value += packageValue[j] * colonyState[i][currAge][j]; }qsort( individualMsg , colonySize , sizeof(IndividualMsg) , cmp );}//终止循环的条件bool stopFlag(){//进行n 代进行后停止static int n = 50;if( n-- <= 0 )return true;elsereturn false;}//赌轮选择int gambleChoose(){int wheel[max] = { 0 };int i = colonySize - 1;int choose;wheel[i] = individualMsg[i].value;for( i-- ; i >= 0 ; i-- )wheel[i] = ( individualMsg[i].value + wheel[i+1] ) + colonySize * ( colonySize - i ); int seed = abs( wheel[0] - ( rand() % ( 2 * wheel[0] ) + 1 ) );choose = colonySize - 1;while( seed > wheel[choose] )choose--;// cout<<"----------------------------------------"<<endl;// cout<<"wheel :"<<endl;// for( i = 0 ; i < colonySize ; i++ )// cout<<setw(5)<<wheel[i];// cout<<endl;// cout<<"seed = "<<seed<<endl;// cout<<"choose "<<choose<<endl;return choose;}//交叉void across( int male , int female , int index ){int nextAge = (currAge+1)%2;int i , j , t;int acrossBit = rand() % (packageNum-1) + 1;for( j = 0 ; j < packageNum ; j++ ){colonyState[index][nextAge][j] =colonyState[individualMsg[male].index][currAge][j];colonyState[index+1][nextAge][j] =colonyState[individualMsg[female].index][currAge][j];}for( i = 0 ; i < acrossBit ; i++ ){t = colonyState[index][nextAge][i];colonyState[index][nextAge][i] = colonyState[index+1][nextAge][i];colonyState[index+1][nextAge][j] = t;}}//变异void aberrance( int index ){int seed , nextAge;nextAge = (currAge+1)%2;//只有1/3 的概率发生异变seed = rand() % ( packageNum * 3 );if( seed < packageNum )colonyState[index][nextAge][seed] = ( colonyState[index][nextAge][seed] + 1 ) % 2;}//处理死亡个体void dealDeath(){int i , j;int weight , w;int nextAge = (currAge+1)%2;for( i = 0 ; i < colonySize ; i++ ){weight = 0;for( j = 0 ; j < packageNum ; j++ )weight += packageWeight[j] * colonyState[i][nextAge][j];if( weight > limitWeight ){//随机生成新的个体w = limitWeight + 1;while( w > limitWeight ){w = 0;for( j = 0 ; j < packageNum && w <= limitWeight ; j++ ){colonyState[i][nextAge][j] = rand() % 2;w += packageWeight[j] * colonyState[i][nextAge][j];}}}}printColonyState( nextAge );}//最优个体保护void saveBest(){int i , j;int min , minp , value;int nextAge = ( currAge+1)%2;min = individualMsg[0].value;minp = -1;for( i = 0 ; i < colonySize ; i++ ){value = 0;for( j = 0 ; j < packageNum ; j++ )value += packageValue[j] * colonyState[i][nextAge][j]; if( value <= min ){min = value;minp = i;}}if( minp >= 0 ){for( j = 0 ; j < packageNum ; j++ ){colonyState[minp][nextAge][j] =colonyState[individualMsg[0].index][currAge][j];}}}//////////////////////////////////////////////////////////// void setProblem(){int i;packageNum = 5;int w[] = { 5 , 4 , 3 , 2 , 1 };int v[] = { 8 , 9 , 3 , 1 , 2 };for( i = 0 ; i < packageNum ; i++ ){packageWeight[i] = w[i];packageValue[i] = v[i];}limitWeight = 13;colonySize = 5;}void printProblem(){int i;cout<<"----------------------------------------"<<endl;cout<<"problem state:"<<endl;cout<<"packageNum = "<<packageNum<<endl;cout<<"limitWeight = "<<limitWeight<<endl;cout<<"Weight: ";for( i = 0 ; i < packageNum ; i++ )cout<<setw(3)<<packageWeight[i];cout<<endl;cout<<"Value: ";for( i = 0 ; i < packageNum ; i++ )cout<<setw(3)<<packageValue[i];cout<<endl;}void printColonyState( int k ){cout<<"----------------------------------------"<<endl;cout<<"colonyState-->";if( k == currAge )cout<<"currAge:"<<endl;elsecout<<"next age:"<<endl;int i , j;for( i = 0 ; i < colonySize ; i++ ){for( j = 0 ; j < packageNum ; j++ )cout<<setw(2)<<colonyState[i][k][j];cout<<endl;}}void printIndividualMsg(){int i;cout<<"----------------------------------------"<<endl;cout<<"Individual Msg:"<<endl;for( i = 0 ; i < colonySize ; i++ ){cout<<individualMsg[i].index<<"\t"<<individualMsg[i].value<<endl; }}////////////////////////////////////////////////////////////void main(){srand( (unsigned int)time(NULL) );setProblem();printProblem();//初始群体colonyInit();printColonyState( currAge );while( !stopFlag() ){//评价当前群体individualEstimate();//生成下一代for( int i = 0 ; i < colonySize ; i += 2 ){int male = gambleChoose();int female = gambleChoose();across( male , female , i );aberrance( i );aberrance( i + 1 );}//处理死亡个体dealDeath();//最优个体保护saveBest();//现在的下一代变成下一轮的当前代currAge = ( currAge + 1 ) % 2;//printColonyState( currAge );}//输出问题解individualEstimate();cout<<"近似解:"<<endl;int j , w = 0;cout<<setw(10)<<"Value:";for( j = 0 ; j < packageNum ; j++ )cout<<setw(5)<<packageValue[j];cout<<endl;cout<<setw(10)<<"Weight:";for( j = 0 ; j < packageNum ; j++ ){w += packageWeight[j] * colonyState[individualMsg[0].index][currAge][j]; cout<<setw(5)<<packageWeight[j];}cout<<endl;cout<<setw(10)<<"Choose:";for( j = 0 ; j < packageNum ; j++ )cout<<setw(5)<<colonyState[individualMsg[0].index][currAge][j];cout<<endl;cout<<"limitWeight: "<<limitWeight<<endl;cout<<"总重量: "<<w<<endl;cout<<"总价值: "<<individualMsg[0].value<<endl; }////////////////////////////////////////////////////////////。
0-1背包问题c语言实现
0-1背包问题c语言实现问题描述:给定n种物品和一个背包。
物品i的重量为w[i]，其价值为v[i]，背包的容量为c。
应如何选择装入背包的物品，使得装入背包中的物品的总价值最大。
每种物品最多装入一次。
0-1背包问题：对于要装入背包中的物品，只有两种选择：全部装入或者不装入。
背包问题：对于要装入背包中的物品，可以选择装入一部分，不一定要全部装入背包中。
算法分析：使用贪心策略求解此类问题时，首先要选出最优的度量标准。
可供选择的度量标准有三种：价值，容量，单位价值（v/w，价值/重量）。
显然，价值高的物品容量可能太大，容量大的物品价值也可能很低。
最优的度量标准是单位价值。
背包问题算法思路：1、将各个物品按照单位价值由高到低排序；2、取价值最高者放入背包；3、计算背包的剩余空间；4、重复2-3步，直到背包剩余容量=0或者物品全部装入背包为止（对于0-1背包，终止条件为背包剩余容量无法装入任意一件物品或者物品全部装入背包）。
下面是C语言实现（DEV c++4.9.9.2运行通过）[cpp]#includevoid package(int n,float c,float v[],float w[],float x[]); void package0_1(int n,float c,float v[],float w[],float x[]);int main(void){int n = 3;float c = 20;float v[] = {24,15,25};float w[] = {15,10,18};//已经按照单位价值降序排列float *x;x = (float*)malloc(sizeof(float)*n);printf("******背包*******\n");package(n,c,v,w,x);printf("*******0-1背包******\n");package0_1(n,c,v,w,x);system("PAUSE");}/** 背包问题* n:物品个数* c：背包容量* v[]:每个物品的价值* w[]:每个物品的重量（这里已经按照单位价值降序排列）* x[]:物品是否放入背包（0表示不放，1表示全部放入，0-1放入一部分）*/void package(int n,float c,float v[],float w[],float x[]){int i;for(i=0;i{x[i] = 0;//初始状态，所有物品都没有被放入背包}for(i=0;i{if(w[i] > c){break;}x[i] = 1;c = c - w[i];printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);}if(i<=n)//还可以放入一个物品的一部分{x[i] = c/w[i];printf("放入第%d件物品的%f部分.背包剩余容量为0.\n",(i+1),w[i]*x[i]);}}/** 0-1背包问题* n:物品个数* c：背包容量* v[]:每个物品的价值* w[]:每个物品的重量（这里已经按照单位价值降序排列）* x[]:物品是否放入背包（0表示不放，1表示全部放入）*/void package0_1(int n,float c,float v[],float w[],float x[]) {int i;for(i=0;i{x[i] = 0;//初始状态，所有物品都没有被放入背包}for(i=0;i{if(w[i] > c){break;}x[i] = 1;c = c - w[i];printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c); }}#includevoid package(int n,float c,float v[],float w[],float x[]); void package0_1(int n,float c,float v[],float w[],float x[]);int main(void){int n = 3;float c = 20;float v[] = {24,15,25};float w[] = {15,10,18};//已经按照单位价值降序排列float *x;x = (float*)malloc(sizeof(float)*n);printf("******背包*******\n");package(n,c,v,w,x);printf("*******0-1背包******\n");package0_1(n,c,v,w,x);system("PAUSE");}/** 背包问题* n:物品个数* c：背包容量* v[]:每个物品的价值* w[]:每个物品的重量（这里已经按照单位价值降序排列）* x[]:物品是否放入背包（0表示不放，1表示全部放入，0-1放入一部分）*/void package(int n,float c,float v[],float w[],float x[]){int i;for(i=0;i<n;i++){x[i] = 0;//初始状态，所有物品都没有被放入背包}for(i=0;i<n;i++){if(w[i] > c){break;}x[i] = 1;c = c - w[i];printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);}if(i<=n)//还可以放入一个物品的一部分{x[i] = c/w[i];printf("放入第%d件物品的%f部分.背包剩余容量为0.\n",(i+1),w[i]*x[i]);}}/** 0-1背包问题* n:物品个数* c：背包容量* v[]:每个物品的价值* w[]:每个物品的重量（这里已经按照单位价值降序排列）* x[]:物品是否放入背包（0表示不放，1表示全部放入）*/void package0_1(int n,float c,float v[],float w[],float x[]){int i;for(i=0;i<n;i++){x[i] = 0;//初始状态，所有物品都没有被放入背包}for(i=0;i<n;i++){if(w[i] > c){break;}x[i] = 1;c = c - w[i];printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);}}虽然背包问题和0-1背包都具有最优子结构性质，但是背包问题用贪心算法求出来的是最优解，0-1背包问题通过贪心算法得不到最优解，因为无法保证最后能将背包装满，部分闲置的背包空间使总价值降低了。
遗传算法的01背包问题(c语言)
基于遗传算法的0-1背包问题的求解摘要：一、前言组合优化问题的求解方法研究已经成为了当前众多科学关注的焦点，这不仅在于其内在的复杂性有着重要的理论价值，同时也在于它们能在现实生活中广泛的应用。
比如资源分配、投资决策、装载设计、公交车调度等一系列的问题都可以归结到组合优化问题中来。
但是，往往由于问题的计算量远远超出了计算机在有效时间内的计算能力，使问题的求解变为异常的困难。
尤其对于NP 完全问题，如何求解其最优解或是近似最优解便成为科学的焦点之一。
遗传算法已经成为组合优化问题的近似最优解的一把钥匙。
它是一种模拟生物进化过程的计算模型，作为一种新的全局优化搜索算法，它以其简单、鲁棒性强、适应并行处理以及应用范围广等特点，奠定了作为21世纪关键智能计算的地位。
背包问题是一个典型的组合优化问题，在计算理论中属于NP-完全问题， 其计算复杂度为)2(O n ，传统上采用动态规划来求解。
设w[i]是经营活动 i 所需要的资源消耗，M 是所能提供的资源总量，p[i]是人们经营活动i 得到的利润或收益，则背包问题就是在资源有限的条件下， 追求总的最大收益的资源有效分配问题。
二、问题描述背包问题( Knapsack Problem)的一般提法是：已知n 个物品的重量（weight ）及其价值（或收益profit ）分别为0>i w 和0>i p ，背包的容量（contain ）假设设为0>i c ，如何选择哪些物品装入背包可以使得在背包的容量约束限制之内所装物品的价值最大？该问题的模型可以表示为下述0/1整数规划模型：目标函数：∑==ni i i n x c x x x f 121),,(max Λ⎪⎩⎪⎨⎧=∈≤∑=),2,1(}1,0{t .s 1n i x p x w i n i i i i Λ （*） 式中i x 为0-1决策变量，1=i x 时表示将物品i 装入背包中，0=i x 时则表示不将其装入背包中。
遗传算法的0-1背包问题(c语言)
基于遗传算法得0—1背包问题得求解摘要:一、前言组合优化问题得求解方法研究已经成为了当前众多科学关注得焦点,这不仅在于其内在得复杂性有着重要得理论价值,同时也在于它们能在现实生活中广泛得应用。
比如资源分配、投资决策、装载设计、公交车调度等一系列得问题都可以归结到组合优化问题中来、但就是,往往由于问题得计算量远远超出了计算机在有效时间内得计算能力,使问题得求解变为异常得困难。
尤其对于NＰ完全问题,如何求解其最优解或就是近似最优解便成为科学得焦点之一、遗传算法已经成为组合优化问题得近似最优解得一把钥匙。
它就是一种模拟生物进化过程得计算模型,作为一种新得全局优化搜索算法,它以其简单、鲁棒性强、适应并行处理以及应用范围广等特点,奠定了作为２１世纪关键智能计算得地位。
背包问题就是一个典型得组合优化问题,在计算理论中属于ＮP-完全问题,其计算复杂度为,传统上采用动态规划来求解。
设w[i］就是经营活动i 所需要得资源消耗,M就是所能提供得资源总量,p[i]就是人们经营活动ｉ得到得利润或收益,则背包问题就就是在资源有限得条件下,追求总得最大收益得资源有效分配问题。
二、问题描述背包问题( Kｎaｐsack Problem)得一般提法就是:已知ｎ个物品得重量(wei ｇht)及其价值(或收益profｉｔ)分别为与,背包得容量(contａin)假设设为,如何选择哪些物品装入背包可以使得在背包得容量约束限制之内所装物品得价值最大?该问题得模型可以表示为下述0/1整数规划模型:目标函数:(*)式中为０－１决策变量,时表示将物品装入背包中,时则表示不将其装入背包中。
三、求解背包问题得一般方法解决背包问题一般就是采取动态规划、递归回溯法与贪心方法、动态规划可以把困难得多阶段决策变换为一系列相互联系比较容易得单阶段问题、对于背包问题可以对子过程用枚举法求解,而且约束条件越多,决策得搜索范围越小,求解也越容易。
它得主要缺点就是用数值方法求解时会随着状态变量得个数呈指数级得增长,往往对于求解背包问题得实际问题就是不现实得。
遗传算法求解01背包问题
遗传算法求解01背包问题一、问题描述01背包问题属于组合优化问题的一个例子，求解01背包问题的过程可以被视作在很多可行解当中求解一个最优解。
01背包问题的一般描述如下：给定n个物品和一个背包，物品i的重量为W i，其价值为V i，背包的容量为C。
选择合适的物品装入背包，使得背包中装入的物品的总价值最大。
注意的一点是，背包内的物品的重量之和不能大于背包的容量C。
在选择装入背包的物品时，对每种物品i只有两种选择：装入背包或者不装入背包，即只能将物品i装入背包一次。
称此类问题为0/1背包问题。
01背包问题是NP问题，传统的解决方法有动态规划法、分支界限法、回溯法等等。
传统的方法不能有效地解决01背包问题。
遗传算法（Genetic Algorithms）则是一种适合于在大量的可行解中搜索最优（或次优）解的有效算法。
二、遗传算法1、遗传算法的基本思想遗传算法的搜索从一个被称作种群的候选解集开始，新的种群由旧的种群中产生以期得到更好的种群。
从旧种群中按照解的适应度来选择解以产生新的解；适应度越大，解被选择生成后代的机率也越大。
这个从已有种群中选择双亲并产生后代的迭代过程持续到遗传算法的停止条件满足为止。
2、遗传算法的基本元素。
遗传算法由以下几个原素组成：由染色体组成的种群，根据适应度进行选择以及交叉产生后代。
三、用遗传算法求解01背包问题1、01背包问题中染色体的表示。
用向量X来表示染色体，X = ｛x1，x2，……，x n｝。
，x i∈｛0,1｝，x i=1表示物品i装入了背包，x i =0表示物品i未装入背包。
每个染色体对应其当前装入背包的物品的总价值和总重量。
背包中物品的中价值代表了该物品的适应度。
程序中定义了这样的一个结构来表示染色体：typedef struct{int Weight; //染色体代表的物品的总重量int Fitness; //染色体代表的物品的价值（适应度）int Gene[NUMG]; //用元素取值于定义域｛0,1｝的数组表示染色体。
分支限界法 01背包问题c语言
分支限界法 01背包问题c语言分支限界法是一种解决组合优化问题的算法。
其中，01背包问题是一种经典的背包问题，它要求在给定的容量下，选择商品的组合，使得组合的总价值达到最大化，但组合中每种商品只能选择一次。
C语言是一种广泛使用的编程语言，适用于实现各种算法和数据结构。
下面我将用C语言实现分支限界法来解决01背包问题。
首先，我们定义一个结构体用来表示商品的信息，包括商品的重量和价值：```typedef struct {int weight;int value;} Item;```接下来，我们定义一个递归函数来实现分支限界法。
该函数通过深度优先搜索的方式，尝试不同的选择，并计算当前组合的总价值。
如果当前组合的总价值已经超过了已知的最优解，则剪枝，不再继续搜索。
```void branchAndBound(int index, int capacity, int currentWeight, int currentValue, int n, Item items[], int bestValue, int choice[]) {if (index >= n || currentWeight >= capacity) {if (currentValue > bestValue) {bestValue = currentValue;// 更新最优解for (int i = 0; i < n; i++) {choice[i] = tempChoice[i];}}return;}// 选择当前商品if (currentWeight + items[index].weight <= capacity) {currentWeight += items[index].weight;currentValue += items[index].value;tempChoice[index] = 1;branchAndBound(index + 1, capacity, currentWeight, currentValue, n, items, bestValue, choice);currentWeight -= items[index].weight;currentValue -= items[index].value;tempChoice[index] = 0;}// 不选择当前商品branchAndBound(index + 1, capacity, currentWeight, currentValue, n, items, bestValue, choice);}最后，我们可以在主函数中调用分支限界法来解决01背包问题。
01背包问题回溯法c语言
01背包问题回溯法c语言背包问题是一个很经典的动态规划问题，其中最常见的一种形式就是 01 背包问题。
在该问题中，给定一组物品的重量和价值，以及一个背包的容量限制，要求选择一些物品，使得在不超过背包容量的前提下，背包中物品的总价值最大。
这里我们将讨论如何使用回溯法解决01 背包问题，使用C 语言进行编程实现。
首先，我们需要定义问题的数据结构。
我们可以使用一个数组来表示不同物品的重量和价值，背包的容量可以通过一个常量来表示。
```c#define N 5 // 物品的个数#define MAX_WEIGHT 10 // 背包的容量int weights[N] = {2, 3, 4, 5, 9}; // 物品的重量int values[N] = {3, 4, 5, 8, 10}; // 物品的价值int bestValue = 0; // 最优解的价值int bestSelection[N]; // 最优解中物品的选择情况```接下来，我们可以定义一个递归函数来实现回溯法。
该函数将遍历所有可能的物品选择情况，并更新当前的最优解。
```cvoid backtrack(int depth, int weight, int value, int selection[]) {if (depth == N) {if (weight <= MAX_WEIGHT && value > bestValue) {bestValue = value;for (int i = 0; i < N; i++) {bestSelection[i] = selection[i];}}return;}// 不选择当前物品selection[depth] = 0;backtrack(depth + 1, weight, value, selection);// 选择当前物品selection[depth] = 1;backtrack(depth + 1, weight + weights[depth], value + values[depth], selection); }```最后，我们可以在主函数中调用回溯函数，得到最优解。
(精品)遗传算法求解背包问题
遗传算法的过程：初始化：将计划装入背包的每个物品看成一个二进制串的一位，为1表示放入该物品，为0表示不放入该物品。
初始种群的产生：初始化前对放入背包物品数的一个预测（背包容积/物品最大体积），接下来只要在种群每条染色体中保证有（背包容积/物品最大体积）个为1的位初始化就完成了。
选择：选择进行杂交的父代染色体，被选中的父代染色体总是若干个染色体中最优（适应度最高）的，来保证向优化的方向发展。
详细的选择方法：随机产生2个数：Chrom_Cross_From, Chrom_Cross_To,当然得采用一定的手段来保证前者比后者小。
从Chrom_Cross_From到Chrom_Cross_To这Chrom_Cross_To-Chrom_Cross_From+1条染色体中选择最优（适应度最大）的染色体作为父代之一。
需要进行两次选择得到杂交的两条父代染色体。
这样做可以保证算法不会过早收敛。
函数实现：Individual Select(int ChromSize,Individual Pop[]){int Num_Selected,i,j,Chrom_Selected_From,Chrom_Selected_To,temp;Individual *Chrom_Selected;do{Chrom_Selected_From=rand()%PopSize;Chrom_Selected_To=rand()%PopSize;if(Chrom_Selected_From>Chrom_Selected_To){temp=Chrom_Selected_From;Chrom_Selected_From=Chrom_Selected_To;Chrom_Selected_To=temp;}Num_Selected=Chrom_Selected_To-Chrom_Selected_From+1;}while(Num_Selected<=0);Chrom_Selected=new Individual[Num_Selected];for(i=0;i<Num_Selected;i++)Chrom_Selected[i].chrom=new int[ChromSize];for(i=0,j=Chrom_Selected_From;i<Num_Selected,j<Chrom_Selected_To+1;i++,j++){Chrom_Selected[i]=Pop[j];}Order_Best_First(ChromSize,Num_Selected,Chrom_Selected);Chrom_Selected[0].fitness=Fitness(Chrom_Selected[0].chrom,ChromSize);return Chrom_Selected[0];}杂交：将两次选择得到的父代染色体进行杂交得到一条新的染色体，作为较新种群（并非新的种群）的一条染色体，杂交直到较新种群的染色体数等于原种群的染色体数。
实现遗传算法的0-1背包问题【精品毕业设计】(完整版)
实现遗传算法的0-1背包问题求解及其改进学校：学院：专业：姓名：学号：课程名称：指导老师：一、 问题陈述0-1背包问题属于组合优化问题的一个例子，求解0-1背包问题的过程可以被视作在很多可行解当中求解一个最优解。
01背包问题的一般描述如下：给定n 个物品和一个背包，物品i 的重量为Wi ，其价值为Vi ，背包的容量为C 。
选择合适的物品装入背包，使得背包中装入的物品的总价值最大。
注意的一点是，背包内的物品的重量之和不能大于背包的容量C 。
在选择装入背包的物品时，对每种物品i 只有两种选择：装入背包或者不装入背包，即只能将物品i 装入背包一次。
称此类问题为0/1背包问题。
其数学模型为：在满足∑w i x i ≤C n i=1的条件下求解 max ∑v i x i n i=1 ，其中i =1,2,3,4…,n0-1背包问题传统的解决方法有动态规划法、分支界限法、回溯法等等。
传统的方法不能有效地解决0-1背包问题。
遗传算法（Genetic Algorithms ）则是一种适合于在大量的可行解中搜索最优（或次优）解的有效算法。
二、遗传算法分析与实现1、遗传算法概述遗传算法（Genetic Algorithm ）是一类借鉴生物界的进化规律（适者生存，优胜劣汰）演化而来的随机化搜索方法。
算法根据问题的目标函数构造一个适值函数，对一个由多个解（每个解对应一个染色体）构成的和种群进行评估、遗传、选择，经多代繁殖，获得适应值最好的个体作为问题的最优解。
其特点是具有内在的隐并行性和更好的全局寻优能力；采用概率化的寻优方法，能自动获取和指导优化的搜索空间，自适应地调整搜索方向，不需要确定的规则。
遗传算法的这些性质，已被人们广泛地应用于组合优化、机器学习、信号处理、自适应控制和人工生命等领域。
• 遗传算法一般是直接在解空间搜索, 而不像图搜索那样一般是在问题空间搜索, 最后才找到解(如果搜索成功的话)。
• 遗传算法的搜索随机地始于搜索空间的一个点集, 而不像图搜索那样固定地始于搜索空间的初始节点或终止节点, 所以遗传算法是一种随机搜索算法。
“遗传算法”解决“背包问题”
“遗传算法”解决“背包问题”遗传算法基本思想：1) ⼀个种群有多个个体，每个个体有染⾊体和对应的基因为了繁殖进⾏：2) 选择：在残酷的世界中，适者⽣存，优胜略汰。
3) 重组：染⾊体交叉，基因重组4) 突变：染⾊体上的基因⼩概率的突变（⼀般给⼩数点后两位）背包问题：背包只能容得下⼀定重量b的物品，物品有m种，每种物品有⾃⼰的重量w(i)和价值v(i)（0<i<=m），从这些物品中选择装⼊背包，是背包不超过重量b，但价值⼜要最⼤。
运⽤动态规划，分⽀限界都可以达到效果，但不佳。
我⽤遗传算法解决：⼀般⼈有多条染⾊体，但对于背包问题，⼀个解我们将看成⼀个个体，所以，⼀个个体只有⼀个染⾊体，⼀个染⾊体对应多个基因。
如：100101010100111 表⽰装⼊背包的可能解。
（具体情况具体分析）遗传所做准备：1) ⽤0表⽰“不选择装⼊”，1表⽰“装⼊”，形成⼀条基因链；100101010100111则表⽰“15种物品”装⼊或不装⼊背包的可能解。
------- 此处⽤chrom[]存放基因，代表染⾊体2) ⼀个基因对应⼀个个体。
------- 此处⽤Population类或结构体声明其含有chrom[]等信息3) 可能的解有很多，构成⼀个种群。
------- ⽤Population类定义⼀个数组代表个体构成的种群newPop[]：存放新⽣代，oldPop[]：存放上⼀代4) 适应度：适应度和⽬标函数是正相关的，所以需要物品价值和重量。
------- fitness,weight包含在Population类中最⼤适应度：maxFitness,最⼩适应度：minFitness,总适应度：sumFitness,(帮助求突变和交叉的染⾊体)平均适应度：avgFitness遗传算法的函数：基本：1) InitPop() 初始化个体，使每个个体都有基因组2) Statistics(*pop) 计算适应度（最⼤，最⼩，总的，平均的）3) Selection(*pop) 通过选择种群中符合要求的⽗母去繁殖新代，返回这对⽗母的位置4) crossover(*parent1,*parent2,pos) 传⼊要改的个体位置，随机产⽣交叉位置，⽤优良⽗母繁殖优良后代并替代传⼊个体位置5) mutation(i) i为基因组基因的位置，逐个基因看是否要变异6) generation() 对个体进⾏判断，若不符合要求，进⾏选择，重组，突变。
分支界线法01背包问题c语言
分支界线法01背包问题c语言一、问题描述01背包问题是常见的动态规划问题，其描述如下：有一个背包，最多能承载重量为W的物品。
现在有n个物品，其重量分别为w1, w2, ..., wn，价值分别为v1, v2, ..., vn。
要求选取若干物品放入背包，使得放入背包的物品总价值最大，且总重量不超过W。
二、分支界线法思想分支界线法是一种求解组合优化问题的常用方法。
在01背包问题中，分支界线法的思想是通过一个优先级队列，不断生成和扩展状态空间树，记录每个节点的上界评价函数值，并根据上界值进行搜索剪枝，直至获得最优解。
三、算法步骤1. 定义物品结构体```ctypedef struct {double value; // 物品价值double weight; // 物品重量double unitValue; // 物品单位价值} Item;```2. 比较函数定义（用于优先级队列）```cintpare(const void* a, const void* b) {Item* itemA = (Item*)a;Item* itemB = (Item*)b;double diff = itemB->unitValue - itemA->unitValue; return diff < 0 ? -1 : diff > 0 ? 1 : 0;}```3. 分支界线法求解01背包问题```cdouble knapsack(int n, double W, Item* items) {qsort(items, n, sizeof(Item),pare);double maxValue = 0;double currentWeight = 0;for (int i = 0; i < n; i++) {if (currentWeight + items[i].weight <= W) {currentWeight += items[i].weight;maxValue += items[i].value;} else {double rem本人nWeight = W - currentWeight;maxValue += items[i].unitValue * rem本人nWeight;break;}}return maxValue;}```四、代码实现解释1. 首先根据物品单位价值对物品进行排序，通过单位价值可以快速确定选择哪个物品放入背包；2. 依次选择单位价值最高的物品放入背包，若背包容量不足则按部分放入；3. 根据剩余容量，估算能够放入的最大价值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
基于遗传算法得0-1背包问题得求解摘要:一、前言组合优化问题得求解方法研究已经成为了当前众多科学关注得焦点,这不仅在于其内在得复杂性有着重要得理论价值,同时也在于它们能在现实生活中广泛得应用。
比如资源分配、投资决策、装载设计、公交车调度等一系列得问题都可以归结到组合优化问题中来。
但就是,往往由于问题得计算量远远超出了计算机在有效时间内得计算能力,使问题得求解变为异常得困难。
尤其对于NP 完全问题,如何求解其最优解或就是近似最优解便成为科学得焦点之一。
遗传算法已经成为组合优化问题得近似最优解得一把钥匙。
它就是一种模拟生物进化过程得计算模型,作为一种新得全局优化搜索算法,它以其简单、鲁棒性强、适应并行处理以及应用范围广等特点,奠定了作为21世纪关键智能计算得地位。
背包问题就是一个典型得组合优化问题,在计算理论中属于NP-完全问题,其计算复杂度为)2(O n ,传统上采用动态规划来求解。
设w[i]就是经营活动 i 所需要得资源消耗,M 就是所能提供得资源总量,p[i]就是人们经营活动i 得到得利润或收益,则背包问题就就是在资源有限得条件下, 追求总得最大收益得资源有效分配问题。
二、问题描述背包问题( Knapsack Problem)得一般提法就是:已知n 个物品得重量(weight)及其价值(或收益profit)分别为0>i w 与0>i p ,背包得容量(contain)假设设为0>i c ,如何选择哪些物品装入背包可以使得在背包得容量约束限制之内所装物品得价值最大？该问题得模型可以表示为下述0/1整数规划模型:目标函数:∑==ni i i n x c x x x f 121),,(max⎪⎩⎪⎨⎧=∈≤∑=),2,1(}1,0{t .s 1n i x p x w i n i i i i (*) 式中i x 为0-1决策变量,1=i x 时表示将物品i 装入背包中,0=i x 时则表示不将其装入背包中。
三、求解背包问题得一般方法解决背包问题一般就是采取动态规划、递归回溯法与贪心方法。
动态规划可以把困难得多阶段决策变换为一系列相互联系比较容易得单阶段问题。
对于背包问题可以对子过程用枚举法求解,而且约束条件越多,决策得搜索范围越小,求解也越容易。
它得主要缺点就是用数值方法求解时会随着状态变量得个数呈指数级得增长,往往对于求解背包问题得实际问题就是不现实得。
使用递归回溯法解决背包问题得优点在于它算法思想简单, 而且它能完全遍历搜索空间,肯定能找到问题得最优解;但就是由于此问题解得总组合数有n 2个,因此,随着物件数 n 得增大,其解得空间将以n2级增长,当 n 大到一定程度上,用此算法解决背包问题将就是不现实得。
使用贪心方法求解时计算得复杂度降低了很多,但就是往往难以得到最优解,有时所得解与最优解相差甚远。
因此, 我们可以探索使用遗传算法解决物件数较大得背包问题。
四、遗传算法简介遗传算法( Genetic Algorithms,GA) 就是在1975 年首次由美国密西根大学得D 。
J 。
Holland 教授与她得同事们借鉴生物界达尔文得自然选择法则与孟德尔得遗传进化机制基础之上提出得。
经过近30年得研究、应用,遗传算法已被广泛地应用于函数优化、机器人系统、神经网络学习过程、模式识别、图象处理、工业优化控制等领域。
遗传算法就是将问题得每一个可能性解瞧作就是群体中得一个个体(染色体),并将每一个染色体编码成串得形式,再根据预定得目标函数对每个个体进行评价,给出一个适应值。
算法将根据适应度值进行它得寻优过程,遗传算法得寻优过程就是通过选择、杂交与变异三个遗传算子来具体实现得。
它得搜索能力由选择算子与杂交算子决定,变异算子则保证了算法能够搜索到问题空间得尽可能多得点,从而使其具有搜索全局最优得能力。
遗传算法得高效性与强壮性可由Holland提出得模式定理( Schema Therem) 与隐式并行性得以解释。
在遗传算法中,定义长度较短、低阶且适应值超过平均适应值得模式在群体中数目得期望值按指数递增,这个结论称为遗传算法得基本定理。
遗传算法就是通过定义长度短、确定位数少、适应度值高得模式得反复抽样、组合来寻找最佳点,称这些使遗传算法有效工作得模式为积木块,就是遗传算法构造答案得基本材料。
但归根到底,要使遗传算法有效工作必须按照遗传算法得模式定理(或积木块假设) 根据具体问题设计合理得编码方案。
在运行遗传算法程序时,需要对一些参数作事先选择,它们包括种群得大小、染色体长、交叉率、变异率、最大进化代数等,这些参数对GA 得性能都有很重要p = 0、4 得影响。
在试验中参数一般选取如下:种群大小N= 20~100 ,交叉概率cp = 0、001~0、1 ,最大进化代数maxgen = 100~500。
~0、9 ,变异概率m遗传算法就是具有“生成+检测”得迭代过程得搜索算法。
它得基本处理流程如图1所示。
图1、遗传算法得基本流程遗传算法得基本流程描述如下:(1)编码:将解空间得解数据进行二进制编码,表达为遗传空间得基因型串(即染色体)结构数据,如将数据9编码为“1001”;(2)初始化种群:定义整数pop_size 作为染色体得个数,并且随机产生pop_size 个染色体作为初始种群;(3)评估种群中个体适应度:评价函数对种群中得每个染色体(chromosome)求得其个体适应度)(fitness f i ;(4)选择:选择把当前群体中适应度较高得个体按某种规则或者模型遗传到下一代种群中,这里所用得规则就是:染色体在种群中被选择得可能性与其个体得适应度得大小成正比;(5)交叉:定义参数c p 作为交叉操作得概率,由(4)选择得到得两个个体以概率c p 交换各自得部分染色体,得到新得两个个体;(6)变异:定义参数m p 作为变异操作得概率,由(5)得到每个个体中得每个基因值都以概率m p 进行变异;(7)演化:经过选择、交叉与变异操作,得到一个新得种群,对上述步骤经过给定得循环次数(maxgen)得种群演化,遗传算法终止。
五、背包问题得遗传算法求解描述基于背包问题得模型(*),我们设计了针对于背包问题得染色体编码方法:将待求解得各量X 表示成长为n 得二进制字符串]j [x ,j=1,2, …,n 。
0]j [x =表示物体j 不放入背包内,1]j [x =表示物体j 放入背包内。
例如:111001100…000111代表一个解,它表示将第1、2、3、6、7…n-2,n-1,n 号物体放入背包中,其它得物体则不放入。
根据遗传算法得基本流程,我们确定了求解背包问题得遗传算法:步骤1、初始化过程确定种群规模popsize 、杂交概率c p 、变异概率m p 、染色体长度lchrom及最大进化代数maxgen;读入背包问题得相关信息,如每个物体得重量weight[j]、每个物体得收益profit[j]与背包得容量contain,其中1)lchrom (,1,0j -= ;1.3 取1)lchrom (,1,0j )1,0(u ]j [x -== ,其中)1,0(u 表示0-1整数得均匀分布函数,即随机地生成数0或1,生成得]j [x 串即可瞧为一个染色体个体。
若不满足模型(*)得约束条件,则拒绝接受,由1、2重新生成一个新得染色体个体chrom;如果产生得染色体可行,则接受它作为种群得一名成员,经过有限次得1、2抽样后,得到popsize 个可行得染色体chrom,形成新得种群。
1、4 置种群得代数gen=0;步骤2、计算种群中个体适应度以及统计种群适应度情况2、1 按照下列公式计算种群中个体适应度:)1(1lchrom 0j ]j [chrom *]j [weight weight ∑-==;)2(containifweight )contain weight (*alpha ]j [chrom *]j [profit contain ifweight ]j [chrom *]j [profit fitness 1lchrom 0j 1lchrom 0j ⎪⎪⎩⎪⎪⎨⎧>--≤=∑∑-=-= 公式(2)得下半部分即为适应度得惩罚函数,其中参数 1.0alpha >。
2、2 按公式(3)计算种群得总体适应度,)3(]i [fitness sumfitness 1popsize 0i ∑-==并且按照排序得方法统计出种群中得最大、最小适应度得染色体个体,分别标记为maxpop 、minpop;步骤3、选择操作3.1 生成一个随机数rand_Number,要求1_0<<Nuber rand ;3.2 按照赌轮法选择个体,赌轮法得算法描述如下:int selection( ){i=0; //个体得编号sum=0; //部分个体适应度得累加与//根据随机数与群体得总适应度确定赌轮得位置wheel-pos=rand_Number*sufitness;while sum<wheel-pos && i<=popsize{ i=i+1;sum=sum+fitness[i]; //fitness 为第i 个个体得适应度}return i-1; //选择了个体i-1}3、3 重复两次操作3、1、3、2,生成两个个体作为交叉操作得父代; 步骤四、交叉操作4、1 根据事先定义好得交叉概率c p ,为了确定就是否进行交叉操作,则生成[0,1]得随机数pp,若c p pp <,则进行4、2交叉操作,否则将两个父代保留为下一代得两个个体;4、2 随机生成]1lchrom ,[0-得整数作为交叉点,对两个父代个体交叉生成新得两个个体;4、3 重复pop_size/2次4、1、4、2便可生成pop_size 个个体组成新得种群;步骤五、 变异操作5、1 根据事先定义好得变异概率m p ,为了确定新种群上得每个个体上得每个基因就是否进行变异操作,则生成[0,1]得随机数pp,若m p pp <,则进行5、2变异操作,否则基因不变异;5、2 基因变异操作为原基因若为1,则新基因则变异为0,若原基因为0,则新基因变异为0;步骤6、 演化6、1 按步骤2得方法计算新种群得个体适应度与总体适应度情况,尤其就是找出新种群中最大适应度得个体与最小适应度得个体;6、2 若旧种群得最大个体适应度〉新种群得最大个体适应度,把旧种群得最大适应度得个体代替新种群中得最小适应度得个体,否则进行6、3;6、3 种群得代数gen=genm+1,若gen〉Maxgen,则结束种群得演化,否则转到步骤2。
六、遗传算法求解得实现1、遗传算法得主要参数#define popsize 80 //种群得规模#define pc 0、7 //杂交概率#define pm 0、1 //变异概率#define lchrom 50 //染色体长度#define maxgen 5000 //最大进化代数double alpha; //计算适应度时使用得惩罚函数系数2、数据结构(1)背包信息://背包问题中物体重量、收益、背包容量int weight[lchrom],profit[lchrom],contain;(2)种群个体结构体struct population{unsigned int chrom[lchrom]; //染色体double fitness; //适应度unsigned int parent1,parent2,cross; //双亲、交叉点};(3)父代种群与新生代种群//父代种群、新生代种群struct population oldpop[popsize],newpop[popsize]; //pop_size为种群大小(4)适应度信息//种群得总适应度、最小、最大适应度double sumfitness,minfitness,maxfitness;//一个种群中最大与最小适应度得个体编号int minpop,maxpop;3、主要函数说明(1)、int read_infor( )功能:从文件knapsack、txt中读出背包信息(物体重量、收益、背包容量);参数:无;返回值:返回读取文件信息就是否正确;流程图:见图2。