Traveling Salesman Problem

介绍

遗传算法（Genetic Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。初代种群产生之后，按照适者生存和优胜劣汰的原理，逐代（generation）演化产生出越来越好的近似解，在每一代，根据问题域中个体的适应度（fitness）大小选择（selection）个体，并借助于自然遗传学的遗传算子（genetic operators）进行组合交叉（crossover）和变异（mutation），产生出代表新的解集的种群。这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境，末代种群中的最优个体经过解码（decoding），可以作为问题近似最优解。

选择算子

• 初始化各种变量
• 种群初始化
• 适应度函数
  适应度函数通常取路径长度T的倒数,即f=1/T
• 选择过程
  用随机方法产生初始种群。适应度比例选择，（精英保留）产生新一代种群。
  选择机制与群体构成：在新一代群体构成方法方面，采用了 保留一个最好的父串的最佳保留群体构造方式。
  其中采用了轮盘赌法，所占比率 = 个体适应度 / 总适应度，每次旋转都为新的种群选择一个染色体。

交叉算子

选择个体进行交叉操作的时候采用轮盘赌策略。

变异算子

变异操作对每一个个体以变异概率确定是否变异，如果变异的话，随机在个体中选择两个城市，然后交换这两个城市的位置得到变异的效果。

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
//此题中就是10条染色体，10个基因
#define cityNum 10  //城市数，城市编号是0~citynum-1		
#define popSize 10  //一个群体中的个体数（染色体数）
#define croRate 0.85 //		
#define mutRate 0.1				
#define MAX 999	 //路径最大值上限	

//定义染色体的结构
struct Chrom//其实就是代表种群表的一行
{
	int cityArr[cityNum];	//染色体的基因序列	
	char name;//染色体的名字标识				
	float adapt;//染色体的适应值
	int dis;	//染色体的总路径
};
struct Chrom genes[popSize];//其实就是代表种群表的一列
struct Chrom genesNew[popSize]; //更新
struct Chrom temp;			


char names[cityNum] = {'A','B','C','D','E','F','G','H','I','J'};		
//计算距离词典distance[][]
int distance[cityNum][cityNum] = {{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9  },	  
							 {  1, 0, 1, 2, 3, 4, 5, 6, 7, 8  },
							 {  2, 1, 0, 1, 2, 3, 4, 5, 6, 7  },
							 {  3, 2, 1, 0, 1, 2, 3, 4, 5, 6  },
							 {  4, 3, 2, 1, 0, 1, 2, 3, 4, 5  },
							 {  5, 4, 3, 2, 1, 0, 1, 2, 3, 4  },
							 {  6, 5, 4, 3, 2, 1, 0, 1, 2, 3  },
							 {  7, 6, 5, 4, 3, 2, 1, 0, 1, 2  },
							 {  8, 7, 6, 5, 4, 3, 2, 1, 0, 1  },
							 {  9, 8, 7, 6, 5, 4, 3, 2, 1, 0  }};	

void initGroup()//种群初始化
{
	int i,j,k;
	int t = 0;
	int flag = 0;
	srand(time(NULL));//用时间作为随机生成器的种子
	for(i = 0; i < popSize; i ++)//填染色体表，随机生成染色体群
	{
		
	    temp.name = names[i];//每条染色体都设置一个名字标识
		temp.adapt = 0.0f;//初始化染色体的适应值和总路径为0
		temp.dis = 0;
		//随机生成染色体的基因序列（即城市序列）
		for(j = 0; j < cityNum;)
		{
			t = rand()%cityNum;//产生0~cityNum-1之间的随机数
			flag = 1;
			for(k = 0; k < j; k ++)//检查该染色体genes[i]是否已经存在t这个基因
			{
				if(genes[i].cityArr[k] == t)//如果存在则需要丢弃重新随机生成
				{
					flag = 0;
					break;
				}
			}
			if(flag)
			{
				temp.cityArr[j] = t;
				genes[i] = temp;//得到一个染色体
				j++;//继续产生下一个基因
			}
		}
	}
}

void popFitness()//适应度函数，求适应度和总路径
{
	int i,n1,n2;
	for(i = 0; i < popSize; i ++)//求每个个体的适应值，总路径
	{
		genes[i].dis = 0;
		for(int j = 1;j < cityNum; j ++)//计算第i个染色的总路径
		{
			n1 = genes[i].cityArr[j-1];
			n2 = genes[i].cityArr[j];
			genes[i].dis += distance[n1][n2];
		}
		genes[i].dis += distance[genes[i].cityArr[0]][genes[i].cityArr[cityNum-1]];//回到原点
		genes[i].adapt = (float)1/genes[i].dis;	//适应值即为总路径的倒数
	}
}

int chooseBest()//选择适应度最小的
{
	int choose = 0;
	float best = 0.0f;
	best = genes[0].adapt;
	for(int i = 0; i < popSize; i ++)
	{
		if(genes[i].adapt < best)
		{
			best = genes[i].adapt;
			choose = i;
		}
	}
	return choose;
}
//选择算子，轮盘赌法
void select()
{
	float biggestSum = 0.0f;//总适应度之和
	float adapt_pro[popSize];//记录每个个体的所占比例
	float pick = 0.0f;
	int i;
	for(i = 0; i < popSize; i ++)//遍历种群表求总适应度
	{
		 biggestSum += genes[i].adapt; 
	}
	for(i = 0; i < popSize; i ++)//求每个个体的所占比例
	{
		 adapt_pro[i] = genes[i].adapt / biggestSum; 
	}
	//适应度比例选择，（精英保留1产生新一代种群）
	//选择机制：保留一个最好的父串的过程，每次提取最好的一个染色体
    //采用轮盘赌法：1.计算每个个体的所占比例p(i) 2.计算每个个体的累积概率q(i) 
	//3.在0~1区间内产生一个均匀的随机数r
    for(i = 0;i < popSize; i ++)//整个种群循环popsize遍，更新genes[]
    {//0<=rand()<=RAND_MAX  RAND_MAX是stdlib.h中宏定义的一个常量
	//其值最小为32767，最大为2147483647
        pick = (float)rand()/RAND_MAX;//在0~1区间内产生一个均匀的随机数
	    /********** Begin **********/
        float m = 0;
		//用随机数淘汰个体
		for(int k = 0;k < popSize;k++){//整个种群遍历一遍
			if(pick<=m+adapt_pro[k]){//如果随机数pick<q[i],则选择个体i
				genesNew[i] = genes[k];
				break;
			}			
			m+=adapt_pro[k];//计算累积概率
		}
        
        
	    /********** End **********/
    }
    for(i = 0;i < popSize; i++)
    {
	    genes[i] = genesNew[i];//更新种群
    }
	//得到的只是染色体的重新排序的种群而已
}
//有性繁殖是自然生物进化的普遍现象，同源染色体通过交叉实现基因重组，从而生成新的个体。
//交叉操作通过组合不同个体的遗传信息（基因）以生成可能的优良个体，
//是遗传算法生成新个体的主要方法.
//算术重组：在实数编码下，算术重组指子代个体的基因（目标变量的分量）
//由父代个体的相应位置上的基因的线性组合而成
void cross()//交叉算子,头尾不变，中间打乱顺序交叉
{
    float pick;
    int choice1,choice2;
    int pos1,pos2;
    int temp;
    int conflict1[popSize];	
    int conflict2[popSize];
    int num1;
    int num2;
    int index1,index2;
    int move = 0;				
    while(move < popSize-1)
    {
        pick = (float)rand()/RAND_MAX; //在0~1区间内产生一个均匀的随机数
        if(pick > croRate)	//如果大于交叉概率则跳过循环不对这两个父代进行交叉
        {
            move += 2;
            continue;			
        }
		//否则，下面将进行交叉操作，采取顺序交叉的方式
        choice1 = move;			
        choice2 = move+1;
		//产生1~popsize-2的随机数		
        pos1 = rand()%popSize;
        pos2 = rand()%popSize;
        while(pos1 > popSize -2 || pos1 < 1)
        {
            pos1 = rand()%popSize;
        }
        while(pos2 > popSize -2 || pos2 < 1)
        {
            pos2 = rand()%popSize;
        }
        //取区间，[pos1,pos2]
        if(pos1 > pos2)
        {
            temp = pos1;
            pos1 = pos2;
            pos2 = temp; 
        }
        //将choice1和choice2进行一次头尾保留，中间交换的操作
        for(int j = pos1;j <= pos2; j++)
        {
            temp = genes[choice1].cityArr[j];
            genes[choice1].cityArr[j] = genes[choice2].cityArr[j];
            genes[choice2].cityArr[j] = temp;
        }

        num1 = 0;//记录交叉1的冲突个数
        num2 = 0;//记录交叉2的冲突个数

        if(pos1 > 0 && pos2 < popSize - 1)//确保pos都在1~possize-2这个位置的合法性
        {
            /********** Begin **********/
            for(int j = 0;j < pos1;j++){//在0~pos1-1和pos1~pos2区间查找是否存在相同的冲突基因
           		for(int k = pos1;k <= pos2;k++){
           		   if(genes[choice1].cityArr[j]==genes[choice1].cityArr[k])
           		   		conflict1[num1++] = j;//记录相同冲突的位置
           		   if(genes[choice2].cityArr[j]==genes[choice2].cityArr[k])
           		   		conflict2[num2++] = j;
           		}
           }
            
            
	        /********** End **********/
            

            for(int j = pos2 + 1;j < popSize;j++)
            {
                for(int k = pos1; k <= pos2; k ++)
                {
                    /********** Begin **********/
                     if(genes[choice1].cityArr[j]==genes[choice1].cityArr[k])
                    	conflict1[num1++] = j;
                    if(genes[choice2].cityArr[j]==genes[choice2].cityArr[k])
           		   		conflict2[num2++] = j;
                    
                    
                    /********** End **********/
                }
            }
        }
        if((num1 == num2) && num1 > 0)
        {
            for(int j = 0;j < num1; j ++)
            {
                index1 = conflict1[j];
                index2 = conflict2[j];
				//交换冲突，那么久不冲突了
                temp = genes[choice1].cityArr[index1]; 
                genes[choice1].cityArr[index1] = genes[choice2].cityArr[index2];
                genes[choice2].cityArr[index2] = temp;
            }
        }
        move += 2;
    }
}
// 遗传算法引入变异的目的有两个:一是使遗传算法具有局部的随机搜索能力。
// 当遗传算法通过交叉算子已接近最优解邻域时，利用变异算子的这种局部随机搜索能力可以加速向最优解收敛。
// 显然，此种情况下的变异概率应取较小值，否则接近最优解的积木块会因变异而遭到破坏。
// 二是使遗传算法可维持群体多样性，以防止出现未成熟收敛现象。此时收敛概率应取较大值
/* 对换变异：
随机选择串中的两点，交换其值（码）。对于串A
A＝1 2 3 4 5 6 7 8 9
若对换点为4，7，则经对换后，A’为
A’＝1 2 3 7 5 6 4 8 9 */
void mutation()
{
	double pick;
    int pos1,pos2,temp;
    for(int i = 0;i < popSize; i ++)
    {
        pick = (float)rand()/RAND_MAX; //在0~1区间内产生一个均匀的随机数
        if(pick > mutRate)	//如果大于变异概率则跳过循环不对这这个染色体进行变异
		{
            continue;
		}
		//产生交换点pos1,pos2
		//产生0~popsize-1的随机数	
        pos1 = rand()%popSize;
        pos2 = rand()%popSize;
        while(pos1 > popSize - 1)
        {
           pos1 = rand()%popSize;
        }
        while(pos2 > popSize - 1)
        {
           pos2 = rand()%popSize;
        }
       
	    int a = genes[i].dis;
		//基因交换
        temp = genes[i].cityArr[pos1];
        genes[i].cityArr[pos1] = genes[i].cityArr[pos2];
        genes[i].cityArr[pos2] = temp;

		popFitness();//适应度函数，求适应度和总路径
		if(genes[i].dis > a)//变异后反而变差了，选择不变异
		{
			temp = genes[i].cityArr[pos1];
			genes[i].cityArr[pos1] = genes[i].cityArr[pos2];
			genes[i].cityArr[pos2] = temp;
		}
    }
}