Copie o código do código da seguinte forma:
importar java.util.*;
classe pública Tsp {
private String cityName[]={"Pequim","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","Macau"};
//string privada cityEnd[]=new String[34];
private int cityNum=cityName.length;//Número de cidades
private int popSize = 50; //Tamanho da população
private int maxgens = 20000; //Número de iterações
private double pxover = 0,8; //probabilidade de cruzamento
pmulação dupla privada = 0,05;
privado longa[][] distância = novo longo[cityNum][cityNum];
private int range = 2000; //intervalo do array usado para determinar quando parar
genótipo de classe privada {
int city[] = new int[cityNum]; //Sequência de cidade de um único gene
aptidão longa; //Aptidão deste gene
double selectP; //Probabilidade de seleção
double exceptp; //probabilidade esperada
int isSelected; //Se está selecionado
}
genótipo privado[] cidades = novo genótipo[popSize];
/**
* Construtor, inicialize a população
*/
public Tsp() {
for (int i = 0; i < popSize; i++) {
cidades[i] = novo genótipo();
int[] num = new int[cityNum];
for (int j = 0; j < cidadeNum; j++)
num[j] = j;
int temp = cidadeNum;
for (int j = 0; j <Numcidade; j++) {
int r = (int) (Math.random() * temp);
cidades[i].cidade[j] = num[r];
num[r] = num[temp - 1];
temperatura--;
}
cidades[i].fitness = 0;
cidades[i].selectP = 0;
cidades[i].excetop = 0;
cidades[i].isSelected = 0;
}
distânciainicial();
}
/**
* Calcule a aptidão, a probabilidade de seleção, a probabilidade esperada e se ela é selecionada para cada indivíduo genético em cada população.
*/
public void CalAll(){
for(int i = 0; i< popSize; i++){
cidades[i].fitness = 0;
cidades[i].selectP = 0;
cidades[i].excetop = 0;
cidades[i].isSelected = 0;
}
CalFitness();
CalSelectP();
CalExceptP();
CalIsSelected();
}
/**
* Preencha, preencha várias seleções em indivíduos não selecionados
*/
bloco de vazio público(){
int melhor = 0;
int ruim = 0;
enquanto(verdadeiro){
while(cidades[melhor].isSelected <= 1 && melhor<popSize-1)
melhor++;
while(citys[bad].isSelected != 0 && bad<popSize-1)
ruim++;
for(int i = 0; i< cidadeNum; i++)
cidades[ruim].cidade[i] = cidades[melhor].cidade[i];
cidades[melhor].isSelected --;
cidades[ruim].isSelected++;
ruim++;
if(melhor == popSize ||ruim == popSize)
quebrar;
}
}
/**
* Função de assunto cruzado
*/
cruzamento de vazio público() {
interno x;
interno;
int pop = (int)(popSize* pxover /2);
enquanto(pop>0){
x = (int)(Math.random()*popSize);
y = (int)(Math.random()*popSize);
executeCrossover(x,y); //xy duas entidades executam cruzamento
pop--;
}
}
/**
* Executar função de cruzamento
* @param indivíduo x
* @param indivíduo y
* Realize a interseção dos melhores conjuntos de pontos para o indivíduo x e o indivíduo y para gerar a sequência de cidades da próxima geração
*/
private void executeCrossover(int x,int y){
dimensão interna = 0;
for(int i = 0 ;i < cidadeNum; i++)
if(cidades[x].cidade[i] != cidades[y].cidade[i]){
dimensão++;
}
int diffItem = 0;
double[] diff = new double[dimensão];
for( int i = 0 ;i < númerocidade; i++){
if(cidades[x].cidade[i] != cidades[y].cidade[i]){
diff[diffItem] = cidades[x].cidade[i];
cidades[x].cidade[i] = -1;
cidades[y].cidade[i] = -1;
item diferente++;
}
}
Arrays.sort(diff);
double[] temp = new double[dimensão];
temp = gp(x, dimensão);
for(int k = 0; k< dimensão;k++)
for(int j = 0; j< dimensão; j++)
if(temp[j] == k){
item duplo = temp[k];
temperatura[k] = temperatura[j];
temp[j] = item;
item = diferença[k];
diferença[k] = diferença[j];
diferença[j] = item;
}
int tempDimension = dimensão;
int tempi = 0;
while(tempDimension> 0 ){
if(cidades[x].cidade[tempi] == -1){
cidades[x].cidade[tempi] = (int)diff[dimensão - tempDimension];
dimensão temporária --;
}
tempo++;
}
Arrays.sort(diff);
temp = gp(y, dimensão);
for(int k = 0; k< dimensão;k++)
for(int j = 0; j< dimensão; j++)
if(temp[j] == k){
item duplo = temp[k];
temperatura[k] = temperatura[j];
temp[j] = item;
item = diferença[k];
diferença[k] = diferença[j];
diferença[j] = item;
}
tempDimension = dimensão;
tempo = 0;
while(tempDimension> 0 ){
if(cidades[y].cidade[tempi] == -1){
cidades[y].cidade[tempi] = (int)diff[dimensão - tempDimension];
dimensão temporária --;
}
tempo++;
}
}
/**
* @param indivíduo indivíduo
* @param dimensão dimensão
* @return O melhor conjunto de pontos (o ponto de interseção usado para a função cruzada) é usado na função executeCrossover()
*/
private double[] gp(int individual, int dimensão){
double[] temp = new double[dimensão];
double[] temp1 = new double[dimensão];
int p = 2 * dimensão + 3;
enquanto(!éSushu(p))
p++;
for(int i = 0; i< dimensão; i++){
temp[i] = 2*Math.cos(2*Math.PI*(i+1)/p) * (indivíduo+1);
temperatura[i] = temperatura[i] - (int)temp[i];
if(temp[i]<0)
temperatura[i] = 1+temp[i];
}
for(int i = 0; i< dimensão; i++)
temperatura1[i] = temperatura[i];
Arrays.sort(temp1);
//Organizar
for(int i = 0; i< dimensão; i++)
for(int j = 0; j< dimensão; j++)
if(temp[j]==temp1[i])
temperatura[j] = eu;
temperatura de retorno;
}
/**
* Mutações
*/
public void mutate(){
duplo aleatório;
temperatura interna;
temperatura interna1;
temperatura interna2;
for(int i = 0; i< popSize; i++){
aleatório = Math.random();
if(aleatório<=pmultação){
temp1 = (int)(Math.random() * (cityNum));
temp2 = (int)(Math.random() * (cityNum));
temp = cidades[i].cidade[temp1];
cidades[i].cidade[temp1] = cidades[i].cidade[temp2];
cidades[i].cidade[temp2] = temp;
}
}
}
/**
* Imprima todas as sequências de cidades da álgebra atual e seus parâmetros relacionados
*/
impressão pública vazia(){
/**
* Inicialize a distância entre cidades
*/
private void initDistance(){
for (int i = 0; i < cidadeNum; i++) {
for (int j = 0; j <Numcidade; j++){
distância[i][j] = Math.abs(ij);
}
}
}
/**
* Calcule a aptidão de todas as sequências da cidade
*/
private void CalFitness() {
for (int i = 0; i < popSize; i++) {
for (int j = 0; j <cityNum - 1; j++)
cidades[i].fitness += distância[cidades[i].cidade[j]][cidades[i].cidade[j + 1]];
cidades[i].fitness += distância[cidades[i].cidade[0]][cidades[i].cidade[cityNum - 1]];
}
}
/**
* Calcular probabilidade de seleção
*/
private void CalSelectP(){
soma longa = 0;
for(int i = 0; i< popSize; i++)
soma += cidades[i].fitness;
for(int i = 0; i< popSize; i++)
cidades[i].selectP = (duplo)cidades[i].fitness/soma;
}
/**
* Calcule a probabilidade esperada
*/
private void CalExceptP(){
for(int i = 0; i< popSize; i++)
cidades[i].exceptp = (duplo)cidades[i].selectP * popSize;
}
/**
* Calcule se a sequência da cidade é melhor, a melhor será selecionada e entrará na próxima geração
*/
private void CalIsSelected(){
int needSelecte = popSize;
for(int i = 0; i< popSize; i++)
if(cidades[i].exceptp<1){
cidades[i].isSelected++;
precisaSelecionar --;
}
double[] temp = new double[popSize];
for (int i = 0; i < popSize; i++) {
// temp[i] = cidades[i].exceptp - (int) cidades[i].exceptp;
// temp[i] *= 10;
temp[i] = cidades[i].excetop*10;
}
int j = 0;
while (needSelecte! = 0) {
for (int i = 0; i < popSize; i++) {
if ((int) temp[i] == j) {
cidades[i].isSelected++;
precisaSelecionar--;
if (precisaSelecionar == 0)
quebrar;
}
}
j++;
}
}
/**
* @paramx
* Função @return para determinar se um número é primo
*/
booleano privado isSushu(int x){
if(x<2) retorna falso;
para(int i=2;i<=x/2;i++)
if(x%i==0&&x!=2) retorna falso;
retornar verdadeiro;
}
/**
* @param x matriz
* @return Se os valores da matriz x são todos iguais. Se iguais, significa que o resultado ideal da geração de x.length é o mesmo e o algoritmo termina.
*/
private boolean isSame(long[] x){
for(int i = 0; i< x.comprimento -1; i++)
se(x[i] !=x[i+1])
retornar falso;
retornar verdadeiro;
}
/**
* Imprima a sequência de caminho ideal para qualquer geração
*/
private void printBestRoute(){
CalTodos();
longa temperatura = cidades[0].fitness;
índice interno = 0;
for (int i = 1; i < popSize; i++) {
if(cidades[i].fitness<temp){
temp = cidades[i].fitness;
índice = eu;
}
}
System.out.println();
System.out.println("Melhor sequência de caminho:");
for (int j = 0; j < cidadeNum; j++)
{
String cidadeEnd[]={nomedacidade[cidades[index].cidade[j]]};
for(int m=0;m<cityEnd.length;m++)
{
System.out.print(cityEnd[m] + " ");
}
}
//System.out.print(cidades[index].cidade[j] + nomedacidade[cidades[index].cidade[j]] + " ");
//System.out.print(nomedacidade[cidades[index].cidade[j]]);
System.out.println();
}
/**
* Execução de algoritmo
*/
execução nula pública(){
resultado longo[] = novo longo[intervalo];
//o resultado é inicializado para que todos os números não sejam iguais
for(int i = 0; i< intervalo; i++)
resultado[i] = i;
int índice = 0; //Posição na matriz
int num = 1; //Número geração
while(maxgens>0){
System.out.println("----------------- "+num+" geração ----- - ----");
CalTodos();
imprimir();
almofada();
cruzamento();
mutação();
maxgens --;
longa temperatura = cidades[0].fitness;
for (int i = 1; i< popSize; i++)
if(cidades[i].fitness<temp){
temp = cidades[i].fitness;
}
System.out.println("Solução ideal: "+temp);
resultado[índice] = temp;
if(éMesmo(resultado))
quebrar;
índice++;
if(índice==intervalo)
índice = 0;
num++;
}
printBestRoute();
}
/**
* @param um horário de início
* @param b horário de término
*/
public void CalTime(Calendário a,Calendário b){
x longo = b.getTimeInMillis() - a.getTimeInMillis();
y longo = x/1000;
x = x - 1000*y;
System.out.println("Tempo de execução do algoritmo: "+y+"."+x+" segundos");
}
/**
*Entrada no programa
*/
public static void main(String[] args) {
Calendário a = Calendar.getInstance();
Colher de chá = new Colher de chá();
colher de chá.run();
Calendário b = Calendar.getInstance();
colher de chá.CalTime(a, b);
}
}