利用遗传算法解决TSP问题c++

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define PMX
#define PC        0.70            //杂交率
#define PM        0.04             //变异率
#define CITY_SIZE 50              //城市数
#define POP_SIZE  1000              //种群规模
#define NEW_SIZE  （POP_SIZE/2）      //用于重组的个体数
#define GEN_TOTAL 10000             //总遗传代数

void Initialize（int Pop[][CITY_SIZE] int Count）;
void Evaluate（int Pop[][CITY_SIZE] int EvalVal[] int Count）;
void ParentSelect（int Pop[][CITY_SIZE] int EvalVal[] int Count）;
void Recombine（int Pop[][CITY_SIZE] int Count）;
void Mutate（int Pop[][CITY_SIZE] int Count）;
int  GetBestPathIndex（int EvalVal[] int Count）;
void ShowBestResult（int Path[] int Len int Gen）;
void ShowPath（int Path[][CITY_SIZE] int Count）;
void TSPProc（）;

int main（int argc char *argv[]）
{
  void TSPProc（）;
  TSPProc（）;
  printf（“\nFinish searching!“）;
  getch（）;
  return 0;
}

void TSPProc（）
{
  //使用一个整型数组表示每条路径  
  int Pop[POP_SIZE][CITY_SIZE];
  int BestEval BestPath[CITY_SIZE];
  //对路径的评估使用整型数表示，忽略小数部分
  int EvalVal[POP_SIZE];

  Initialize（Pop POP_SIZE）;
  Evaluate（Pop EvalVal POP_SIZE）;
  
  int t = GetBestPathIndex（EvalVal POP_SIZE）;  
  memmove（BestPath Pop[t] sizeof（int） * CITY_SIZE）;
  BestEval = EvalVal[t];
  ShowBestResult（BestPath BestEval 0）;

  t = 1;
  while（t < GEN_TOTAL）
  {
    ParentSelect（Pop EvalVal POP_SIZE）;
    Recombine（Pop POP_SIZE）;
    Mutate（Pop POP_SIZE）;
    Evaluate（Pop EvalVal POP_SIZE）;

    printf（“\rCurrent generation:%d“ t）;
    int Index = GetBestPathIndex（EvalVal POP_SIZE）;
    if（EvalVal[Index] < BestEval）
    {      
      BestEval = EvalVal[Index];
      memmove（BestPath Pop[Index] sizeof（int） * CITY_SIZE）;
      printf（“\r“）;
      ShowBestResult（BestPath BestEval t）;
    }    
    t++;
  }
}

//初始化种群
void Initialize（int Pop[][CITY_SIZE] int Count）
{
  int i j;
  int Seed[CITY_SIZE];  

  srand（time（NULL））;
  for（i = 0; i < Count; i++）
  {
    for（j = 0; j < CITY_SIZE; j++）
      Seed[j] = j; 

    //随机产生一条路径
    for（j = 0; j < CITY_SIZE; j++）
    {
      int RandIdx = rand（） % （CITY_SIZE - j）;
      Pop[i][j] = Seed[RandIdx];
      Seed[RandIdx] = Seed[CITY_SIZE - j - 1];
    }
  }
}

//评估路径Pop，结果放入EvalVal
void Evaluate（int Pop[][CITY_SIZE] int EvalVal[] int Count）
{
  static int Matrix[CITY_SIZE][CITY_SIZE];
  static bool bInitMatrix;

  int i j;
  char Str[256];
  //先检查邻接矩阵是否已初始化
  if（!bInitMatrix）
  {
    bool bInit = false;
    FILE *pFile = fopen（“d:\\tsp.txt“ “r“）;
    if（pFile）
    {
      bInit = true;
      for（i = 0; i < CITY_SIZE; i++）
      {
        for（j = 0; j < CITY_SIZE; j++）
        {          
          if（!fgets（Str 64 pFile））
          {
            bInit = false;
            break;
          }
          Matrix[i][j] = atoi（Str）;//将字符串转换