数学建模之遗传算法

---

前言

遗传算法是美国教授Holland于1975年提出的一种基于模仿生物遗传学的优化算法。这种算法很难得到问题的精确答案，但是能够在允许的时间复杂度内得到一个较优的答案。常用来解决一些目前不存在多项式算法的问题，如旅行商问题（TSP问题），背包问题。

遗传算法

算法思想

我们假设在自然界中，存在一个种群。根据达尔文的生物进化论，生物会进行交配和变异，从而慢慢进化。而我们的目标，就是让这群生物往我们希望的方向进化，进化得越来越优秀。而通过数代进化之后，最优秀的那个个体，就是我们问题的解。

生物的表示

在实际问题中，我们用一个n位的01二进制串来表示一个生物。每一位取0或1，表示一个信息。比如，在01背包问题中，一共有n个物品。可以用第i位取1表示取第i个物品，取0表示不取第i个物品。这样，一个方案就可以用一个生物来表示。一个种群包含很多个生物，于是，一个种群可以理解为很多个方案。而我们的目标，就是要选出最优的一个方案。

初始种群的生成

初始种群的生成，可以用随机数来生成。每一位随机取0或1，就可以生成初始种群。当然，这样生成的初始生物可能不太好，我们可以通过贪心思想等生成一些较为优良的初始生物，以提升算法准确度。

下一代种群的产生

生成完初始种群之后，我们需要生成下一代种群。为了比较生物的优劣，我们需要定义适应度函数。

适应度函数

适应度函数是根据实际问题，自己定义的一个函数，较优的方案具有较高的适应度，较差的方案拥有较低的适应度。本文用$f(x_i)$表示第i个生物的适应度。

轮盘赌

为了产生下一代，我们需要选择两个生物作为父母，使其进行交配。那么，如何选择生物呢？常用的一个方法是轮盘赌。即第i个生物被选中的概率为$\frac{f(x_i)}{{\sum }_{i=1}^{n}f(x_i)}$。为什么这个方法被称为轮盘赌呢，是因为其指导思想是将每个生物按照其适应度在轮盘上分配位置，适应度越大，分配到的位置越大。然后转动轮盘，指针指到哪里，就抽到哪个生物。这样做的有点在于适应度越高的生物被选中的概率越大，越有可能保留优良基因。让优秀的基因传承下去，才能使得种群总体适应度越来越高。

交配

我们通过轮盘赌选择了两个生物，现在要让它们生成一个新的生物。也就是说，我们要用两个长度为n的01串$x_i$和$x_j$，生成一个新的长度为n的01串。我们的做法是产生一个1~n-1的随机数，记为y。用$x_i$的1~y位和$x_j$的y+1~n位组成一个新的01串。这个新的01串就是$x_i$和$x_j$的孩子。

变异

由于初始种群的随机度较高，可能无法通过交配产生一些生物。为了丰富生物多样性，我们需要以适当的概率对生物进行变异。通常采用的变异方法是以固定的变异率对生物的某一位进行取反操作。一般变异率保持在0.2左右。

混合产生新种群

通过交配和变异，我们产生了一个新个体。下一代的新种群由这一代的部分个体和下一代的新个体按某种比例混合产生。一般是由20%的这一代生物和80%的新产生 的生物组成。

停止迭代的条件

随着一代一代的新种群产生，生物的总体适应度也将越来越高。我们需要一个停止迭代的条件，一般有两种。第一种是按照固定的迭代次数进行，比如10000次。第二种是比较相邻两代中的平均适应度，如果平均适应度的增加小于一个我们规定的值，那么就可以停止迭代了。我们选取最后一代中最优秀的生物作为我们的最终方案。

遗传算法在01背包中的应用

我们举个具体的例子，来看一看遗传算法在实际问题中的应用。

01背包问题介绍

假设背包的容量为m，有n个物品，第i物品的重量为$w[i]$，价值为$v[i]$，我们要从中选取一些物品放入背包，在不超过背包容量的前提下，使装入背包的物品总价值最高。

01背包的其它解法

01背包的标准解法是利用动态规划算法进行解决，时间复杂度为$O(nm)$，空间复杂度为$O(m)$。但是，使用动态规划算法的前提是，$m$为整数，且$w[i]$均为整数。对于更一般的01背包问题，目前没有找到多项式时间的解法，是一个NP难问题。而对于这样一类问题，遗传算法就非常适用。遗传算法虽然不能给出一个精确解，但是能在可接受的时间范围内给出一个较优的答案。

01背包的遗传算法解法

通过遗传算法，可以让算法的时间复杂度与背包容量$m$无关。并且可以应对$m$不是整数的情况。

生物的表示

我们用$c[i]$表示一个01串，代表第i个生物。$c[i][j]$表示第i个生物的第j位是1还是0。对应到01背包问题，就表示第i种方案的第j个物品选或不选。

初始种群的生成

我们首先对于所有物品，按照性价比（即$v[i]/w[i]$)从高到低进行排序。然后我们随机生成一个长度为n的01串。由于随机生成0和1的方案不一定能满足背包容量的要求。所以我们基于贪心思想，把一个随机01串改造成符合背包容量的01串。在产生的随机方案的基础上，从性价比最高的物品开始，如果随机方案选了，且选择之后背包容量没有超，则选取该物品，否则不选该物品。但是通过这种方式，背包可能有剩余容量，于是我们再次从性价比最高的物品开始，如果我们的方案没有选择它，且选择它之后没有超出背包容量，那么我们就把它加入背包。通过这种基于贪心的选择方式，可以生成一系列较优的初始方案。这些方案组成了初始种群。

下一代种群的产生

适应度函数

每个生物的适应度应该与该方案的总价值相关，总价值越大，适应度越高。我们一般有几种不同的适应度函数。第一种直接用总价值来表示适应度，即$f(x_i)={\sum }_{j=1}^{n}c[i][j]\ast v[j]$。第二种为了使后面的轮盘赌能更大程度区分优秀方案和劣质方案，用该方案的总价值减去这一代方案中最低的总价值来表示适应度，即 f ( x i ) = ∑ j = 1 n c [ i ] [ j ] ∗ v [ j ] − m i n { ∑ j = 1 n c [ i ] [ j ] ∗ v [ j ] } f(x_i)=\sum_{j=1}^{n}{c[i][j]*v[j]}-min\{\sum_{j=1}^{n}{c[i][j]*v[j]}\} f(xi​)=∑j=1n​c[i][j]∗v[j]−min{∑j=1n​c[i][j]∗v[j]}。

轮盘赌

我们通过轮盘赌的方法选取两个方案，来产生下一个方案。在轮盘赌中，每个方案被选择的概率为$\frac{f(x_i)}{{\sum }_{i=1}^{n}f(x_i)}$。通过生成随机数，来选择两个方案。

交配

通过轮盘赌，选择了两个方案，假设为第$a$个和第$b$个方案，假设新产生的方案为d，在1~n-1中产生的随机数为$z$，那么
$$d[j]=\{\begin{array}{ll}c[a][j]& 1\le j\le z\\ c[b][j]& z+1\le j\le n\end{array}$$
如果该方案不满足背包容量的要求，就重新用轮盘赌选择两个方案，重新生成新的方案。

变异

我们设定变异率为一个常数，对新产生的方案进行变异。我们生成一个0~1的随机数，若这个随机数小于变异率，那么就进行变异。我们再生成一个1~n的随机数$z$，表示对新方案的第$z$位进行取反操作。即
$$d[j]=\{\begin{array}{ll}d[j]& j\ne z\\ 1-d[j]& j=z\end{array}$$

混合产生新种群

我们通过轮盘赌，将20%的这一代的方案和80%的新产生的方案混合在一起，组成新一代的方案。值得说明的是，需要将每一代产生的最优方案记录下来。

停止迭代的条件

我们固定一个迭代次数，运行完之后，我们记录的最优秀的方案就是我们程序的运行结果。由于程序的随机性较高，所以一般重复多次运行程序，取最优结果作为我们的最终答案。对于迭代次数、变异率、种群大小等常数，需要根据实际情况灵活选取，在保证准确率的情况下，使得程序运行效率较高。

一个优化

由于算法随机性较高，有一些非常优秀的方案可能不一定能够保存下来。所以我们采用优先队列，人为把每一代中最优秀的两个方案保存下来，放到下一代中。对于这个问题，也有很多人在研究，可能也存在很多更合理的优化。这里只是选取了一个能够大大提升算法准确性的优化。

代码

下面是我用遗传算法写的01背包问题的C++代码

#include
#include
#include
#include
#include
#include
using namespace std;
int n,m,w[10005],v[10005];
vector<bool> c[105];
double d[105];
const int populationSize = 20;//设定种群大小为20 
const int generations = 10000;//设定迭代次数为10000 
double mutationRate = 0.3;//设定变异率为0.3 
vector<bool> q;
int num=0;
bool check(vector<bool> &a)//对于一个方案，验证其是否超过背包容量 
{
	int s=0;
	for (int i=0;i<n;i++) s+=a[i]*w[i];
	return s<=m;
}
double jisuan(vector<bool> &a)//计算给定方案的总价值 
{
	if (!check(a)) return 0;//若该方案超出背包容量，则价值为0 
	double s=0,t=0;
	for (int i=0;i<n;i++) 
	{
		s+=a[i]*v[i];
		t+=a[i]*w[i];
	}
	return s;
}
vector<bool> jiaocha(vector<bool> &a,vector<bool> &b)//对于两个方案，进行交叉 
{
	int x=rand()%n;
	vector<bool> t;
	for (int i=0;i<x;i++) t.push_back(a[i]);
	for (int i=x;i<n;i++) t.push_back(b[i]);
	return t;
}
void bianyi(vector<bool> &a)//对于一个方案，进行变异 
{
	double x=rand()/double(RAND_MAX);
	double y;	
	if (x<mutationRate) 
	{
		y=rand()%n;
		a[y]=!a[y];
	}
}
int lunpandu()//通过轮盘赌，选出一个方案的编号 
{
	double x=rand()/double(RAND_MAX);
	for (int i=1;i<=populationSize;i++)
	{
		if (d[i]>=x) return i;
	}
	return populationSize;
}
struct Compare {  //根据方案价值的高低来在优先队列中排序 
    bool operator()(vector<bool>& a,vector<bool>& b) {  
        return jisuan(a) < jisuan(b);  
    }  
};
int main()
{
	srand(time(NULL));
	cin>>m>>n;//m表示背包容量，n表示物品数量 
	for (int i=0;i<n;i++)
	{
		cin>>w[i]>>v[i];//w[i]表示物品重量，v[i]表示物品价值  
	}
	for (int i=0;i<n;i++)//对所有物品关于性价比从高到低进行排序 
	{
		for (int j=0;j<n-i;j++)
		{
			if ((double)v[j]/w[j]<(double)v[j+1]/w[j+1])
			{
				int t=v[j];
				v[j]=v[j+1];
				v[j+1]=t;
				t=w[j];
				w[j]=w[j+1];
				w[j+1]=t;
			}
		}
	}
	int ans=0;
	for (int k=1;k<=10;k++) //程序重复运行10次 
	{
		num=0; 
		srand(time(NULL));
		for (int i=1;i<=populationSize;i++)//生成初始种群 
		{
			c[i].clear();
			for (int j=0;j<n;j++) c[i].push_back(rand()%2);//生成随机01串 
			int weight=0;
			for (int j=0;j<n;j++) 
			{
				if (weight+c[i][j]*w[j]<=m) weight+=c[i][j]*w[j];//若加入该物品后背包重量没有超，就加入该物品 
				else c[i][j]=0;
			}
			for (int j=0;j<n;j++)//背包还有剩余空间，可以再加入一些物品 
			{
				if (c[i][j]==0&&weight+w[j]<=m) 
				{
					c[i][j]=1;
					weight+=w[j];
				}
			}
		}
		priority_queue<vector<bool>, vector<vector<bool> >, Compare> p;//定义优先队列 
		vector<bool> x;
		for (int i=1;i<=generations;i++)
		{
			while (!p.empty()) p.pop();//清空优先队列 
			double s=0,zuixiaozhi=1000000;
			bool b=0;
			for (int j=1;j<=populationSize;j++) 
			{
				if (j==1) //把上一代最优的方案加入优先队列 
				{
					p.push(c[j]);
					b=1;
				}
				if (b==1&&c[j]!=p.top()) //把上一代次优的方案加入优先队列 
				{
					p.push(c[j]); 
					b=0;
				}
				d[j]=jisuan(c[j]);
				if (d[j]<zuixiaozhi) zuixiaozhi=d[j];
				s+=d[j];
			}
			s-=zuixiaozhi*populationSize;
			for (int j=1;j<=populationSize;j++) d[j]=d[j-1]+(d[j]-zuixiaozhi)/s;//d[j]表示第j个方案在轮盘赌中被选中的概率 
			for (int j=1;j<=populationSize;j++)//产生下一代 
			{
				int x1=lunpandu(),x2=lunpandu();//根据轮盘赌，选择两个方案 
				x=jiaocha(c[x1],c[x2]);//两个方案进行交叉 
				bianyi(x);//对新得到的方案进行变异 
				p.push(x);//把新得到的方案加入优先队列 
			}
			for (int j=1;j<=populationSize&&!p.empty();j++)//把较优的一些方案作为下一代，从而继续产生下下代 
			{
				c[j]=p.top();
				p.pop();
			}
		}
		for (int i=1;i<=populationSize;i++)//把最优的方案记录下来 
		{
			if (check(c[i]))
			{
				cout<<k<<' '<<jisuan(c[i])<<"\n";//输出第k次的最优值 
				if (jisuan(c[i])>ans) ans=jisuan(c[i]);
				break;
			}
		}
	}
	cout<<ans;//输出10次的最优值 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

遗传算法的优缺点

优点

可以全局搜索

由于遗传算法的多样性搜索性质，它可以在搜索空间内找到许多可能的解，于是可以在较短时间内全局最优或近似最优的解。

适用范围广

作为一种优化算法，它的适用范围非常广，可以基于初始解，产生近似最优解。而且可以人为定义适应度，可以应用于一些难以定量的问题。

缺点

参数调节困难

该算法中有多个参数，比如种群大小，迭代次数，变异率等。如何通过修改参数使得能取得更优秀的解，是一个比较困难的问题。

可能陷入局部最优

若父代的相似度较高，则产生的子代相似度也很可能较高，从而使得陷入局部最优。

遗传算法的时间复杂度

设迭代次数为G，种群规模为P，01串长度为n，则不加任何优化的遗传算法的时间复杂度为$O(GPn)$。G和P都是人为控制的参数。通过这种方法，把原来的$O(2^n)$的时间复杂度降为了关于n的线性表达式，这已经是一个极大的进步了。

总结

遗传算法主要应用于一些不存在多项式算法的问题，使得在较短时间内能够得到较优的答案。但要得到真正最优的解还是有一定困难的。遗传算法在数学建模方面也有着广泛的应用，比如用于函数的求最值等问题。