Genetic Algorithm Primary

    Genome GenAlg:: GetChromoRoulette()  
      
    {  
      
        //产生一个0到人口总适应性评分总和之间的随机数.  
      
        //中m_dTotalFitness记录了整个种群的适应性分数总和)  
      
        double Slice = (random()) * totalFitness;  
      
        //这个基因将承载转盘所选出来的那个个体.  
      
        Genome TheChosenOne;  
      
        //累计适应性分数的和.  
      
        double FitnessSoFar = 0;  
      
        //遍历总人口里面的每一条染色体。  
      
        for (int i=0; i<popSize; ++i)  
      
        {  
      
            //累计适应性分数.  
      
            FitnessSoFar += vecPop[i].fitness;  
      
            //如果累计分数大于随机数,就选择此时的基因.  
      
            if (FitnessSoFar >= Slice)  
      
            {  
      
                TheChosenOne = vecPop[i];  
      
                break;  
      
            }  
      
        }  
      
        //返回转盘选出来的个体基因  
      
        return TheChosenOne;  
      
    }  

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<fstream>
#include<cmath>
#include<ctime>
using namespace std;
typedef long long LL;
/************************City Set************************/
string filename = "berlin52.txt";
#define runs 10
#define groupNum 10
#define cnt 52 //城市数量
const double pc = 0.65;//交配概率
const double mp = 0.35;//变异概率
/*********************************************************/
double edge[cnt][cnt];
double best_tsp = 1e7;
int trace[cnt];

struct City{
    double x, y;
}city[cnt];

struct Group{
    int cities[cnt];
    double tsp;
    double fit;    
}group[groupNum], groupt[groupNum];

void init(){
    int num = 0;
    ifstream fin(filename);
    while(fin>>num){
        fin>>city[num-1].x>>city[num-1].y;
        //cout<<num-1<<" "<<city[num-1].x<<" "<<city[num-1].y<<endl;
    }
    //构造邻接矩阵
    for(int i =0 ; i< cnt ; ++i){
        edge[i][i] = 0;
        for(int j =i+1 ; j< cnt ; ++j){
            edge[j][i] = edge[i][j] = sqrt((city[i].x-city[j].x)*(city[i].x-city[j].x) + (city[i].y-city[j].y)*(city[i].y-city[j].y));
        }
    }
    /*cout<<"邻接矩阵为"<<endl;
    for(int i=0 ; i<cnt ; ++i){
        for(int j =0 ; j<cnt ; ++j){
            cout<<edge[i][j]<<" ";
        }
        cout<<endl;
    }*/
}

void print(){
    for(int i =0 ; i<groupNum ;++i){
        cout<<"Group"<<i<<":";
        for(int j= 0 ; j<cnt ; ++j)    cout<<" "<<group[i].cities[j];
        cout<<endl;
    }
}

void pre_value(){
    srand(time(0));
    /***********************给每个种群初始化**************************/
    for(int i = 0 ; i<groupNum ; ++i){
        int j = 0; 
        for(int k = 0 ; k< cnt ; ++k){
            group[i].cities[k] = -1;
        }
        while( j<cnt ){
            int x = rand()%cnt ;
            if(group[i].cities[x] == -1){
                group[i].cities[x] = j;
                ++j;
            }
        }
    }
    /********************打印种群*****************************/
    cout<<"Initial Population："<<endl;
    for(int i=0 ; i<groupNum ; ++i){
        cout<<"Group"<<i<<":";
        for(int j=0 ;j<cnt ; ++j){
            cout<<group[i].cities[j]<<" ";
        }
        cout<<endl;
    }
    //system("pause");
}

void fitness(){
    /*************************计算种群总路径*****************************/
    double sum_dis = 0;
    for(int i=0 ; i< groupNum ; ++i){
        group[i].tsp = 0;
        group[i].fit = 0;
    }
    for(int i =0 ; i<groupNum ; ++i){
        for(int j=0 ; j<cnt ; ++j){
            if(j == cnt -1){
                group[i].tsp += edge[group[i].cities[cnt-1]][group[i].cities[0]];
            }
            else group[i].tsp += edge[group[i].cities[j]][group[i].cities[j+1]];
        }
        sum_dis += group[i].tsp;
    }
    /*************************计算每个种群的存活几率***********************/
    double sum_fit = 0;
    for(int i=0 ; i<groupNum ; ++i){
        group[i].fit = 1 - group[i].tsp / sum_dis;
        sum_fit += group[i].fit;
    }
    for(int i=0 ; i<groupNum ;++i){
        group[i].fit = group[i].fit/sum_fit;
    }
    int best = 0; 
    for(int i= 0; i<groupNum ; ++i){
        if( group[i].tsp < group[best].tsp ){
            best = i;
        }
    }
    /************************************************************************/
    /*cout<<"当前代最好的种群是种群"<<best<<‘:‘<<endl;
    for(int i=0; i<cnt ; ++i){
        cout<<group[best].cities[i]<<" ";
    }*/
    if( group[best].tsp < best_tsp){
        best_tsp = group[best].tsp;
        for(int i=0 ; i< cnt ; ++i){
            trace[i] = group[best].cities[i];
        }
    }
    //cout<<"TSP = "<<group[best].tsp<<endl;
    //system("pause");
}

void select(){
    int chosen[groupNum];
    /*********************轮盘法随机选择种群***************************/
    for(int i =0 ; i<groupNum ; ++i){
        double x = rand()%100;
        x /= 100;
        double fitSofar = 0;
        for(int j=0 ; j< groupNum ; ++j){
            fitSofar += group[j].fit;
            if(fitSofar > x ){
                chosen[i] = j;    break;
            }
        }
    }
    /*************************复制产生新一代种群*************************/
    for(int i=0 ; i<groupNum ; ++i){
        groupt[i] = group[i];
    }
    for(int i=0 ; i<groupNum ;++i){
        group[i] = groupt[ chosen[i] ];
    }
    /*********************************************************************/
    //cout<<"The new generation:"<<endl;
    //print();
    //system("pause");
}

void cross(){
    int t=0;
    int crossp[groupNum];
    memset(crossp, 0, sizeof(crossp));
    /*********************确定交配种群个数***********************/
    for(int i=0 ; i< groupNum ; ++i){
        double x = rand()%100;
        x /= 100;
        if( x<pc ){
            crossp[t++] = i;
        }
    }
    //t = t/2*2;  //保证t为偶数
    /************************开始交配**************************/
    for(int j=0 ; j+1<t ; j+=2){
        int temp1 = j, temp2 = j+1;
        int map1[cnt], map2[cnt];
        int point1, point2;
        point1 = rand()%cnt;    point2 = rand()%cnt;
        if(point2<point1)    swap(point1, point2);
        //两头直接交换
        for(int i=0 ; i<point1; ++i){
            swap(group[temp1].cities[i], group[temp2].cities[i]);
        }
        for(int i=point2+1 ; i<cnt; ++i){
            swap(group[temp1].cities[i], group[temp2].cities[i]);
        }
        //中间产生映射， 处理冲突
        memset(map1, 0, sizeof(map1));
        memset(map2, 0, sizeof(map2));
        for(int i=point1 ; i<=point2; ++i){
            map1[group[temp1].cities[i]] = group[temp2].cities[i];
            map2[group[temp2].cities[i]] = group[temp1].cities[i];
        }
        //处理temp1的冲突
        for(int k = 0 ; k < point1; ++k){
            for(int kk = point1; kk<=point2; ++kk){
                if(group[temp1].cities[k] == group[temp1].cities[kk]){
                    group[temp1].cities[k] = map1[group[temp1].cities[kk]];
                    kk=point1-1;
                    //cout<<"kk = "<<kk<<" ";    system("pause");
                }
            }
        }
        for(int k = point2+1 ; k < cnt; ++k){
            for(int kk = point1; kk<=point2; ++kk){
                if(group[temp1].cities[k] == group[temp1].cities[kk]){
                    group[temp1].cities[k] = map1[group[temp1].cities[kk]];
                    kk=point1-1;
                }
            }
        }
        //处理temp2的冲突
        for(int k = 0 ; k < point1; ++k){
            for(int kk = point1; kk<=point2; ++kk){
                if(group[temp2].cities[k] == group[temp2].cities[kk]){
                    group[temp2].cities[k] = map2[group[temp2].cities[kk]];
                    kk=point1-1;
                }
            }
        }
        for(int k = point2+1 ; k < cnt; ++k){
            for(int kk = point1; kk<=point2; ++kk){
                if(group[temp2].cities[k] == group[temp2].cities[kk]){
                    group[temp2].cities[k] = map2[group[temp2].cities[kk]];
                    kk=point1-1;
                }
            }
        }
    }
    //cout<<"After crossover:"<<endl;
    //print();
}

void mutate(){
    int mutatep[groupNum];
    int t=0;//变异个数
    srand(time(0));
    memset(mutatep, 0, sizeof(mutatep));
    for(int i=0 ; i<groupNum ; ++i){
        double x = rand()%100;
        x /= 100;
        if( x< mp){
            mutatep[t++] = i;
        }
    }
    //开始变异，即随机交换一对城市
    for(int i =0 ; i<t; ++i){
        int temp = mutatep[i];
        int point1 = rand()%cnt;
        int point2 = rand()%cnt;
        swap(group[temp].cities[point1], group[temp].cities[point2]);
    }

    //cout<<"After mutation:"<<endl;
    //print();
}


int main(){
    init();
    pre_value();
    int counter = 0;
    while(counter++ < runs){
        fitness();
        select();
        cross();
        mutate();
    }
    print();
    cout<<"Best tsp = "<<best_tsp<<endl;
    cout<<"Trace:"<<endl;
    for(int i=0 ; i<cnt ; ++i){
        cout<<trace[i]<<" ";
    }
    cout<<endl;
    system("pause");
    return 0;
}