用遗传算法解决TSP问题

遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法

遗传算法的基本运算过程如下：

a)初始化：设置进化代数计数器t=0，设置最大进化代数T，随机生成M个个体作为初始群体P(0)。

b)个体评价：计算群体P(t)中各个个体的适应度。

c)选择运算:将选择算子作用于群体。选择的目的是把优化的个体直接遗传到下一代或通过配对交叉产生新的个体再遗传到下一代。选择操作是建立在群体中个体的适应度评估基础上的。

d)交叉运算：将交叉算子作用于群体。所谓交叉是指把两个父代个体的部分结构加以替换重组而生成新个体的操作。遗传算法中起核心作用的就是交叉算子。

e)变异运算：将变异算子作用于群体。即是对群体中的个体串的某些基因座上的基因值作变动。

群体P(t)经过选择、交叉、变异运算之后得到下一代群体P(t 1)。

f)终止条件判断:若t=T,则以进化过程中所得到的具有最大适应度个体作为最优解输出，终止计算。

下面用C语言模拟遗传算法模拟TSP问题

TSP问题及旅行商问题,假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值

交叉的算法如下图

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include<string.h>  
3. #include<stdlib.h>  
4. #include<math.h>  
5. #include<time.h>  
6. #define cities 10  //城市的个数  
7. #define MAXX 100//迭代次数  
8. #define pc 0.8 //交配概率  
9. #define pm 0.05 //变异概率  
10. #define num 10//种群的大小  
11. int bestsolution;//最优染色体  
12. int distance[cities][cities];//城市之间的距离  
13. struct group  //染色体的结构  
14. {  
15.     int city[cities];//城市的顺序  
16.     int adapt;//适应度  
17.     double p;//在种群中的幸存概率  
18. }group[num],grouptemp[num];  
19. //随机产生cities个城市之间的相互距离  
20. void init()  
21. {  
22.     int i,j;  
23.     memset(distance,0,sizeof(distance));  
24.     srand((unsigned)time(NULL));  
25.     for(i=0;i<cities;i++)  
26.     {  
27.         for(j=i+1;j<cities;j++)  
28.         {  
29.            distance[i][j]=rand()%100;  
30.            distance[j][i]=distance[i][j];  
31.         }  
32.     }  
33.     //打印距离矩阵  
34.     printf("城市的距离矩阵如下\n");  
35.     for(i=0;i<cities;i++)  
36.     {  
37.         for(j=0;j<cities;j++)  
38.         printf("%4d",distance[i][j]);  
39.         printf("\n");  
40.     }  
41. }  
42. //随机产生初试群  
43. void groupproduce()  
44. {  
45.     int i,j,t,k,flag;  
46.     for(i=0;i<num;i++)  //初始化  
47.     for(j=0;j<cities;j++)  
48.     group[i].city[j]=-1;  
49.     srand((unsigned)time(NULL));  
50.     for(i=0;i<num;i++)  
51.     {  
52.         //产生10个不相同的数字  
53.         for(j=0;j<cities;)  
54.         {  
55.             t=rand()%cities;  
56.             flag=1;  
57.             for(k=0;k<j;k++)  
58.             {  
59.                 if(group[i].city[k]==t)  
60.                 {  
61.                     flag=0;  
62.                     break;  
63.                 }  
64.             }  
65.             if(flag)  
66.             {  
67.                 group[i].city[j]=t;  
68.                 j++;  
69.             }  
70.         }  
71.     }  
72.     //打印种群基因  
73.     printf("初始的种群\n");  
74.     for(i=0;i<num;i++)  
75.     {  
76.         for(j=0;j<cities;j++)  
77.         printf("%4d",group[i].city[j]);  
78.         printf("\n");  
79.     }  
80. }  
81. //评价函数,找出最优染色体  
82. void pingjia()  
83. {  
84.     int i,j;  
85.     int n1,n2;  
86.     int sumdistance,biggestsum=0;  
87.     double biggestp=0;  
88.     for(i=0;i<num;i++)  
89.     {  
90.         sumdistance=0;  
91.         for(j=1;j<cities;j++)  
92.         {  
93.             n1=group[i].city[j-1];  
94.             n2=group[i].city[j];  
95.             sumdistance+=distance[n1][n2];  
96.         }  
97.         group[i].adapt=sumdistance; //每条染色体的路径总和  
98.         biggestsum+=sumdistance; //种群的总路径  
99.     }  
100.     //计算染色体的幸存能力,路劲越短生存概率越大  
101.     for(i=0;i<num;i++)  
102.     {  
103.         group[i].p=1-(double)group[i].adapt/(double)biggestsum;   
104.         biggestp+=group[i].p;  
105.     }  
106.     for(i=0;i<num;i++)  
107.     group[i].p=group[i].p/biggestp;  //在种群中的幸存概率,总和为1  
108.     //求最佳路劲  
109.     bestsolution=0;  
110.     for(i=0;i<num;i++)  
111.     if(group[i].p>group[bestsolution].p)  
112.     bestsolution=i;  
113.     //打印适应度  
114.     for(i=0;i<num;i++)  
115.     printf("染色体%d的路径之和与生存概率分别为%4d  %.4f\n",i,group[i].adapt,group[i].p);  
116.     printf("当前种群的最优染色体是%d号染色体\n",bestsolution);  
117. }  
118. //选择  
119. void xuanze()  
120. {  
121.     int i,j,temp;  
122.     double gradient[num];//梯度概率  
123.     double xuanze[num];//选择染色体的随机概率  
124.     int xuan[num];//选择了的染色体  
125.     //初始化梯度概率  
126.     for(i=0;i<num;i++)  
127.     {  
128.         gradient[i]=0.0;  
129.         xuanze[i]=0.0;  
130.     }  
131.     gradient[0]=group[0].p;  
132.     for(i=1;i<num;i++)  
133.     gradient[i]=gradient[i-1]+group[i].p;  
134.     srand((unsigned)time(NULL));  
135.     //随机产生染色体的存活概率  
136.     for(i=0;i<num;i++)  
137.     {  
138.         xuanze[i]=(rand()%100);  
139.         xuanze[i]/=100;  
140.     }  
141.     //选择能生存的染色体  
142.     for(i=0;i<num;i++)  
143.     {  
144.         for(j=0;j<num;j++)  
145.         {  
146.             if(xuanze[i]<gradient[j])  
147.             {  
148.                 xuan[i]=j; //第i个位置存放第j个染色体  
149.                 break;  
150.             }  
151.         }  
152.     }  
153.     //拷贝种群  
154.     for(i=0;i<num;i++)  
155.     {  
156.         grouptemp[i].adapt=group[i].adapt;  
157.         grouptemp[i].p=group[i].p;  
158.         for(j=0;j<cities;j++)  
159.         grouptemp[i].city[j]=group[i].city[j];  
160.     }  
161.     //数据更新  
162.     for(i=0;i<num;i++)  
163.     {  
164.         temp=xuan[i];  
165.         group[i].adapt=grouptemp[temp].adapt;  
166.         group[i].p=grouptemp[temp].p;  
167.         for(j=0;j<cities;j++)  
168.         group[i].city[j]=grouptemp[temp].city[j];  
169.     }  
170.     //用于测试  
171.     /* 
172.     printf("<------------------------------->\n"); 
173.     for(i=0;i<num;i++) 
174.     { 
175.         for(j=0;j<cities;j++) 
176.         printf("%4d",group[i].city[j]); 
177.         printf("\n"); 
178.         printf("染色体%d的路径之和与生存概率分别为%4d  %.4f\n",i,group[i].adapt,group[i].p); 
179.     } 
180.     */  
181. }  
182. //交配,对每个染色体产生交配概率,满足交配率的染色体进行交配  
183. void  jiaopei()  
184. {  
185.     int i,j,k,kk;  
186.     int t;//参与交配的染色体的个数  
187.     int point1,point2,temp;//交配断点  
188.     int pointnum;  
189.     int temp1,temp2;  
190.     int map1[cities],map2[cities];  
191.     double jiaopeip[num];//染色体的交配概率  
192.     int jiaopeiflag[num];//染色体的可交配情况  
193.     for(i=0;i<num;i++)//初始化  
194.     jiaopeiflag[i]=0;  
195.     //随机产生交配概率  
196.     srand((unsigned)time(NULL));  
197.     for(i=0;i<num;i++)  
198.     {  
199.         jiaopeip[i]=(rand()%100);  
200.         jiaopeip[i]/=100;  
201.     }  
202.     //确定可以交配的染色体  
203.     t=0;  
204.     for(i=0;i<num;i++)  
205.     {  
206.         if(jiaopeip[i]<pc)  
207.         {  
208.             jiaopeiflag[i]=1;  
209.             t++;  
210.         }  
211.     }  
212.     t=t/2*2;//t必须为偶数  
213.     //产生t/2个0-9交配断点  
214.     srand((unsigned)time(NULL));  
215.     temp1=0;  
216.     //temp1号染色体和temp2染色体交配  
217.     for(i=0;i<t/2;i++)  
218.     {  
219.         point1=rand()%cities;  
220.         point2=rand()%cities;  
221.         for(j=temp1;j<num;j++)  
222.         if(jiaopeiflag[j]==1)  
223.         {  
224.             temp1=j;  
225.             break;  
226.         }  
227.         for(j=temp1+1;j<num;j++)  
228.         if(jiaopeiflag[j]==1)  
229.         {  
230.             temp2=j;  
231.             break;  
232.         }  
233.         //进行基因交配  
234.         if(point1>point2) //保证point1<=point2  
235.         {  
236.             temp=point1;  
237.             point1=point2;  
238.             point2=temp;  
239.         }  
240.         memset(map1,-1,sizeof(map1));  
241.         memset(map2,-1,sizeof(map2));  
242.         //断点之间的基因产生映射  
243.         for(k=point1;k<=point2;k++)  
244.         {  
245.             map1[group[temp1].city[k]]=group[temp2].city[k];  
246.             map2[group[temp2].city[k]]=group[temp1].city[k];  
247.         }  
248.         //断点两边的基因互换  
249.         for(k=0;k<point1;k++)  
250.         {  
251.             temp=group[temp1].city[k];  
252.             group[temp1].city[k]=group[temp2].city[k];  
253.             group[temp2].city[k]=temp;  
254.         }  
255.         for(k=point2+1;k<cities;k++)  
256.         {  
257.             temp=group[temp1].city[k];  
258.             group[temp1].city[k]=group[temp2].city[k];  
259.             group[temp2].city[k]=temp;  
260.         }  
261.         //处理产生的冲突基因  
262.         for(k=0;k<point1;k++)  
263.         {  
264.             for(kk=point1;kk<=point2;kk++)  
265.             if(group[temp1].city[k]==group[temp1].city[kk])  
266.             {  
267.                 group[temp1].city[k]=map1[group[temp1].city[k]];  
268.                 break;  
269.             }  
270.         }  
271.         for(k=point2+1;k<cities;k++)  
272.         {  
273.             for(kk=point1;kk<=point2;kk++)  
274.             if(group[temp1].city[k]==group[temp1].city[kk])  
275.             {  
276.                 group[temp1].city[k]=map1[group[temp1].city[k]];  
277.                 break;  
278.             }  
279.         }  
280.         for(k=0;k<point1;k++)  
281.         {  
282.             for(kk=point1;kk<=point2;kk++)  
283.             if(group[temp2].city[k]==group[temp2].city[kk])  
284.             {  
285.                 group[temp2].city[k]=map2[group[temp2].city[k]];  
286.                 break;  
287.             }  
288.         }  
289.         for(k=point2+1;k<cities;k++)  
290.         {  
291.             for(kk=point1;kk<=point2;kk++)  
292.             if(group[temp2].city[k]==group[temp2].city[kk])  
293.             {  
294.                 group[temp2].city[k]=map2[group[temp2].city[k]];  
295.                 break;  
296.             }  
297.         }  
298.         temp1=temp2+1;  
299.     }  
300. }  
301. //变异  
302. void bianyi()  
303. {  
304.     int i,j;  
305.     int t;  
306.     int temp1,temp2,point;  
307.     double bianyip[num]; //染色体的变异概率  
308.     int bianyiflag[num];//染色体的变异情况  
309.     for(i=0;i<num;i++)//初始化  
310.     bianyiflag[i]=0;  
311.     //随机产生变异概率  
312.     srand((unsigned)time(NULL));  
313.     for(i=0;i<num;i++)  
314.     {  
315.         bianyip[i]=(rand()%100);  
316.         bianyip[i]/=100;  
317.     }  
318.     //确定可以变异的染色体  
319.     t=0;  
320.     for(i=0;i<num;i++)  
321.     {  
322.         if(bianyip[i]<pm)  
323.         {  
324.             bianyiflag[i]=1;  
325.             t++;  
326.         }  
327.     }  
328.     //变异操作,即交换染色体的两个节点  
329.     srand((unsigned)time(NULL));  
330.     for(i=0;i<num;i++)  
331.     {  
332.         if(bianyiflag[i]==1)  
333.         {  
334.             temp1=rand()%10;  
335.             temp2=rand()%10;  
336.             point=group[i].city[temp1];  
337.             group[i].city[temp1]=group[i].city[temp2];  
338.             group[i].city[temp2]=point;  
339.         }  
340.     }  
341. }  
342. int main()  
343. {  
344.     int i,j,t;  
345.     init();  
346.     groupproduce();  
347.     //初始种群评价  
348.     pingjia();  
349.     t=0;  
350.     while(t++<MAXX)  
351.     {  
352.          xuanze();  
353.          //jiaopei();  
354.          bianyi();  
355.          pingjia();  
356.     }  
357.     //最终种群的评价  
358.     printf("\n输出最终的种群评价\n");  
359.     for(i=0;i<num;i++)  
360.     {  
361.         for(j=0;j<cities;j++)  
362.         {  
363.             printf("%4d",group[i].city[j]);  
364.         }  
365.         printf("  adapt:%4d, p:%.4f\n",group[i].adapt,group[i].p);  
366.     }  
367.     printf("最优解为%d号染色体\n",bestsolution);  
368.     return 0;  
369. }