算法解密：用遗传算法巧妙解决旅行商问题

在现实生活中，旅行商问题经常出现在物流配送、城市规划、旅游线路安排等场景中。旅行商需要辗转多个城市进行业务拜访或货物配送，如何在保证所有城市都被访问到的前提下，找到最短的总旅程？这就是旅行商问题。

遗传算法是一种常用的优化算法，它模拟生物进化的过程，通过不断选择、交叉、变异等操作，寻找问题的最优解。遗传算法解决旅行商问题的主要步骤如下：

1. 初始化种群： 随机生成一组候选解决方案（染色体），每个染色体表示一条可能的旅行路线。
2. 计算适应度： 根据每个染色体的总旅程长度计算适应度，适应度高的染色体有更大的机会被选择。
3. 选择： 根据染色体的适应度进行选择，适应度高的染色体更有可能被选中，进入下一代。
4. 交叉： 将两个被选中的染色体进行交叉操作，生成新的染色体，以探索新的解决方案。
5. 变异： 对新生成的染色体进行变异操作，以引入新的基因，增加种群的多样性。
6. 重复步骤2-5： 重复步骤2-5，直到达到预定的进化代数或找到令人满意的解。

在JavaScript中，我们可以使用如下代码实现遗传算法解决旅行商问题：

// 城市数据
const cities = [
  { name: "北京", x: 116.40, y: 39.90 },
  { name: "上海", x: 121.48, y: 31.22 },
  { name: "广州", x: 113.23, y: 23.16 },
  { name: "深圳", x: 114.07, y: 22.54 },
  { name: "成都", x: 104.06, y: 30.67 }
];

// 计算两个城市之间的距离
function distance(city1, city2) {
  const dx = city1.x - city2.x;
  const dy = city1.y - city2.y;
  return Math.sqrt(dx * dx + dy * dy);
}

// 初始化种群
const populationSize = 100;
const chromosomes = [];
for (let i = 0; i < populationSize; i++) {
  const chromosome = [];
  for (let j = 0; j < cities.length; j++) {
    chromosome.push(j);
  }
  // 打乱染色体顺序
  shuffle(chromosome);
  chromosomes.push(chromosome);
}

// 计算适应度
function fitness(chromosome) {
  let totalDistance = 0;
  for (let i = 0; i < chromosome.length - 1; i++) {
    const city1 = cities[chromosome[i]];
    const city2 = cities[chromosome[i + 1]];
    totalDistance += distance(city1, city2);
  }
  // 返回适应度（总距离的倒数）
  return 1 / totalDistance;
}

// 选择
function selection() {
  const selectedChromosomes = [];
  for (let i = 0; i < populationSize; i++) {
    // 根据适应度选择染色体
    const randomValue = Math.random();
    let sum = 0;
    let selectedChromosomeIndex = -1;
    for (let j = 0; j < chromosomes.length; j++) {
      sum += fitness(chromosomes[j]);
      if (randomValue < sum) {
        selectedChromosomeIndex = j;
        break;
      }
    }
    selectedChromosomes.push(chromosomes[selectedChromosomeIndex]);
  }
  return selectedChromosomes;
}

// 交叉
function crossover(chromosome1, chromosome2) {
  const newChromosome = [];
  const crossoverPoint = Math.floor(Math.random() * chromosome1.length);
  for (let i = 0; i < crossoverPoint; i++) {
    newChromosome.push(chromosome1[i]);
  }
  for (let i = crossoverPoint; i < chromosome2.length; i++) {
    if (!newChromosome.includes(chromosome2[i])) {
      newChromosome.push(chromosome2[i]);
    }
  }
  return newChromosome;
}

// 变异
function mutation(chromosome) {
  const mutationPoint1 = Math.floor(Math.random() * chromosome.length);
  const mutationPoint2 = Math.floor(Math.random() * chromosome.length);
  const temp = chromosome[mutationPoint1];
  chromosome[mutationPoint1] = chromosome[mutationPoint2];
  chromosome[mutationPoint2] = temp;
  return chromosome;
}

// 主循环
const maxGenerations = 100;
let bestChromosome = chromosomes[0];
let bestDistance = fitness(bestChromosome);
for (let generation = 0; generation < maxGenerations; generation++) {
  // 选择
  const selectedChromosomes = selection();

  // 交叉
  const newChromosomes = [];
  for (let i = 0; i < populationSize; i += 2) {
    const chromosome1 = selectedChromosomes[i];
    const chromosome2 = selectedChromosomes[i + 1];
    const newChromosome = crossover(chromosome1, chromosome2);
    newChromosomes.push(newChromosome);
  }

  // 变异
  for (let i = 0; i < populationSize; i++) {
    const chromosome = newChromosomes[i];
    const mutatedChromosome = mutation(chromosome);
    newChromosomes[i] = mutatedChromosome;
  }

  // 计算新种群的适应度
  for (let i = 0; i < populationSize; i++) {
    const chromosome = newChromosomes[i];
    const distance = fitness(chromosome);
    if (distance > bestDistance) {
      bestDistance = distance;
      bestChromosome = chromosome;
    }
  }

  // 替换旧种群
  chromosomes = newChromosomes;

  // 打印最佳解