TSP问题_遗传算法(STL大量使用)

 

#include<iostream>
#include<vector>
#include<algorithm>//random_shuffle();sort();lower_bound();
#include<cmath>
#include<ctime>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define PB push_back //在vector尾部加入一个数据
#define MP make_pair //1.将2个数据组合成一个数据//2.当一个函数需要返回2个数据的时候，可以选择pair
//pair的实现是一个结构体，主要的两个成员变量是first、second 
//因为是使用struct不是class，所以可以直接使用pair的成员变量
int next_int();
double next_double();
void pmx(VI& a,VI& b,int pointcnt);//PMX交叉
double fitness(const VI& v,int pointcnt);//计算适应度
void change0(vector<int>& K,int N);//变异策略:两点互换
void mutate(VI& route,int mutate_type,int pointcnt);
bool pair_dec(const pair<double,VI*>& a,const pair<double,VI*>& b);
vector<double> x,y;//全局函数，记录城市坐标

class other_population
{
public:
    int popsize,pointcnt;//种群规模,染色体长度
    double pc,pm;//交叉概率,变异概率
    vector<pair<double,VI*> >pop;//种群
    pair<double,VI*> bestofpop;//最好个体
    int cross_type;//交叉类型
    int mutate_type;//变异类型
    int make_p;//个体概率分配策略类型
    int select_type;//个体选择类型
    int toursize;//竞赛规模
    double bestp;//最好个体选择概率
    other_population(int a,int b,int c,int f,int g,double d,double e,int h,double j,int m)
    {
        popsize=a,pointcnt=b,cross_type=c,mutate_type=f,make_p=g,pc=d,pm=e,toursize=h,bestp=j,select_type=m;
        for(int i=0;i<popsize;i++)//初始化种群
        {
            VI* v=new VI(pointcnt);
            for(int j=0;j<pointcnt;j++)
                (*v)[j]=j;
            random_shuffle(v->begin(),v->end());
            pop.PB(MP(fitness(*v,pointcnt),v));
        }
        sort(pop.begin(),pop.end(),pair_dec);
        bestofpop.first=pop[0].first;//初始时最好个体的适应度
        bestofpop.second=new VI(*pop[0].second);//初始时最好个体的染色体
    }
    ~other_population()
    {
        for(int i=0;i<pop.size();i++)
            delete pop[i].second;
        delete bestofpop.second;
    }
    void next()//产生下一代种群
    {
        vector<double> ps(popsize);
        if(make_p==0) //按适应度比例分配个体的选择概率
        {
            double sum=0;
            for(int i=0;i<popsize;i++)
                sum+=pop[i].first;
            for(i=0;i<popsize;i++)
                ps[i]=pop[i].first/sum;
        }    
    
        if(select_type==0)//轮盘赌选择个体
        {
            vector<pair<double,VI*> > select_res;
            vector<double> addsum(popsize);
            for(int i=0;i<popsize-1;i++)//计算个体的累计概率
            {
                if(i==0)
                    addsum[i]=ps[0];
                else
                    addsum[i]=addsum[i-1]+ps[i];
            }
            addsum[popsize-1]=1.5;
            for(i=0;i<popsize;i++)
            {
                double rd=next_double();
                int r=lower_bound(addsum.begin(),addsum.end(),rd)-addsum.begin();
                //lower_bound()返回一个 iterator 它指向在[first,last)标记的有序序列中可以插入value，
                //而不会破坏容器顺序的第一个位置，而这个位置标记了一个大于等于value 的值。
                VI* v=new VI(*pop[r].second);
                select_res.PB(MP(fitness(*v,pointcnt),v));
            }
            for(i=0;i<popsize;i++)
                delete pop[i].second;
            pop=select_res;
            ////////////////////////////////
            /*cout<<"选择后共"<<pop.size()<<"个子染色体\n";
            for(i=0;i<pop.size();i++)
            {
                VI temp=*pop[i].second;
                for(int j=0;j<10;j++)
                    cout<<temp[j]<<" ";
                cout<<"\n";
            }*/
            //////////////////////////////
        }    
        int Count_cross=0;
        for(int cc=0;cc<popsize/2;cc++)//随机选择两个个体,然后进行交叉
        {
            int a=next_int()%popsize;
            int b=(a+1+(next_int()%(popsize-1)))%popsize;
            if(next_double()<pc)//随机数小于交叉概率,进行交叉
            {
                if(cross_type==0)//pmx交叉
                    pmx(*pop[a].second,*pop[b].second,pointcnt);                
                ///////////////////////////////
                /*Count_cross+=2;
                cout<<"交叉后第"<< a <<"条子染色体: ";
                VI temp=*pop[a].second;
                for(int j=0;j<10;j++)
                    cout<<temp[j]<<" ";
                cout<<"\n";
                //////////////////////////////
                cout<<"交叉后第"<< b <<"条子染色体: ";
                temp=*pop[b].second;
                for(j=0;j<10;j++)
                    cout<<temp[j]<<" ";
                cout<<"\n";*/
                ////////////////////////////////

                pop[a].first=fitness(*pop[a].second,pointcnt);//计算交叉后个体a的适应度
                if(bestofpop.first<pop[a].first)//更新最好个体
                {
                    bestofpop.first=pop[a].first;
                    delete bestofpop.second;
                    bestofpop.second=new VI(*pop[a].second);
                }
                pop[b].first=fitness(*pop[b].second,pointcnt);//计算交叉后个体b的适应度
                if(bestofpop.first<pop[b].first)//更新最好个体
                {
                    bestofpop.first=pop[b].first;
                    delete bestofpop.second;
                    bestofpop.second=new VI(*pop[b].second);
                }
            }        
        }
        //////////////////////////////////////
        //cout<<"交叉"<<Count_cross<<"条染色体\n";
        //cout<<"交叉后共"<<pop.size()<<"个子染色体\n";        
        /////////////////////////////////////

        int Count_mutate=0;//变异染色体条数
        for(int i=pop.size()-1;i>=0;i--)//进行变异
            if(next_double()<pm)//随机数小于变异概率,进行变异
            {
                mutate(*pop[i].second,mutate_type,pointcnt);//变异
                pop[i].first=fitness(*pop[i].second,pointcnt);//计算变异后个体的适应度
                ///////////////////////////////
                /*Count_mutate++;
                cout<<"变异后第"<< i <<"个子染色体: ";
                VI temp=*pop[i].second;
                for(int j=0;j<10;j++)
                    cout<<temp[j]<<" ";
                cout<<"\n";*/
                ///////////////////////////////
            }
        ///////////////////////////////
        //cout<<"变异"<<Count_mutate<<"条染色体\n";
        //cout<<"变异后共"<<pop.size()<<"个子染色体\n\n\n";    
        ///////////////////////////////

        sort(pop.begin(),pop.end(),pair_dec);//从大到小排序
        if(bestofpop.first<pop[0].first)//更新最好个体
        {
            delete bestofpop.second;
            bestofpop.first=pop[0].first;
            bestofpop.second=new VI(*pop[0].second);
        }
    }
};
int next_int()
{
    return rand()*(RAND_MAX+1)+rand();
}
double next_double()
{
    return (double(rand()*(RAND_MAX+1)+rand()))/((RAND_MAX+1)*RAND_MAX+RAND_MAX);
}
double fitness(const VI& v,int pointcnt)//计算适应度
{
    double r=0;
    for(int i=0;i<pointcnt;i++)
    {
        double dx=x[v[i]]-x[v[(i+1)%pointcnt]];
        double dy=y[v[i]]-y[v[(i+1)%pointcnt]];
        r+=sqrt(dx*dx+dy*dy);//个体的适应度为相邻两城市之间的距离平方的平方根和
    }
    return 1.0/r;
}
int flag=0;
void pmx(VI& a,VI& b,int pointcnt)//PMX交叉
{
    
    int i;
    int sa=next_int()%pointcnt,sb=next_int()%pointcnt;//随机选择两交叉位
    if (sa>sb)
    {        
        swap(sa,sb);
    }//保证交叉位sa<=sb
    
    /*if(flag==0)
    {
        cout<<"互换前(互换位:"<<sa<<" "<<sb<<")\n";
        for(i=0;i<10;i++)
            cout<<a[i]<<" ";
        cout<<"\n";
        for(i=0;i<10;i++)
            cout<<b[i]<<" ";
        cout<<"\n";    
    }*/
    VI m1(pointcnt,-1);
    VI m2(pointcnt,-1);    
    for (i = sa; i <= sb; ++i) //互换交叉位之间的基因
    {
        //相当于a中将城市a[i]删了，用城市b[i]取代，从而出现城市b[i](替换后的a'[i])重复
        //        b中将城市b[i]删了，用城市a[i]取代，从而出现城市a[i](替换后的b'[i])重复
        swap(a[i], b[i]);    
        m1[a[i]] = b[i];//记录a'[i]所取代的城市a[i],用于替换非交叉部分的a'[i]的元素重复
        m2[b[i]] = a[i];
    }
    ///////////////////////
    /*if(flag==0)
    {
        cout<<"互换后(未调整)\n";
        for(i=0;i<10;i++)
            cout<<a[i]<<" ";
        cout<<"\n";
        for(i=0;i<10;i++)
            cout<<b[i]<<" ";
        cout<<"\n";

        for(i=0;i<10;i++)
            cout<<m1[i]<<" ";
        cout<<"\n";
        for(i=0;i<10;i++)
            cout<<m2[i]<<" ";
        cout<<"\n";
    }*/
    ///////////////////////
    for (i = 0; i < pointcnt; ++i)//调整交叉位之前、之后的基因，防止和交叉位之间的基因重复
        if (i < sa || i > sb) 
        {
                if (m2[b[i]] != -1) 
                {
                    while (m2[b[i]] != -1)
                        b[i] = m2[b[i]];
                }    
                if (m1[a[i]] != -1) 
                {
                    while (m1[a[i]] != -1)
                       a[i] = m1[a[i]];
                }        
        }
    /////////////////////
    /*if(flag==0)
    {
        cout<<"互换调整后\n";
        for(i=0;i<10;i++)
            cout<<a[i]<<" ";
        cout<<"\n";
        for(i=0;i<10;i++)
            cout<<b[i]<<" ";
        cout<<"\n";
    }
    flag=1;*/
    ////////////////////
}
void mutate(VI& route,int mutate_type,int pointcnt)//变异
{
    if(mutate_type==0)//两点互换
        change0(route,pointcnt);    
}
void change0(vector<int>& K,int N)//变异策略:两点互换
{
    int i=next_int()%N;
    int d=next_int()%(N-1);
    int j=(i+1+d)%N;
    swap(K[i],K[j]);
}
bool pair_dec(const pair<double,VI*>& a,const pair<double,VI*>& b)//比较因子，用于sort()函数
{
    return a>b;
}






int main()
{
    srand((unsigned)time(NULL));
    int CASNUM,POINTCNT,POPSIZE,GENERATIONS;
    //scanf("%d",&CASNUM);
    CASNUM=10;//实验次数
    //scanf("%d%d%d",&POINTCNT,&POPSIZE,&GENERATIONS);
    POINTCNT=10, POPSIZE=100,GENERATIONS=100;//染色体长度（城市数），种群规模，最大迭代步数
    cout<<"城市数="<<POINTCNT<<endl;
    x.resize(POINTCNT);
    y.resize(POINTCNT);
    x[0]=87, x[1]=91,x[2]=83,x[3]=71,x[4]=64,x[5]=68,x[6]=83,x[7]=87,x[8]=74,x[9]=71;
    y[0]=7,  y[1]=38,y[2]=46,y[3]=44,y[4]=60,y[5]=58,y[6]=69,y[7]=76,y[8]=78,y[9]=71;    
    cout<<"各城市坐标:"<<endl;
    for(int i=0;i<POINTCNT;i++)
    {
        //scanf("%lf%lf",&x[i],&y[i]);//输入各个城市的坐标
        cout<<"["<<x[i]<<", "<<y[i]<<"]"<<endl;//输出各个城市的坐标                
    }    

    int select_type,make_p_type,k,cross_type,mutate_type;
    double q,pc,pm;
    //scanf("%d%d%d",&select_type,&make_p_type,&k);
    //scanf("%lf%lf%lf",&q,&pc,&pm);
    //scanf("%d%d",&cross_type,&mutate_type);
    select_type=0,make_p_type=0,k=5;//个体选择方法类型，个体选择概率分配类型，竞赛规模
    q=0.5,pc=0.85,pm=0.15;//最好个体选择概率，交叉概率，变异概率
    cross_type=0,mutate_type=0;//交叉类型，变异类型
    
    double best=1e9,worst=0,sum=0;
    VI res;
    for(int cas=0;cas<CASNUM;cas++)//进行10代的试验
    {
        other_population gen(POPSIZE,POINTCNT,cross_type,mutate_type,make_p_type,pc,pm,k,q,select_type);//初始化
        for(int g=0;g<GENERATIONS;g++)//每次试验进行迭代进化(100代进化)
            gen.next();//每代进化过程中都会记录最更好的染色体
        if(best>1.0/gen.bestofpop.first)//更新历次最好适应度
        {
            best=1.0/gen.bestofpop.first;
            res=*gen.bestofpop.second;//存放最好个体的染色体
        }
        if(worst<1.0/gen.bestofpop.first)//更新历次最差适应度
            worst=1.0/gen.bestofpop.first;
        sum+=1.0/gen.bestofpop.first;//计算各次最好个体的适应度之和
    }
    sum/=CASNUM;//计算平均适应度
    cout<<endl;
    cout<<"历次最好适应度："<<best<<"\n"<<"历次最差适应度："<<worst<<"\n"<<"平均适应度："<<sum<<"\n";
    cout<<"输出最好解：";
    for(i=0;i<POINTCNT;i++)//输出解
    {
        cout<<res[i];//输出各城市
        if (i<POINTCNT-1)
            cout<<"-";
    }
    cout<<endl;

    return 0;
}