基因算法解决01背包问题

                                                                  

背包问题简述：
有m个物体，每个物体价值为v[i]，重量为w[i]，有一个背包，最多能盛重量为W的物体，

 求背包能盛的最大的价值。

基因算法:

编码：编码长度为物体的个数，1表示放进包，0表示不放进包

适应度：包里物品的价值和

交叉：两个随机，采用多点交叉，交叉点的个数是随机的，交叉的位置是随机的

编译：同样两个随机

交叉概率：0.8

变异概率：0.15

个体类（一个个体就是问题的一个解）：

import java.util.Arrays;

/**
* 0 1背包中的个体，一个个体对应基因算法的一个解
* @author founder
*/
public class Individual {

//基因序列，数组的大小为物体的个数，gene[i]=1表示选择，gene[i]=0表示不选择
public int[] gene;
public double fitness; //个体的适应度
public double selectProbability; //选择概率
public double accumulateProbability; //累积的选择概率

public Individual(Individual ind){
this.gene = new int[ind.gene.length];
this.gene = Arrays.copyOf(ind.gene, ind.gene.length);
this.fitness = ind.fitness;
this.selectProbability = ind.selectProbability;
this.accumulateProbability = ind.accumulateProbability;
}

public Individual(){
}
}

全部代码如下，evaluate给出每个解的评估，crossover交叉操作，mutation编译操作，迭代次数为100，种群大小为50。

代码实现了两种选择算子，轮盘赌算法和二进制锦标赛算法

：

import java.util.Arrays;
import java.util.Random;

/**
* 基因算法解决0 1背包问题，背包问题简述：
* 有m个物体，每个物体价值为v[i]，重量为w[i]，有一个背包，最多能盛重量为W的物体，
* 求背包能盛价值最大的物体
* @author founder
*/
public class BinPacking {

public int[] bin_values;	//价值向量
public int[] bin_weights;	//重量向量
public int bin_capacity;	//背包可以承受的总重量
public int bin_objNum;

public int gene_N;			//种群大小
public double gene_cross_prob = 0.8;
public double gene_mutation_prob = 0.15;

public Individual[] population;

public Random random;

/**
* 构造函数
* @param num	物体个数
* @param gene_N	种群大小
*/
public BinPacking(){

this.bin_objNum = 7;	//物体个数
this.gene_N = 40;		//种群中的个体个数

population = new Individual[gene_N];

int[] bin_values = {10,40,30,50,35,40,30};
this.bin_values = bin_values;

int[] bin_weights = {35,30,60,50,40,10,25};
this.bin_weights = bin_weights;

this.bin_capacity = 150;

this.random = new Random(System.currentTimeMillis());
}

/**
* 随机产生大小为N的种群
* Random.nextInt(n)从0(包含)到n(不包含)均匀分布的整数
*/
public void generateInitPopulation(){

for(int i=0;i<this.gene_N;i++){
Individual ind = new Individual();
ind.gene = new int[this.bin_objNum];
for(int j=0;j<ind.gene.length;j++){
ind.gene[j] = random.nextInt(2);
}
population[i] = ind;
}
}

/**
* 计算每个个体的适应度，顺便计算整个种群的适应度
* @param Individual[] inds,一整个种群
* @return 种群总的适应度，所有个体的适应度的和（用来计算选择概率）
*/
public void evaluate(){
int totalFitness = 0;

for(int i=0;i<this.population.length;i++){			//计算每个个体的适应度以及种群的总适应度
Individual ind = this.population[i];
int weight = 0;
ind.fitness = 0;
for(int j=0;j<ind.gene.length;j++){
if(ind.gene[j]==1){
ind.fitness += bin_values[j];
weight += bin_weights[j];
}
}

if(weight > bin_capacity){
ind.fitness = 1;
}
totalFitness += ind.fitness;
}

double lastcf = 0.0;
for(int i=0;i<this.population.length;i++){		//计算每个个体的选择概率，以及累加选择概率（轮盘赌）
this.population[i].selectProbability = this.population[i].fitness/totalFitness;
this.population[i].accumulateProbability = lastcf + this.population[i].selectProbability;
lastcf = this.population[i].accumulateProbability;
}

}

/**
* 使用轮盘赌算法选择大小为N的种群
*/
public void select(){
Individual[] newInds = new Individual[this.gene_N];
for(int i=0;i<this.gene_N;i++){		//选择的次数即为种群的大小
double prob = random.nextDouble();
if(prob<this.population[0].accumulateProbability){
newInds[i] = new Individual(this.population[0]);
}else{
for(int j=0;j<this.population.length-1;j++){
if(prob>=this.population[j].accumulateProbability
&& prob<this.population[j+1].accumulateProbability){

newInds[i] = new Individual(this.population[j+1]);
}
}
}
}
this.population = newInds;
}

/**
* 轮盘赌选择算法的另一种选择方法：二进制竞赛
* 随机选择两个，适应度大的作为下一代，适应度小的丢弃
*/
public void binaryCompetitionSelect(){
Individual[] newInds = new Individual[this.gene_N];

for(int i=0;i<newInds.length;i++){
int first = random.nextInt(this.gene_N);
int second = random.nextInt(this.gene_N);

if(this.population[first].fitness>=this.population[second].fitness){
newInds[i] = new Individual(this.population[first]);
}else{
newInds[i] = new Individual(this.population[second]);
}
}

this.population = newInds;
}

/**
* 交叉操作，以某概率，交叉概率设置为0.8
*/
public void crossover(){
int first = -1;
for(int i=0;i<this.population.length;i++){
double prob = random.nextDouble();
if(prob<this.gene_cross_prob){
if(first<0){
first = i;
}else{
exchange(first, i);
first = -1;
}
}
}
}

/**
* 交换两个个体的部分基因（随机个基因）,两个随机：
* 1、交换点的个数是随机的
* 2、交换的位置是随机的
*/
public void exchange(int first,int second){
int exNum = random.nextInt(population.length);	//产生交换的基因数
for(int i=0;i<exNum;i++){
//每次选择一个基因进行交换，一共exNum个。
int pos = random.nextInt(this.bin_objNum);
//int temp = population[first].gene[pos];

Individual ind = population[first];
int temp = ind.gene[pos];

population[first].gene[pos] = population[second].gene[pos];
population[second].gene[pos] = temp;
}
}

/**
* 变异操作
*/
public void mutation(){
for(int i=0;i<this.population.length;i++){
if(random.nextDouble()<this.gene_mutation_prob){		//进行变异操作，随机个点，随机位置
int mutNum = random.nextInt(this.population.length);
for(int j=0;j<mutNum;j++){
int pos = random.nextInt(this.bin_objNum);
this.population[i].gene[pos] = 1-this.population[i].gene[pos];
}
}
}
}

public static void startBP(){
BinPacking bp = new BinPacking();
bp.generateInitPopulation();

for(int i=0;i<50;i++){
bp.evaluate();
//bp.select();
bp.binaryCompetitionSelect();
bp.crossover();
bp.mutation();
}

bp.evaluate();

Arrays.sort(bp.population, new IndCom());

System.out.println(bp.population[0].fitness);
for(int i=0;i<bp.population[0].gene.length;i++){
System.out.print(bp.population[0].gene[i]+" ");
}
}

public static void main(String[] args) {
startBP();
}

}

用于对Individual排序的比较器：

import java.util.Comparator;

public class IndCom implements Comparator<Individual>{

@Override
public int compare(Individual o1, Individual o2) {

if(o2.fitness>o1.fitness){
return 1;
}else if(o2.fitness<o1.fitness){
return -1;
}else{
return 0;
}
}

}

基因算法流程图：