遗传算法解决网络布线问题 tsp

// File: CgaTsp.h the head of class
#ifndef GATSP_H
#define GATSP_H

#include <vector>
#include <fstream>
#include <algorithm>
#include <iostream>
using namespace std;



// 变异概率
#define MUTATION_RATE       0.2

// 杂交概率
#define CROSSOVER_RATE  0.75

// 基因组数目
#define POP_SIZE              40

// 为2的倍数
#define NUM_BEST_TO_ADD 2

// 产生随机数
inline int    RandInt(int x,int y)
{

    return rand()%(y-x+1)+x;
}
inline double RandFloat()
{

    return (rand())/(RAND_MAX+1.0);
}

// 计算机坐标结构
struct CoOrd
{
        float x,y;
        CoOrd(){};
        CoOrd(float a, float b):x(a),y(b){};
};

// 基因组结构
struct SGenome
{
    // 连接计算机间的路径（基因组）
    vector<int>     vecPC;

   // 适应分数
  double         dFitness;


    // 构造函数
    SGenome():dFitness(0){}

    SGenome(int nc): dFitness(0)
    {
        vecPC = GrabPermutation(nc);
    }

    // 创建计算机间随机的一条路径
    vector<int> GrabPermutation(int &limit);

    // 在GrabPermutation函数中使用
    bool        TestNumber(const vector<int> &vec, const int &number);

};


// 遗传算法类
class CgaTSP
{
private:

    // 计算机坐标向量
    vector<CoOrd> m_vecPCCoOrds;
    vector<SGenome>     m_vecPopulation;
    vector<int>  m_savevecPC;


    double              m_dMutationRate;

    double              m_dCrossoverRate;

    // 整个种子群体的总适应性分
    double              m_dTotalFitness;

    // 在此之前找到的最短路径
    double              m_dShortestRoute;
    // 把所有代中的最短路径保存起来
    double              m_saveShortestRoute;

    // 最长路径
    double              m_dLongestRoute;

    // 种子群中的基因组数目
    int                   m_iPopSize;

    // 染色体数目
    int                   m_iChromoLength;

    // 新一代中适应分最高的成员
    int                   m_iFittestGenome;

    // 表明已经到了那一代
    int                   m_iGeneration;

    // 交换变异
    void              MutateEM(vector<int> &chromo);



    // 部分匹配杂交
    void              CrossoverPMX(const vector<int> &mum,
                                   const vector<int> &dad,
                                           vector<int>       &baby1,
                                           vector<int>       &baby2);

    SGenome&        RouletteWheelSelection();


    // 计算计算机之间连接路径的长度
     double   GetTourLength(const vector<int> &route);

    void             CalculatePopulationsFitness();

    void             CalculateBestWorstAvTot();

    void             Reset();

    void             CreateStartingPopulation();

    // 计算两个计算之间的长度
    double  CalculateA_to_B(const CoOrd &PC1, const CoOrd &PC2);

    // 建立坐标
    void CreateCoOrd();

public:

    // 构造函数
    CgaTSP(double     mut_rat,
             double   cross_rat,
             int          pop_size,
             int          NumPC
         ):m_dMutationRate(mut_rat),
            m_dCrossoverRate(cross_rat),
            m_iPopSize(pop_size),
                        m_iFittestGenome(0),
                        m_iGeneration(0),
                        m_dShortestRoute(999999999),
                        m_saveShortestRoute(999999999),
                        m_dLongestRoute(0),
                        m_iChromoLength(NumPC)



    {
        // 建立坐标
            CreateCoOrd();
            // 清除基因组生成新的基因组
        CreateStartingPopulation();
    }


    ~CgaTSP()
    {
    }

// 把所有的遗传算法的步骤进行合并到一个函数
  void  Epoch();
  void Show();
};

#endif

//File: CgaTsp.cpp
#include "CgaTSP.h"
#include <math.h>
#include <time.h>
#include <vector>
#include <fstream>
#include <algorithm>
#include <iostream>
using namespace std;

// 随机生成一个基因并返回
vector<int> SGenome::GrabPermutation(int &limit)
{
    vector<int> vecPerm;

    for (int i=0; i<limit; i++)
    {
        // 0到limint-1为计算机的序号
        int NextPossibleNumber = RandInt(0, limit-1);

        // 向量中存在随见生成的序号就在生成一次
        while(TestNumber(vecPerm, NextPossibleNumber))
        {
            NextPossibleNumber = RandInt(0, limit-1);
        }

        // 把新生成的序号放进向量
        vecPerm.push_back(NextPossibleNumber);
    }

    // 返回基因
    return vecPerm;
}

// 测试number是否已经存在向量中
bool SGenome::TestNumber(const vector<int> &vec, const int &number)
{
    for (int i=0; i<vec.size(); ++i)
    {
        if (vec[i] == number)
        {
            return true;
        }
    }

    return false;
}

// 计算路径长度和适应性分
void CgaTSP::CalculatePopulationsFitness()
{
    // 对于每组基因计算路径长度
    for (int i=0; i<m_iPopSize; ++i)
    {

        // 计算计算机间路径的总长度
        double TourLength = GetTourLength(m_vecPopulation[i].vecPC);


        m_vecPopulation[i].dFitness = TourLength;


        if (TourLength < m_dShortestRoute)
        {
            m_dShortestRoute = TourLength;

            // 代表适应性分最高的成员
            m_iFittestGenome = i;
        }


        if (TourLength > m_dLongestRoute)
        {
            m_dLongestRoute = TourLength;
        }

    }

    // 计算适应性分
    for (i=0; i<m_iPopSize; ++i)
    {
        m_vecPopulation[i].dFitness =
        m_dLongestRoute - m_vecPopulation[i].dFitness;
    }

}

// 计算两个计算机之间的路径长度
double CgaTSP::CalculateA_to_B(const CoOrd &PC1, const CoOrd &PC2)
{
    double xDist = PC1.x - PC2.x;
    double yDist = PC1.y - PC2.y;

    return sqrt(xDist*xDist + yDist*yDist);
}

// 计算所有计算机连接起来的路径长度
double CgaTSP::GetTourLength(const vector<int> &route)
{
    double TotalDistance = 0;

    for (int i=0; i<route.size()-1; ++i)
    {
        int PC1 = route[i];
        int PC2 = route[i+1];

        TotalDistance += CalculateA_to_B(m_vecPCCoOrds[PC1], m_vecPCCoOrds[PC2]);
    }
    // 返回总的路径长度
    return TotalDistance;
}

// 选择基因(轮盘赌选择法)
SGenome& CgaTSP::RouletteWheelSelection()
{
    // 随机生成0到1的数乘以总的适应性分
    double fSlice   = RandFloat() * m_dTotalFitness;

    double cfTotal  = 0.0;

    int SelectedGenome = 0;

    for (int i=0; i<m_iPopSize; ++i)
    {
        // 累计适应性分
        cfTotal += m_vecPopulation[i].dFitness;

        if (cfTotal > fSlice)
        {
            SelectedGenome = i;

            break;
        }
    }

    return m_vecPopulation[SelectedGenome];
}


void ChooseSection(int &beg,
                   int &end,
                   const int vec_size,
                   const int min_span)
{

    beg = RandInt(0, vec_size-1-min_span);

    end = beg;

    //find an end
    while (end <= beg)
    {
        end = RandInt(0, vec_size-1);
    }
}

// 交换变异操作（随机基因进行交换）
void CgaTSP::MutateEM(vector<int> &chromo)
{
    // 根据变异率确定是否发生变异
    if (RandFloat() > m_dMutationRate)
        return;

    // 选择第一个基因(计算机)
    int pos1 = RandInt(0, chromo.size()-1);

    // 选择第二个基因(计算机)
    int pos2 = pos1;

    while (pos1 == pos2)
    {
        pos2 = RandInt(0, chromo.size()-1);
    }

    // 交换位置
    swap(chromo[pos1], chromo[pos2]);
}

// 置换杂交
void CgaTSP::CrossoverPMX(const vector<int> &mum,
                                        const vector<int>   &dad,
                                        vector<int>       &baby1,
                                        vector<int>       &baby2)
{
    baby1 = mum;
    baby2 = dad;

    // 杂交率
    if ( (RandFloat() > m_dCrossoverRate) || (mum == dad))
    {
        return;
    }

    // 选择基因组的一节
    int beg = RandInt(0, mum.size()-2);

    int end = beg;

    // 在选择另一节
    while (end <= beg)
    {
        end = RandInt(0, mum.size()-1);
    }


    vector<int>::iterator posGene1, posGene2;

    for (int pos = beg; pos < end+1; ++pos)
    {
        // 交换的两个基因
        int gene1 = mum[pos];
        int gene2 = dad[pos];

        if (gene1 != gene2)
        {
            // 在第一个后代中进行交换
            posGene1 = find(baby1.begin(), baby1.end(), gene1);
            posGene2 = find(baby1.begin(), baby1.end(), gene2);

            swap(*posGene1, *posGene2);

            // 在第二个后代中进行交换
            posGene1 = find(baby2.begin(), baby2.end(), gene1);
            posGene2 = find(baby2.begin(), baby2.end(), gene2);

            swap(*posGene1, *posGene2);
        }

    }// 下一对基因
}

// 清除基因组生成新的基因组
void CgaTSP::CreateStartingPopulation()
{

    m_vecPopulation.clear();

    // 基因组数目
    for (int i=0; i<m_iPopSize; ++i)
    {
        m_vecPopulation.push_back(SGenome(m_iChromoLength));
    }
    m_iGeneration    = 0;
    m_dShortestRoute = 9999999;
    m_iFittestGenome = 0;

}

void CgaTSP::Reset()
{

    m_dShortestRoute    = 999999999;
    m_dLongestRoute     = 0;
    m_dTotalFitness     = 0;
}

void CgaTSP::Epoch()
{

    // 设置变量
    Reset();

    // 计算每个基因组的适应性分
    CalculatePopulationsFitness();
    if (m_dShortestRoute < m_saveShortestRoute)
    {
        m_saveShortestRoute = m_dShortestRoute;
        // 把路径保存下来
         m_savevecPC = m_vecPopulation[m_iFittestGenome].vecPC;

    }

    // 为新种群创建临时向量
    vector<SGenome> vecNewPop;

    // 把上一代中最适应的精英加入到种群
    for (int i=0; i<NUM_BEST_TO_ADD; ++i)
    {
        vecNewPop.push_back(m_vecPopulation[m_iFittestGenome]);
    }


    // 创建种群的其他成员
    while (vecNewPop.size() != m_iPopSize)
    {

        // 选取两个基因作为父代
        SGenome mum = RouletteWheelSelection();
        SGenome dad = RouletteWheelSelection();

        // 两个后代
        SGenome baby1, baby2;

        // 进行杂交
        CrossoverPMX(mum.vecPC,
                           dad.vecPC,
                           baby1.vecPC,
                           baby2.vecPC);

        // 变异
        MutateEM(baby1.vecPC);
        MutateEM(baby2.vecPC);

        // 加入新种群
        vecNewPop.push_back(baby1);
        vecNewPop.push_back(baby2);
    }

    // 复制到下一代
    m_vecPopulation = vecNewPop;

    // 代数加一
    ++m_iGeneration;
}

// 建立坐标
void CgaTSP::CreateCoOrd()
{
    CoOrd ThisPC;
    float x;
    float y;
    for (int i=0; i<m_iChromoLength; i++)
    {
        scanf("%f%f", &x,&y);
        ThisPC.x = x;
        ThisPC.y = y;
        m_vecPCCoOrds.push_back(ThisPC);
    }
}

// 输出结果
void CgaTSP::Show()
  {
      int k;
      int p;
    for(int i=0; i<m_iChromoLength-1; i++)
    {
        // 获取相邻两个电脑之间的序号
        k = m_savevecPC[i];
        p = m_savevecPC[i+1];
        printf("Cable requirement to connect(%.0f,%.0f) to (%.0f,%.f) is %.2lf/n",m_vecPCCoOrds[k].x , m_vecPCCoOrds[k].y,
            m_vecPCCoOrds[p].x, m_vecPCCoOrds[p].y, CalculateA_to_B(m_vecPCCoOrds[k], m_vecPCCoOrds[p])+16);
    }
    printf("Number of feet of cable required is%.2lf/n", m_saveShortestRoute + 16*(m_iChromoLength-1));
  }

// 主函数
int main()
{
    CgaTSP* tsp;
    srand( (unsigned)time( NULL ) );
    // 输入计算机数
    int nc;
    int flag=0;
    while(scanf("%d", &nc) && nc !=0)
    {
        // 初始化遗传算法类
        tsp = new CgaTSP(MUTATION_RATE,
                       CROSSOVER_RATE,
                           POP_SIZE,
                        nc);

        // 进行50进化
        for(int i=0; i<50; i++)
        tsp->Epoch();
        printf("Network # %d/n", ++flag);
        tsp->Show();

        // 释放空间
        delete tsp;

    }

        return 0;
}