旅行商问题的遗传算法-JAVA



 
import java.util.*;

public class Tsp {
 private String cityName[]={"北京","上海","天津","重庆","哈尔滨","长春","沈阳","呼和浩特","石家庄","太原","济南","郑州","西安","兰州","银川","西宁","乌鲁木齐","合肥","南京","杭州","长沙","南昌","武汉","成都","贵州","福建","台北","广州","海口","南宁","昆明","拉萨","香港","澳门"};
 //private String cityEnd[]=new String[34];
 private int cityNum=cityName.length; //城市个数
private int popSize = 50; //种群数量
private int maxgens = 20000; //迭代次数
private double pxover = 0.8; //交叉概率
private double pmultation = 0.05; //变异概率
private long[][] distance = new long[cityNum][cityNum];
 private int range = 2000; //用于判断何时停止的数组区间

private class genotype {
 int city[] = new int[cityNum]; //单个基因的城市序列
long fitness; //该基因的适应度
double selectP; //选择概率
double exceptp; //期望概率
int isSelected; //是否被选择
}
private genotype[] citys = new genotype[popSize];

/**
 * 构造函数，初始化种群
*/
public Tsp() {
 for (int i = 0; i < popSize; i++) {
 citys[i] = new genotype();
 int[] num = new int[cityNum];
 for (int j = 0; j < cityNum; j++)
 num[j] = j;
 int temp = cityNum;
 for (int j = 0; j < cityNum; j++) {
 int r = (int) (Math.random() * temp);//产生随机数
 citys[i].city[j] = num[r];//每个个体上的每位基因值
 num[r] = num[temp - 1];
 temp--;
 }
 citys[i].fitness = 0;
 citys[i].selectP = 0;
 citys[i].exceptp = 0;
 citys[i].isSelected = 0;
 }
 initDistance();
 }

/**
 * 计算每个种群每个基因个体的适应度，选择概率，期望概率，和是否被选择。
*/
public void CalAll(){
 for( int i = 0; i< popSize; i++){
 citys[i].fitness = 0;
 citys[i].selectP = 0;
 citys[i].exceptp = 0;
 citys[i].isSelected = 0;
 }
 CalFitness();
 CalSelectP();
 CalExceptP();
 CalIsSelected();
 }

/**
 * 填充，将多选的填充到未选的个体当中
*/
public void pad(){
 int best = 0;
 int bad = 0;
 while(true){
 while(citys[best].isSelected <= 1 && best<popSize-1)
 best ++;
 while(citys[bad].isSelected != 0 && bad<popSize-1)
 bad ++;
 for(int i = 0; i< cityNum; i++)
 citys[bad].city[i] = citys[best].city[i];
 citys[best].isSelected --;
 citys[bad].isSelected ++;
 bad ++;
 if(best == popSize ||bad == popSize)
 break;
 }
 }

/**
 * 交叉主体函数
*/
public void crossover() {
 int x;
 int y;
 int pop = (int)(popSize* pxover /2);
 while(pop>0){
 x = (int)(Math.random()*popSize);
 y = (int)(Math.random()*popSize);

executeCrossover(x,y);//x y 两个体执行交叉
pop--;
 }
 }

/**
 * 执行交叉函数
* @param 个体x
 * @param 个体y
 * 对个体x和个体y执行佳点集的交叉，从而产生下一代城市序列
*/
private void executeCrossover(int x,int y){
 int dimension = 0;
 for( int i = 0 ;i < cityNum; i++)
 if(citys[x].city[i] != citys[y].city[i]){
 dimension ++;
 }
 int diffItem = 0;
 double[] diff = new double[dimension];

for( int i = 0 ;i < cityNum; i++){
 if(citys[x].city[i] != citys[y].city[i]){
 diff[diffItem] = citys[x].city[i];
 citys[x].city[i] = -1;
 citys[y].city[i] = -1;
 diffItem ++;
 }
 }

Arrays.sort(diff);

double[] temp = new double[dimension];
 temp = gp(x, dimension);

for( int k = 0; k< dimension;k++)
 for( int j = 0; j< dimension; j++)
 if(temp[j] == k){
 double item = temp[k];
 temp[k] = temp[j];
 temp[j] = item;

item = diff[k];
 diff[k] = diff[j];
 diff[j] = item;
 }
 int tempDimension = dimension;
 int tempi = 0;

while(tempDimension> 0 ){
 if(citys[x].city[tempi] == -1){
 citys[x].city[tempi] = (int)diff[dimension - tempDimension];

tempDimension --;
 }
 tempi ++;
 }

Arrays.sort(diff);

temp = gp(y, dimension);

for( int k = 0; k< dimension;k++)
 for( int j = 0; j< dimension; j++)
 if(temp[j] == k){
 double item = temp[k];
 temp[k] = temp[j];
 temp[j] = item;

item = diff[k];
 diff[k] = diff[j];
 diff[j] = item;
 }

tempDimension = dimension;
 tempi = 0;

while(tempDimension> 0 ){
 if(citys[y].city[tempi] == -1){
 citys[y].city[tempi] = (int)diff[dimension - tempDimension];

tempDimension --;
 }
 tempi ++;
 }

}

/**
 * @param individual 个体
* @param dimension 维数
* @return 佳点集 (用于交叉函数的交叉点） 在executeCrossover()函数中使用
*/
private double[] gp(int individual, int dimension){
 double[] temp = new double[dimension];
 double[] temp1 = new double[dimension];
 int p = 2 * dimension + 3;

while(!isSushu(p))
 p++;

for( int i = 0; i< dimension; i++){
 temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (individual+1);
 temp[i] = temp[i] - (int)temp[i];
 if( temp [i]< 0)
 temp[i] = 1+temp[i];

}
 for( int i = 0; i< dimension; i++)
 temp1[i] = temp[i];
 Arrays.sort(temp1);
 //排序
for( int i = 0; i< dimension; i++)
 for( int j = 0; j< dimension; j++)
 if(temp[j]==temp1[i])
 temp[j] = i;
 return temp;
 }

/**
 * 变异
*/
public void mutate(){
 double random;
 int temp;
 int temp1;
 int temp2;
 for( int i = 0 ; i< popSize; i++){
 random = Math.random();
 if(random<=pmultation){
 temp1 = (int)(Math.random() * (cityNum));
 temp2 = (int)(Math.random() * (cityNum));
 temp = citys[i].city[temp1];
 citys[i].city[temp1] = citys[i].city[temp2];
 citys[i].city[temp2] = temp;

}
 }
 }

/**
 * 打印当前代数的所有城市序列，以及其相关的参数
*/
public void print(){
 /**
 * 初始化各城市之间的距离
*/
private void initDistance(){
 for (int i = 0; i < cityNum; i++) {
 for (int j = 0; j < cityNum; j++){
 distance[i][j] = Math.abs(i-j);
 }
 }
 }

/**
 * 计算所有城市序列的适应度
*/
private void CalFitness() {
 for (int i = 0; i < popSize; i++) {
 for (int j = 0; j < cityNum - 1; j++)
 citys[i].fitness += distance[citys[i].city[j]][citys[i].city[j + 1]];
 citys[i].fitness += distance[citys[i].city[0]][citys[i].city[cityNum - 1]];
 }
 }

/**
 * 计算选择概率
*/
private void CalSelectP(){
 long sum = 0;
 for( int i = 0; i< popSize; i++)
 sum += citys[i].fitness;
 for( int i = 0; i< popSize; i++)
 citys[i].selectP = (double)citys[i].fitness/sum;

}

/**
 * 计算期望概率
*/
private void CalExceptP(){
 for( int i = 0; i< popSize; i++)
 citys[i].exceptp = (double)citys[i].selectP * popSize;
 }

/**
 * 计算该城市序列是否较优，较优则被选择，进入下一代
*/
private void CalIsSelected(){
 int needSelecte = popSize;
 for( int i = 0; i< popSize; i++)
 if( citys[i].exceptp<1){
 citys[i].isSelected++;
 needSelecte --;
 }
 double[] temp = new double[popSize];
 for (int i = 0; i < popSize; i++) {
 // temp[i] = citys[i].exceptp - (int) citys[i].exceptp;
 // temp[i] *= 10;
 temp[i] = citys[i].exceptp*10;
 }
 int j = 0;
 while (needSelecte != 0) {
 for (int i = 0; i < popSize; i++) {
 if ((int) temp[i] == j) {
 citys[i].isSelected++;
 needSelecte--;
 if (needSelecte == 0)
 break;
 }
 }
 j++;
 }

}

/**
 * @param x
 * @return 判断一个数是否是素数的函数
*/
private boolean isSushu( int x){
 if(x<2) return false;
 for(int i=2;i<=x/2;i++)
 if(x%i==0&&x!=2) return false;

return true;
 }

/**
 * @param x 数组
* @return x数组的值是否全部相等，相等则表示x.length代的最优结果相同，则算法结束
*/
private boolean isSame(long[] x){
 for( int i = 0; i< x.length -1; i++)
 if(x[i] !=x[i+1])
 return false;
 return true;
 }

/**
 * 打印任意代最优的路径序列
*/
private void printBestRoute(){
 CalAll();
 long temp = citys[0].fitness;
 int index = 0;
 for (int i = 1; i < popSize; i++) {
 if(citys[i].fitness<temp){
 temp = citys[i].fitness;
 index = i;
 }
 }
 System.out.println();
 System.out.println("最佳路径的序列：");
for (int j = 0; j < cityNum; j++)
 {
 String cityEnd[]={cityName[citys[index].city[j]]};
 for(int m=0;m<cityEnd.length;m++)
 {
 System.out.print(cityEnd[m] + " ");
 }
 }

//System.out.print(citys[index].city[j] + cityName[citys[index].city[j]] + " ");
 //System.out.print(cityName[citys[index].city[j]]);
 System.out.println();
 }

/**
 * 算法执行
*/
public void run(){
 long[] result = new long[range];
 //result初始化为所有的数字都不相等
for( int i = 0; i< range; i++)
 result[i] = i;
 int index = 0; //数组中的位置
int num = 1; //第num代
while(maxgens>0){
 System.out.println("----------------- 第 "+num+" 代 -------------------------");
CalAll();
 print();
 pad();
 crossover();
 mutate();
 maxgens --;
 long temp = citys[0].fitness;
 for ( int i = 1; i< popSize; i++)
 if(citys[i].fitness<temp){
 temp = citys[i].fitness;
 }
 System.out.println("最优的解："+temp);
 result[index] = temp;
 if(isSame(result))
 break;
 index++;
 if(index==range)
 index = 0;
 num++;
 }
 printBestRoute();
 }

/**
 * @param a 开始时间
* @param b 结束时间
*/
public void CalTime(Calendar a,Calendar b){
 long x = b.getTimeInMillis() - a.getTimeInMillis();
 long y = x/1000;
 x = x - 1000*y;
 System.out.println("算法执行时间："+y+"."+x+" 秒");
 }

/**
 * 程序入口
*/
public static void main(String[] args) {

Calendar a = Calendar.getInstance(); //开始时间
Tsp tsp = new Tsp();
 tsp.run();
 Calendar b = Calendar.getInstance(); //结束时间
tsp.CalTime(a, b);

}
 }