Copie el código de código de la siguiente manera:
importar java.util.*;
cucharadita de clase pública {
private String cityName[]={"Beijing","Shanghai","Tianjin","Chongqing","Harbin","Changchun","Shenyang","Hohhot","Shijiazhuang","Taiyuan","Jinan" ,"Zhengzhou","Xi'an","Lanzhou","Yinchuan","Xining","Urumqi","Hefei","Nanjing","Hangzhou","Changsha","Nanchang","Wuhan" ," Chengdu","Guizhou","Fujian","Taipei","Guangzhou","Haikou","Nanning","Kunming","Lhasa","Hong Kong","Macao"};
//cadena privada cityEnd[]=new String[34];
private int cityNum=cityName.length;//Número de ciudades
private int popSize = 50 //Tamaño de la población
private int maxgens = 20000 //Número de iteraciones
pxover doble privado = 0,8; //probabilidad de cruce
doble pmulación privada = 0,05 //Probabilidad de mutación
privado larga[][] distancia = new larga[cityNum][cityNum];
private int range = 2000; //rango de matriz utilizado para determinar cuándo detenerse
genotipo de clase privada {
int ciudad[] = new int[cityNum]; //Secuencia de ciudad de un solo gen
fitness largo //Fitness de este gen
double selectP //Probabilidad de selección
doble excepciónp; //probabilidad esperada
int isSelected //Si está seleccionado
}
genotipo privado[] ciudades = nuevo genotipo[popSize];
/**
* Constructor, inicializa la población.
*/
cucharadita pública() {
para (int i = 0; i < popSize; i++) {
ciudades[i] = nuevo genotipo();
int[] número = nuevo int[ciudadNum];
para (int j = 0; j < numciudad; j++)
número[j] = j;
int temp = númciudad;
for (int j = 0; j < númciudad; j++) {
int r = (int) (Math.random() * temp);
ciudades[i].ciudad[j] = num[r];
número[r] = número[temp - 1];
temperatura--;
}
ciudades[i].fitness = 0;
ciudades[i].selectP = 0;
ciudades[i].exceptp = 0;
ciudades[i].isSelected = 0;
}
distanciainit();
}
/**
* Calcular la aptitud, la probabilidad de selección, la probabilidad esperada y si se selecciona para cada individuo genético en cada población.
*/
CalAll vacío público(){
para(int i = 0; i< popSize; i++){
ciudades[i].fitness = 0;
ciudades[i].selectP = 0;
ciudades[i].exceptp = 0;
ciudades[i].isSelected = 0;
}
CalFitness();
CalSelectP();
CalExceptP();
CalIsSelected();
}
/**
* Complete, complete múltiples selecciones en individuos no seleccionados
*/
almohadilla vacía pública(){
int mejor = 0;
int malo = 0;
mientras (verdadero) {
while(ciudades[mejores].isSelected <= 1 && mejor<popSize-1)
mejor++;
while(ciudades[malas].isSelected!= 0 && malas<popSize-1)
malo++;
para(int i = 0; i< númciudad; i++)
ciudades[mala].ciudad[i] = ciudades[mejor].ciudad[i];
ciudades[mejores].isSelected --;
ciudades[malas].isSelected++;
malo++;
if(mejor == popSize ||malo == popSize)
romper;
}
}
/**
* Función cruzada
*/
cruce de vacío público () {
intx;
int y;
int pop = (int)(tamañopop* pxover /2);
mientras(pop>0){
x = (int)(Math.random()*popSize);
y = (int)(Math.random()*popSize);
ejecutarCrossover(x,y);//xy dos entidades ejecutan cruce
estallido--;
}
}
/**
* Ejecutar función de cruce
* @param individuo x
* @param individual y
* Realizar la intersección de los mejores conjuntos de puntos para el individuo x y el individuo y para generar la secuencia de ciudades de próxima generación
*/
ejecución nula privadaCrossover(int x,int y){
dimensión interna = 0;
para( int i = 0 ;i < numciudad; i++)
if(ciudades[x].ciudad[i] != ciudades[y].ciudad[i]){
dimensión++;
}
int elemento diferencial = 0;
doble[] diff = nuevo doble[dimensión];
for( int i = 0 ;i < numciudad; i++){
if(ciudades[x].ciudad[i] != ciudades[y].ciudad[i]){
diff[diffItem] = ciudades[x].ciudad[i];
ciudades[x].ciudad[i] = -1;
ciudades[y].ciudad[i] = -1;
diferenciaArtículo++;
}
}
Arrays.sort(diff);
doble[] temp = nuevo doble[dimensión];
temperatura = gp(x, dimensión);
para(int k = 0; k< dimensión;k++)
para(int j = 0; j< dimensión; j++)
si(temperatura[j] == k){
elemento doble = temp[k];
temperatura[k] = temperatura[j];
temp[j] = artículo;
elemento = diferencia[k];
diferencia[k] = diferencia[j];
diferencia[j] = elemento;
}
int tempDimensión = dimensión;
int tiempos = 0;
mientras (dimensión temporal> 0) {
if(ciudades[x].ciudad[tempi] == -1){
ciudades[x].ciudad[tempi] = (int)diff[dimensión - tempDimension];
dimensión temporal --;
}
tiempos++;
}
Arrays.sort(diff);
temp = gp(y, dimensión);
para(int k = 0; k< dimensión;k++)
para(int j = 0; j< dimensión; j++)
si(temp[j] == k){
elemento doble = temp[k];
temperatura[k] = temperatura[j];
temp[j] = artículo;
elemento = diferencia[k];
diferencia[k] = diferencia[j];
diferencia[j] = elemento;
}
tempDimensión = dimensión;
tiempos = 0;
mientras (dimensión temporal> 0) {
if(ciudades[y].ciudad[tempi] == -1){
ciudades[y].ciudad[tempi] = (int)diff[dimensión - tempDimension];
dimensión temporal --;
}
tiempos++;
}
}
/**
* @param individuo individuo
* @param dimensión dimensión
* @return El mejor conjunto de puntos (el punto de intersección utilizado para la función cruzada) se utiliza en la función ejecutarCrossover()
*/
doble privado[] gp(int individual, int dimensión){
doble[] temp = nuevo doble[dimensión];
doble[] temp1 = nuevo doble[dimensión];
int p = 2 * dimensión + 3;
mientras(!isSushu(p))
p++;
for(int i = 0; i< dimensión; i++){
temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (individual+1);
temperatura[i] = temperatura[i] - (int)temp[i];
si(temperatura[i]<0)
temperatura[i] = 1+temperatura[i];
}
para(int i = 0; i< dimensión; i++)
temp1[i] = temperatura[i];
Arrays.sort(temp1);
//Clasificar
para(int i = 0; i< dimensión; i++)
para(int j = 0; j< dimensión; j++)
si(temperatura[j]==temp1[i])
temperatura[j] = yo;
temperatura de retorno;
}
/**
* Mutaciones
*/
mutación de vacío público(){
doble aleatorio;
temperatura interna;
inttemp1;
int temp2;
para(int i = 0; i< popSize; i++){
aleatorio = Math.random();
if(aleatorio<=multación){
temp1 = (int)(Math.random() * (cityNum));
temp2 = (int)(Math.random() * (cityNum));
temp = ciudades[i].ciudad[temp1];
ciudades[i].ciudad[temp1] = ciudades[i].ciudad[temp2];
ciudades[i].ciudad[temp2] = temp;
}
}
}
/**
* Imprime todas las secuencias de ciudades del álgebra actual y sus parámetros relacionados.
*/
impresión pública vacía(){
/**
* Inicializar la distancia entre ciudades.
*/
distancia init vacía privada(){
for (int i = 0; i < númciudad; i++) {
for (int j = 0; j < númciudad; j++){
distancia[i][j] = Math.abs(ij);
}
}
}
/**
* Calcular la aptitud de todas las secuencias de la ciudad.
*/
vacío privado CalFitness() {
para (int i = 0; i < popSize; i++) {
para (int j = 0; j < cityNum - 1; j++)
ciudades[i].fitness += distancia[ciudades[i].ciudad[j]][ciudades[i].ciudad[j + 1]];
ciudades[i].fitness += distancia[ciudades[i].ciudad[0]][ciudades[i].ciudad[cityNum - 1]];
}
}
/**
* Calcular la probabilidad de selección.
*/
vacío privado CalSelectP(){
suma larga = 0;
para(int i = 0; i< popSize; i++)
suma += ciudades[i].fitness;
para(int i = 0; i< popSize; i++)
ciudades[i].selectP = (doble)ciudades[i].fitness/suma;
}
/**
* Calcular la probabilidad esperada
*/
vacío privado CalExceptP(){
para(int i = 0; i< popSize; i++)
ciudades[i].exceptp = (doble)ciudades[i].selectP * popSize;
}
/**
* Calcule si la secuencia de la ciudad es mejor, se seleccionará la mejor e ingresará a la siguiente generación
*/
vacío privado CalIsSelected(){
int needSelecte = popSize;
para(int i = 0; i< popSize; i++)
if( ciudades[i].exceptp<1){
ciudades[i].isSelected++;
necesitaSeleccionar --;
}
doble[] temp = nuevo doble[popSize];
para (int i = 0; i < popSize; i++) {
// temp[i] = ciudades[i].exceptp - (int) ciudades[i].exceptp;
// temperatura[i] *= 10;
temp[i] = ciudades[i].exceptp*10;
}
int j = 0;
mientras (necesitaSelecte! = 0) {
para (int i = 0; i < popSize; i++) {
si ((int) temp[i] == j) {
ciudades[i].isSelected++;
needSelecte--;
si (necesitaSeleccionar == 0)
romper;
}
}
j++;
}
}
/**
* @param x
* Función @return para determinar si un número es primo
*/
booleano privado esSushu(int x){
si(x<2) devuelve falso;
para(int i=2;i<=x/2;i++)
if(x%i==0&&x!=2) devuelve falso;
devolver verdadero;
}
/**
* @param x matriz
* @return Si los valores de la matriz x son todos iguales. Si son iguales, significa que el resultado óptimo de la generación de x.length es el mismo y el algoritmo finaliza.
*/
booleano privado es igual (largo [] x) {
para(int i = 0; i< x.length -1; i++)
si(x[i] !=x[i+1])
devolver falso;
devolver verdadero;
}
/**
* Imprime la secuencia de ruta óptima para cualquier generación.
*/
printBestRoute vacío privado(){
Llamar a todos();
larga temperatura = ciudades[0].fitness;
índice int = 0;
para (int i = 1; i < popSize; i++) {
if(ciudades[i].fitness<temp){
temp = ciudades[i].fitness;
índice = i;
}
}
Sistema.out.println();
System.out.println("Mejor secuencia de ruta:");
para (int j = 0; j < numciudad; j++)
{
String cityEnd[]={cityName[citys[index].city[j]]};
para(int m=0;m<cityEnd.length;m++)
{
System.out.print(cityEnd[m] + " ");
}
}
//System.out.print(ciudades[índice].ciudad[j] + nombreciudad[ciudades[índice].ciudad[j]] + " ");
//System.out.print(nombreciudad[ciudades[índice].ciudad[j]]);
Sistema.out.println();
}
/**
* Ejecución del algoritmo
*/
ejecución pública vacía(){
resultado largo[] = nuevo largo[rango];
//el resultado se inicializa para que todos los números no sean iguales
para(int i = 0; i< rango; i++)
resultado[i] = yo;
int index = 0; //Posición en la matriz
int num = 1; //Núm. generación
mientras(maxgens>0){
System.out.println("----------------- "+num+" generación-------------------- - ----");
Llamar a todos();
imprimir();
almohadilla();
cruce();
mudar();
maxgens --;
larga temperatura = ciudades[0].fitness;
para (int i = 1; i< popSize; i++)
if(ciudades[i].fitness<temp){
temp = ciudades[i].fitness;
}
System.out.println("Solución óptima: "+temp);
resultado[índice] = temporal;
si (es igual (resultado))
romper;
índice++;
si(índice==rango)
índice = 0;
número++;
}
imprimirMejorRuta();
}
/**
* @param una hora de inicio
* @param b hora de finalización
*/
public void CalTime(Calendario a,Calendario b){
largo x = b.getTimeInMillis() - a.getTimeInMillis();
largo y = x/1000;
x = x - 1000*y;
System.out.println("Tiempo de ejecución del algoritmo: "+y+"."+x+" segundos");
}
/**
* Entrada al programa
*/
público estático vacío principal (String [] argumentos) {
Calendario a = Calendar.getInstance(); //Hora de inicio
Cucharadita cucharita = nueva Cucharadita();
tsp.run();
Calendario b = Calendar.getInstance(); //Hora de finalización
cucharadita.CalTime(a, b);
}
}