方程的维数在jiedeweishu中修改，目标函数mubiaohanshu中写入，想求最小值就在该函数最后输入bianliang.shiyingdu=-bianliang.shiyingdu,想求最大值就保持bianliang.shiyingdu为正

 

 

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream.h>
#include <iomanip.h>
#include <time.h>
#include <windows.h>
#define IM1 2147483563
#define IM2 2147483399
#define AM (1.0/IM1)
#define IMM1 (IM1-1)
#define IA1 40014
#define IA2 40692
#define IQ1 53668
#define IQ2 52774
#define IR1 12211
#define IR2 3791
#define NTAB 32
#define NDIV (1+IMM1/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
#define zhizhenjuli 0.005
#define PI 3.14159265358
#define T0 10000//温度要取得很高才行。
#define zhongqunshu1 200
#define jiedeweishu 4
//#define zuobianjie -2000
//#define youbianjie 2000
#define lanmuteshuliang 5
unsigned int seed=0; //seed 为种子，要设为全局变量
void mysrand(long int i) //初始化种子
{
seed = -i;
}
long a[1];

double zuobianjie[jiedeweishu]={60,7.5,0,0};//定义左边界数值
double youbianjie[jiedeweishu]={100,25,40,0.4};//定义右边界数值
//double hundun;

//double c=3.95;
//设置全局变量
struct individual
{
 double *chrom;  //染色体；
 double geti[jiedeweishu];//变量值
 double shiyingdu; //目标函数的值；
 double fitness;   //变换后的适应度值；
};
struct haiming
{
 int bianhao;//编号
 double geti[jiedeweishu];
 int haimingchazhi;//海明差值
};
struct youxuan//确定交叉后的优选个体
{
 double geti[jiedeweishu];
 double shiyingdu;
};
//double fangcha;   //目标函数值的方差
individual *zuiyougeti;//精英保存策略
//double zuidafangcha;//到本代为止最优方差
int zhongqunshu;   //种群大小
individual *nowpop;//当前代
individual *newpop;//新一代
double sumfitness;//当代的总适应度fitness
double sumshiyingdu;//当代的总适应度shiyingdu
double maxfitness;//最大适应度
double avefitness;//平均适应度
double maxshiyingdu;//最大适应度
double aveshiyingdu;//平均适应度
float pc;//交叉概率
float pm;//变异概率
int lchrom;//染色体长度
int maxgen;//最大遗传代数
int gen;//遗传代数
double aa=1000,c=25;
//函数
int flipc(double ,double );//判断是否交叉
int flipm(double );//判断是否变异
int rnd(int low,int high);//产生low与high之间的任意数
void initialize();//遗传算法初始化
void preselectfitness(); //计算sumfiness,avefitness,maxfitness
void generation();
double suijibianli();//产生随机遍历指针
int fuzhi(float );//选择要复制的个体
void crossover(individual ,individual ,individual &,individual &);//交叉
void bianyi(individual &);//变异
void mubiaohanshu(individual &);//计算适应度
void chidubianhuan(individual &);//对shiyingdu进行尺度变换赋给fitness
double ran1(long *);//随机数初始
double gasdev(long *idum);//高斯随机数
void bianma(double bianliang,unsigned *p);//编码
double yima(unsigned *p);
void guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
void jingyingbaoliu();//精英保存的实现
//void zuidafangchabaoliu();//最大方差值的保存
//void glp(int n,int s,int *,int (*)[1],float (*)[1]);//glp生成函数
double hundunsuiji();
int haimingchazhijisuan(double *getishuzhi1,double *getishuzhi2);//计算个体的海明值
BOOL Exist(int Val, int Num, int *Array);//判断一个数在前面是否出现过
int cmpfitness(const void *p1,const void *p2)
{
 float i=((individual *)p1)->shiyingdu;//现在是按照"适应度"排序，改成"个体"的话就是按照"个体"排序
 float j=((individual *)p2)->shiyingdu;
 return i<j ? -1:(i==j ? 0:1);//现在是按升序牌排列，将1和-1互换后就是按降序排列
}
int cmpshiyingdu(const void *p1,const void *p2)
{
 float i=((individual *)p1)->shiyingdu;//现在是按照"个体"排序
 float j=((individual *)p2)->shiyingdu;
 return i<j ? -1:(i==j ? 0:1);//现在是按升序牌排列，将1和-1互换后就是按降序排列
}
int cmpshiyingdujiang(const void *p1,const void *p2)
{
 float i=((youxuan *)p1)->shiyingdu;
 float j=((youxuan *)p2)->shiyingdu;
 return i<j ? 1:(i==j ? 0:-1);//现在是按降序牌排列，将1和-1互换后就是按升序排列
}
int cmpgeti(const void *p1,const void *p2)
{
 float i=((individual *)p1)->geti[0];//现在是按照"个体值"排序
 float j=((individual *)p2)->geti[0];
 return i<j ? -1:(i==j ? 0:1);//现在是按升序牌排列，将1和-1互换后就是按降序排列
}
int cmphaimingchazhi(const void *p1,const void *p2)
{
 float i=((haiming *)p1)->haimingchazhi;//现在是按照"适应度"排序，改成"个体"的话就是按照"个体"排序
 float j=((haiming *)p2)->haimingchazhi;
 return i<j ? 1:(i==j ? 0:-1);//现在是按降序牌排列，将-1和1互换后就是按升排列
}
int cmp1(const void *p1,const void *p2)
{
 int i= *(int*)p1;
 int j= *(int*)p2;
 return i<j ? 1:(i==j ? 0:-1);//现在是按降序牌排列，将1和-1互换后就是按升序排列
}
void main()
{
 initialize();
 int i;
 for(i=0;i<jiedeweishu;i++)
 {
  cout<<zuiyougeti->geti[i]<<",";
 }
 cout<<setiosflags(ios::scientific);
 cout<<"初始最优解："<<" "<<-zuiyougeti->shiyingdu<<endl;/////////////
 //system("pause");////////////////////////////////////
 for(gen=1;gen<maxgen;gen++)
 {
  generation();
  //if(-zuiyougeti->shiyingdu<3e-5)
  // break;
 }
  jingyingbaoliu();
  cout<<setiosflags(ios::scientific);
  for(i=0;i<jiedeweishu;i++)
  {
   cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti[i]<<",";
  }
  cout<<"最优解为："<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<-(zuiyougeti->shiyingdu)<<endl;////////////////
 delete [] newpop;
 delete [] nowpop;
 delete [] zuiyougeti;
 system("pause");
}
void initialize()
{
 int i,j;
// hundun=ran1(a);
// while(hundun==0||hundun==0.25||hundun==0.75||hundun==1)
// {
//  hundun=ran1(a);
// }
// int q[zhongqunshu1][1],s=1;
// float xx[zhongqunshu1][1];//生成的glp用x储存
// int h[1]={1};//生成向量
 //for(i=0;i<jiedeweishu;i++)//对边界进行初始化
//{
//  zuobianjie[i]=-100;
//  youbianjie[i]=100;
// }
 zuiyougeti=new individual;//最优个体的生成
 zhongqunshu=200;//种群数量
 nowpop=new individual[zhongqunshu1];//当代
 newpop=new individual[zhongqunshu1];//新一代
 maxgen=300;//最大代数
 gen=0;//起始代
 lchrom=22;//基因数量的初始化
 mysrand(time(0));//随机数种子
    a[0]=seed;//随机数种子
 //对最优个体的初始化
 for(i=0;i<jiedeweishu;i++)
 {
  zuiyougeti->geti[i]=1;
 }
       zuiyougeti->fitness=0;
     zuiyougeti->shiyingdu=-200;
  //zuidafangcha=0;
  //glp(zhongqunshu,s,h,q,xx);
// for(int i=0;i<zhongqunshu1;i++)//产生初始种群
// {
//  for(int j=0;j<s;j++)
//  {
//   nowpop[i].geti=zuobianjie+(youbianjie-(zuobianjie))*xx[i][j];
//  }
// }
   for(i=0;i<zhongqunshu1;i++)//产生初始种群
   {
    for(j=0;j<jiedeweishu;j++)
    {
     nowpop[i].geti[j]=zuobianjie[j]+(youbianjie[j]-(zuobianjie[j]))*ran1(a);
    }
   }
 //nowpop[0].geti=999;//////////////////////////
 guanjiancanshujisuan();
 //zuidafangchabaoliu();//最大方差值的保存
 jingyingbaoliu(); //精英保留的实现
 guanjiancanshujisuan();//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
 //zuidafangchabaoliu();//最大方差值的保存
}
void jingyingbaoliu() //精英保留的实现
{
 individual *zuiyougetiguodu;
 zuiyougetiguodu=new individual[zhongqunshu1];//建立一个过渡数组
 for(int i=0;i<zhongqunshu;i++)//将当代个体复制到过渡数组中
  zuiyougetiguodu[i]=nowpop[i];
 qsort(zuiyougetiguodu,zhongqunshu1,sizeof(individual),&cmpfitness);//按fitness升序排序
      // cout<<"zuiyougetiguodu适应度:"<<zuiyougetiguodu[zhongqunshu1-1].shiyingdu<<endl;///////////
 // cout<<"zuiyougeti适应度:"<<zuiyougeti->shiyingdu<<endl;///////////////////
  //system("pause");
  if(zuiyougetiguodu[zhongqunshu-1].shiyingdu>zuiyougeti->shiyingdu)
  {
   *zuiyougeti=zuiyougetiguodu[zhongqunshu1-1];//如果最优个体的fitness比当代最大的fitness小则用当代的代替之
  //cout<<"zuiyougetiguodu个体:"<<zuiyougetiguodu[zhongqunshu1-1].geti<<endl;/////////////
  //cout<<"zuiyougeti个体:"<<zuiyougeti->geti<<endl;/////////////
  }
  else
   nowpop[rnd(0,(zhongqunshu1-1))]=*zuiyougeti;//否则的话从当代中随机挑选一个用最优个体代替之
  delete [] zuiyougetiguodu;//释放过渡数组
}
//void zuidafangchabaoliu()//最大方差值的保存
//{
/// if(fangcha>zuidafangcha)
//  zuidafangcha=fangcha;
//}

void guanjiancanshujisuan()//计算shiyingdu,根据shiyingdu计算sumshiyingdu,对shiyingdu进行尺度变换变成fitness,根据fitness计算sumfitness，avefitness，maxfitness
{
 for(int i=0;i<zhongqunshu;i++)//计算shiyingdu
  mubiaohanshu(nowpop[i]);
 sumshiyingdu=0;
 for(i=0;i<zhongqunshu;i++)
  sumshiyingdu=sumshiyingdu+nowpop[i].shiyingdu;
 aveshiyingdu=sumshiyingdu/zhongqunshu;
 //fangcha=0;
 //for(i=0;i<zhongqunshu;i++)//求方差
 // fangcha+=pow((nowpop[i].shiyingdu-aveshiyingdu),2)/zhongqunshu;
 for(i=0;i<zhongqunshu;i++)//对shiyingdu进行尺度变换变成fitness
  chidubianhuan(nowpop[i]);
 preselectfitness();//根据fitness计算sumfitness，avefitness，maxfitness
}
void mubiaohanshu(individual &bianliang)//计算shiyingdu
{

 double fangcheng1,fangcheng2,fangcheng3,fangcheng4;
 if(bianliang.geti[1]>7.5)
 {
  fangcheng1=9.5*(bianliang.geti[0]-c)+5.7*(bianliang.geti[0]-bianliang.geti[1])+0.1033*(1-0.0045*(bianliang.geti[0]-25))*aa-0.70965*aa;
  fangcheng2=1.997*pow(bianliang.geti[3],1.4)+1087.536*pow(bianliang.geti[2]*(bianliang.geti[1]-7.5),0.7)/pow(bianliang.geti[3]*194740,0.7)-bianliang.geti[2];
  fangcheng3=bianliang.geti[3]*139250/100-bianliang.geti[2]*0.876096*(bianliang.geti[1]-7.5);
  fangcheng4=0.12274*aa+5.7*(bianliang.geti[0]-bianliang.geti[1])-bianliang.geti[2]*(bianliang.geti[1]-7.5);
 }
 else //罚函数
 {
  fangcheng1=1e66;
  fangcheng2=1e66;
  fangcheng3=1e66;
  fangcheng4=1e66;
  bianliang.geti[0]=100;
  bianliang.geti[1]=100;
  bianliang.geti[2]=100;
  bianliang.geti[3]=100;

 }
 
 bianliang.shiyingdu=-fabs(fangcheng1)-fabs(fangcheng2)-fabs(fangcheng3)-fabs(fangcheng4);//三个方程的解的绝对值和若为0，则方程组得解
 //cout<<bianliang.shiyingdu<<endl;/////////////////////
 

}
void chidubianhuan(individual &bianliang)//对shiyingdu进行尺度变换变成fitness
{
 double T;//退火温度
 T=T0*(pow(0.99,(gen+1-1)));
 double sum=0;
    for(int j=0;j<zhongqunshu;j++)
  sum+=exp(nowpop[j].shiyingdu/T);
 bianliang.fitness=exp(bianliang.shiyingdu/T)/sum;//算出fitness
}
void preselectfitness()//根据fitness计算sumfitness，avefitness，maxfitness
{
 int j;
 sumfitness=0;
 for(j=0;j<zhongqunshu;j++)
  sumfitness+=nowpop[j].fitness;
 individual *guodu;
 guodu=new individual[zhongqunshu1];
 for(j=0;j<zhongqunshu;j++)
  guodu[j]=nowpop[j];
 qsort(guodu,zhongqunshu1,sizeof(individual),&cmpfitness);
 maxfitness=guodu[zhongqunshu1-1].fitness;
 avefitness=sumfitness/zhongqunshu1;
 delete [] guodu;
}
void generation()
{
 individual fuqin1,fuqin2,*pipeiguodu,*pipeichi;
 int *peiduishuzu;//用来存放产生的随机配对
 pipeiguodu=new individual[zhongqunshu1];
 pipeichi=new individual[zhongqunshu1];
 peiduishuzu=new int[zhongqunshu1];
 haiming *haimingrongqi;
 haimingrongqi=new haiming[zhongqunshu1];
 int member1,member2,j=0,fuzhijishu=0,i=0,temp=0,tt=0;
 float zhizhen;
 //随机遍历的实现
 for(zhizhen=suijibianli();zhizhen<1;(zhizhen=zhizhen+zhizhenjuli))//设定指针1/zhongqunshu1
 {
  
  pipeichi[fuzhijishu]=nowpop[fuzhi(zhizhen)];
  fuzhijishu++;//复制计数
  //cout<<fuzhijishu<<endl;
 }
 //for(int iii=0;iii<zhongqunshu1;iii++)
 //{
 // for(int kk=0;kk<jiedeweishu;kk++)
 // {
 // if(pipeichi[iii].geti[kk]<zuobianjie[kk]||pipeichi[iii].geti[kk]>youbianjie[kk])
 // cout<<pipeichi[iii].geti[kk]<<" ";///////////
 // }
 // cout<<endl;
 //}
// cout<<endl;////////////////
   // system("pause");//////////////////////////
 //交叉与变异的实现
 //交叉
    for(i=0;i<zhongqunshu1;i++)
 {
  peiduishuzu[i]=-1;
 }
 
 for(i=0;i<zhongqunshu1;i++)
 {
  for(int kk=0;kk<jiedeweishu;kk++)
  {
   haimingrongqi[i].geti[kk]=pipeichi[i].geti[kk];
  }
 }
 //cout<<haimingrongqi[1].geti[0]<<endl;//////////////
 //system("pause");//////////////////////////
 double rou;//进化因子
 double avehai=0;//平均海明值
 int sumchahainei=0;//单个个体和其他个体海明距离和
 int sumchahaiwai=0;//总的海明距离和
 int jisuancishu=0;//求海明和的次数
 for(int ii=0;ii<zhongqunshu1-1;ii++)
 {
  sumchahainei=0;
        //cout<<"ii的值:"<<haimingrongqi[ii].geti<<endl;//////////
  for(int jj=ii+1;jj<zhongqunshu1;jj++)
  {
   //cout<<"jj的值:"<<haimingrongqi[jj].geti<<endl;//////////
   //system("pause");//////////////////////////
   sumchahainei=sumchahainei+haimingchazhijisuan(haimingrongqi[ii].geti,haimingrongqi[jj].geti);
  }
  sumchahaiwai=sumchahaiwai+sumchahainei;
 }
 //cout<<"平均海明差:"<<sumchahaiwai<<endl;////////////////////////////
 //system("pause");///////////////
// cout<<endl;
 for(ii=1;ii<=zhongqunshu1-1;ii++)
 {
  jisuancishu=jisuancishu+(zhongqunshu1-ii);
 }
//  cout<<jisuancishu<<endl;////////////////////////////
// system("pause");///////////////
// cout<<endl;
 rou=exp(-pow(gen,2)/(2*pow(maxgen/3,2)));
 avehai=(double)(rou*sumchahaiwai/jisuancishu);
// cout<<rou<<" "<<avehai<<" "<<jisuancishu<<" "<<sumchahaiwai<<endl;////////////////////////////
  // system("pause");///////////////
 for (i=0; i<zhongqunshu1; i++)
 {
  temp =rnd(0,zhongqunshu1-1); //产生值在0-zhongqunshu1-1的随机数
   while(Exist(temp, i, peiduishuzu))//判断产生的随机数是否已经产生过，如果是，则再产生一个随机数
   {
    temp =rnd(0,zhongqunshu1-1);
   }
   //如果没有的话，则把产生的随机数放在peiduishuzu中
    *(peiduishuzu+i) = temp;
   // cout<<temp<<endl;/////////////////////////
    int t=zhongqunshu1;
       j=0;
    //cout<<"wo0"<<endl;///////////////////////
    while(Exist(j,i,peiduishuzu)||haimingchazhijisuan(haimingrongqi[temp].geti,haimingrongqi[j].geti)<avehai)
    {
     //cout<<"编号:"<<j<<"海明差值内:"<<haimingchazhijisuan(haimingrongqi[temp].geti,haimingrongqi[j].geti)<<" "<<"是否存在:"<<Exist(j,i,peiduishuzu)<<endl;//////
     // system("pause");//////////////
     j=j+1;
     t--;
     if(t<1)
      break;
    }
    //if(t>=1)
    //cout<<"编号:"<<j<<"海明差值外:"<<haimingchazhijisuan(haimingrongqi[temp].geti,haimingrongqi[j].geti)<<" "<<"是否存在:"<<Exist(j,i,peiduishuzu)<<endl;//////
     // system("pause");//////////////
    //cout<<j<<" "<<t<<endl;///////////
    //system("pause");/////
    if(t>=1)
    {
     i=i+1;
     *(peiduishuzu+i)=j;
     //cout<<"wo1"<<endl;///////////////
    }
    else
    {
     //cout<<"wo2"<<endl;
     haiming *haimingchazhirongqi;
     haimingchazhirongqi=new haiming[zhongqunshu1];
     for(j=0;j<zhongqunshu1;j++)
     {
      haimingchazhirongqi[j].haimingchazhi=haimingchazhijisuan(haimingrongqi[temp].geti,haimingrongqi[j].geti);
      haimingchazhirongqi[j].bianhao=j;
      //cout<<temp<<" "<<j<<" "<<haimingchazhirongqi[j].haimingchazhi<<endl;////////////////
     }
     qsort(haimingchazhirongqi,zhongqunshu1,sizeof(haiming),&cmphaimingchazhi);
     int m=0;
     while(Exist(haimingchazhirongqi[m].bianhao,i,peiduishuzu)||haimingchazhirongqi[m].bianhao==temp)
     {
      m=m+1;
     }
     i=i+1;
     *(peiduishuzu+i)=haimingchazhirongqi[m].bianhao;
     //cout<<"m="<<m<<endl;///////////////////////////////////
     //cout<<"配对编号:"<<haimingchazhirongqi[m].bianhao<<endl;///////
     //cout<<"海明差值:"<<haimingchazhirongqi[m].haimingchazhi<<endl;///////
                    //cout<<"海明差值小:"<<haimingchazhirongqi[m+2].haimingchazhi<<endl;///////
     //system("pause");//////////////////////////////////
    }
  
 }
 //cout<<"wo"<<endl;
   // for(int iii=0;iii<zhongqunshu1;iii++)///////////////////
   // {
   //  for(int kk=0;kk<jiedeweishu;kk++)
   //  {
   //   cout<<pipeichi[peiduishuzu[iii]].geti[kk]<<" ";///////////////
   //  }
   //  cout<<endl;
   // }
   // system("pause");//////////////////////
   // cout<<endl;
   // qsort(peiduishuzu,200,sizeof(int),&cmp1);//////////////
   // cout<<endl;/////////////////////////////////
   // for(iii=0;iii<200;iii++)///////////////////
   // {
    // cout<<peiduishuzu[iii]<<endl;///////////////
    //}
    //system("pause");//////////////////////
    //cout<<endl;
 for(i=0;i<zhongqunshu1-1;i=i+2)
 {
 // cout<<"wozai453"<<endl;
  fuqin1=pipeichi[peiduishuzu[i]];
  fuqin2=pipeichi[peiduishuzu[i+1]];
  //cout<<"父亲1"<<":"<<fuqin1.geti[0]<<" "<<fuqin1.geti[1]<<endl;///////////
  //cout<<"父亲2"<<":"<<fuqin2.geti[0]<<" "<<fuqin2.geti[1]<<endl;///////////
  //cout<<"wo1"<<endl;
  crossover(fuqin1,fuqin2,newpop[i],newpop[i+1]);
 }
 //cout<<"wo123"<<endl;//////////////////////
 int bianlianggeshu=0;
 for(j=0;j<zhongqunshu1;j++)
 {
  //if(newpop[j].geti<-1000)
   //cout<<"个体数值小于下界了";
  for(bianlianggeshu=0;bianlianggeshu<jiedeweishu;bianlianggeshu++)
  {
   nowpop[j].geti[bianlianggeshu]=newpop[j].geti[bianlianggeshu];
  }
 }
 //
 guanjiancanshujisuan();
 //变异的实现
    for(j=0;j<zhongqunshu;j++)
 {
  bianyi(nowpop[j]);
 }
 //
 guanjiancanshujisuan();
 //精英保留的实现
 jingyingbaoliu();
  //
 guanjiancanshujisuan();
 delete [] haimingrongqi;
 delete [] peiduishuzu;
 delete [] pipeichi;
 delete [] pipeiguodu;
}
void crossover(individual parent1,individual parent2,individual &child1,individual &child2)//交叉
{
 int j=0,i=0,jj;
 if(flipc(parent1.fitness,parent2.fitness))
 {
  //cout<<"父个体1:"<<parent1.geti[0]<<endl;////////////////
 // cout<<"父个体2:"<<parent2.geti[0]<<endl;////////////////
  //system("pause");
  int xingcunzhe;
  youxuan *zuihouliangge;//将优选群的个体按高斯变异的结果排序（高斯变异为了验证是否是信息最大化点），取适应度最大的两个
  individual *jingzhengqun,*youxuanqun,*beiyongyouxuanqun;
  int *I,*index,*red;
  double lanmute,*getipingjunhaiming;
  I=new int[2*lanmuteshuliang+2];
  index=new int[2*lanmuteshuliang+2];
      jingzhengqun=new individual[(2*lanmuteshuliang+2)];//设置竞争群的大小，用于交叉的栏目特暂时设为5个
  youxuanqun=new individual[(2*lanmuteshuliang+2)];//优选群的大小最后为信息最大化选择后剩下的个体
  beiyongyouxuanqun=new individual[(2*lanmuteshuliang+2)];
        getipingjunhaiming=new double[(2*lanmuteshuliang+2)];//用来储存个体平均海明距离
  red=new int[(2*lanmuteshuliang+2)];//用来储存冗余信息
  
  for(j=0;j<(2*lanmuteshuliang+2);j++)
  {
   I[j]=0;
   index[j]=1;
  }
  for(j=0;j<lanmuteshuliang;j++)
  {
   for(jj=0;jj<jiedeweishu;jj++)
   {
    lanmute=0.5+ran1(a)*(1.5-0.5);
    jingzhengqun[i].geti[jj]=lanmute*parent1.geti[jj]+(1-lanmute)*parent2.geti[jj];
    jingzhengqun[i+1].geti[jj]=lanmute*parent2.geti[jj]+(1-lanmute)*parent1.geti[jj];
    while(jingzhengqun[i].geti[jj]<zuobianjie[jj]||jingzhengqun[i].geti[jj]>youbianjie[jj]||jingzhengqun[i+1].geti[jj]<zuobianjie[jj]||jingzhengqun[i+1].geti[jj]>youbianjie[jj])
    {
     lanmute=0.5+ran1(a)*(1.5-0.5);
     jingzhengqun[i].geti[jj]=lanmute*parent1.geti[jj]+(1-lanmute)*parent2.geti[jj];
     jingzhengqun[i+1].geti[jj]=lanmute*parent2.geti[jj]+(1-lanmute)*parent1.geti[jj];
    }
   }
   i=i+2;
  }
  for(jj=0;jj<jiedeweishu;jj++)
  {
   jingzhengqun[i].geti[jj]=parent1.geti[jj];
   jingzhengqun[i+1].geti[jj]=parent2.geti[jj];
  }
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
 //  cout<<"wo1"<<endl;
 //  for(int kk=0;kk<2;kk++)
 //  {
 //   cout<<jingzhengqun[j].geti[kk]<<" ";
 //  }
 //  cout<<endl;
 // }
 //system("pause");///////////////////////////////////
  for(j=0;j<(2*lanmuteshuliang+2);j++)
  {
   mubiaohanshu(jingzhengqun[j]);
  }
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
 //  for(int kk=0;kk<jiedeweishu;kk++)
 //  {
 //   cout<<jingzhengqun[j].geti[kk]<<" ";
 //  }
 //  cout<<endl;
 // }
 // system("pause");///////////////////////////////////
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
 //  cout<<jingzhengqun[j].shiyingdu<<endl;
 // }
 // system("pause");///////////////////////////////////
  qsort(jingzhengqun,(2*lanmuteshuliang+2),sizeof(individual),&cmpgeti);//将竞争群按空间排序
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
   //      for(int kk=0;kk<jiedeweishu;kk++)
 //  {
 //   cout<<jingzhengqun[j].geti[kk]<<" ";
  // }
 //  cout<<endl;
 // }
 // system("pause");///////////////////////////////////
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
 //  cout<<jingzhengqun[j].shiyingdu<<endl;
 // }
 // system("pause");///////////////////////////////////
  //判断是否是峰值附近
        for(j=0;j<(2*lanmuteshuliang+1);j++)
  {
   if(jingzhengqun[j].shiyingdu<jingzhengqun[j+1].shiyingdu)
   {
    I[j]=1;
   }
   else if(jingzhengqun[j].shiyingdu>=jingzhengqun[j+1].shiyingdu)
   {
    I[j]=-1;
   }
  }
  I[(2*lanmuteshuliang+1)]=I[2*lanmuteshuliang];
 // for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
 // {
 // cout<<I[j]<<endl;
 // }
  //system("pause");///////////////////////////////////
        for(j=0;j<(2*lanmuteshuliang+1);j++)
  {
   if(I[j]==I[j+1])
    index[j]=0;
  }
  //for(j=0;j<(2*lanmuteshuliang+2);j++)////////////////////
  //{
  // cout<<index[j]<<endl;
  //}
  //system("pause");///////////////////////////////////
        //判断冗余度
  //求平均海明距离
  double avehai=0;//平均海明值
  int sumchahainei=0;//单个个体和其他个体海明距离和
  int sumchahaiwai=0;//总的海明距离和
  int jisuancishu=0;//求海明和的次数
  jj=0; 
  for(int ii=0;ii<(2*lanmuteshuliang+1);ii++)
  {
   sumchahainei=0;
   //cout<<"ii的值:"<<haimingrongqi[ii].geti<<endl;//////////
   for(jj=ii+1;jj<(2*lanmuteshuliang+2);jj++)
   {
    //cout<<"jj的值:"<<haimingrongqi[jj].geti<<endl;//////////
    //system("pause");//////////////////////////
    sumchahainei=sumchahainei+haimingchazhijisuan(jingzhengqun[ii].geti,jingzhengqun[jj].geti);
   }
   sumchahaiwai=sumchahaiwai+sumchahainei;
  }
  //cout<<sumchahaiwai<<endl;///////////
  for(ii=1;ii<=(2*lanmuteshuliang+1);ii++)
  {
   jisuancishu=jisuancishu+((2*lanmuteshuliang+2)-ii);
  }
  avehai=(double)(sumchahaiwai/jisuancishu);
  // cout<<"平均海明距离:"<<avehai<<endl;////////////////////
  //system("pause");////////////////////
  //求单个个体平均海明距离
  for(ii=0;ii<(2*lanmuteshuliang+2);ii++)
  {
   getipingjunhaiming[ii]=0;
   for(jj=0;jj<(2*lanmuteshuliang+2);jj++)
   {
    getipingjunhaiming[ii]=getipingjunhaiming[ii]+haimingchazhijisuan(jingzhengqun[ii].geti,jingzhengqun[jj].geti);
   }
   getipingjunhaiming[ii]= getipingjunhaiming[ii]/(2*lanmuteshuliang+1);
  }
   //  for(ii=0;ii<(2*lanmuteshuliang+2);ii++)////////////////////////
  // {////////////////
  //  cout<<getipingjunhaiming[ii]<<endl;///////////
  // }////////////////////
  // system("pause");////////////////////
  for(ii=0;ii<(2*lanmuteshuliang+2);ii++)
  {
   if(getipingjunhaiming[ii]>=avehai)
    red[ii]=1;
   else
    red[ii]=0;
  }
  // for(ii=0;ii<(2*lanmuteshuliang+2);ii++)////////////////////////
  // {////////////////
  //  cout<<red[ii]<<endl;///////////
  // }/////////////////////
  // system("pause");////////////////////
  ii=0;
  xingcunzhe=0;
  for(ii=0;ii<(2*lanmuteshuliang+2);ii++)
  {
   if(index[ii]!=0||red[ii]!=0)
   {
    for(jj=0;jj<jiedeweishu;jj++)
    {
     youxuanqun[xingcunzhe].geti[jj]=jingzhengqun[ii].geti[jj];
    }
    xingcunzhe++;
   }
  }
  zuihouliangge=new youxuan[xingcunzhe];
  // cout<<"幸存者数量:"<<xingcunzhe<<endl;//////////////////
    //for(ii=0;ii<xingcunzhe;ii++)////////////////////////
  // {////////////////
  //  mubiaohanshu(youxuanqun[ii]);
  //  cout<<"个体:"<<youxuanqun[ii].geti[0]<<" "<<youxuanqun[ii].geti[1]<<" "<<"适应度:"<<youxuanqun[ii].shiyingdu<<endl;///////////
  // }/////////////////////
    //system("pause");////////////////////
  for(ii=0;ii<xingcunzhe;ii++)////////////////////////
  {
   //zuihouliangge[ii].geti=youxuanqun[ii].geti;
   zuihouliangge[ii].shiyingdu=0;
  }
  //对优选群进行高斯变异
  if(xingcunzhe>=2)
  {
   for(int jjj=0;jjj<30;jjj++)
   {
    for(ii=0;ii<xingcunzhe;ii++)
    {
     mubiaohanshu(youxuanqun[ii]);
    }
    for(ii=0;ii<xingcunzhe;ii++)
    {
     for(jj=0;jj<jiedeweishu;jj++)
     {
      beiyongyouxuanqun[ii].geti[jj]=youxuanqun[ii].geti[jj]+gasdev(a);
      while(beiyongyouxuanqun[ii].geti[jj]<zuobianjie[jj]||beiyongyouxuanqun[ii].geti[jj]>youbianjie[jj])
      {
       beiyongyouxuanqun[ii].geti[jj]=youxuanqun[ii].geti[jj]+gasdev(a);
      }
     }
    }
   }
    for(ii=0;ii<xingcunzhe;ii++)
    {
     mubiaohanshu(beiyongyouxuanqun[ii]);
    }
    for(ii=0;ii<xingcunzhe;ii++)
    {
     if(beiyongyouxuanqun[ii].shiyingdu>youxuanqun[ii].shiyingdu)
     {
      for(jj=0;jj<jiedeweishu;jj++)
      {
       youxuanqun[ii].geti[jj]=beiyongyouxuanqun[ii].geti[jj];
      }
     }
    }
    for(ii=0;ii<xingcunzhe;ii++)
    {
     mubiaohanshu(youxuanqun[ii]);
    }
 
       //for(ii=0;ii<xingcunzhe;ii++)////////////////////
     //{////////////////
     // cout<<"个体:"<<youxuanqun[ii].geti[0]<<" "<<youxuanqun[ii].geti[1]<<" "<<"适应度:"<<youxuanqun[ii].shiyingdu<<endl;///////////
     //}///
     //cout<<endl;///////////
     //system("pause");/////////////
    for(ii=0;ii<xingcunzhe;ii++)
    {
     for(jj=0;jj<jiedeweishu;jj++)
     {
      zuihouliangge[ii].geti[jj]=youxuanqun[ii].geti[jj];
     }
     zuihouliangge[ii].shiyingdu=youxuanqun[ii].shiyingdu;
    }
     // for(ii=0;ii<xingcunzhe;ii++)////////////////////
    // {////////////////
    //  cout<<"个体:"<<zuihouliangge[ii].geti[0]<<" "<<zuihouliangge[ii].geti[1]<<" "<<"适应度:"<<zuihouliangge[ii].shiyingdu<<endl;///////////
    // }///
    // cout<<endl;///////////
    // system("pause");/////////////
    qsort(zuihouliangge,xingcunzhe,sizeof(youxuan),&cmpshiyingdujiang);//将优选群按变异后适应度降序排序
    // for(ii=0;ii<xingcunzhe;ii++)////////////////////
    // {////////////////
    //  cout<<"个体:"<<zuihouliangge[ii].geti[0]<<" "<<zuihouliangge[ii].geti[1]<<" "<<"适应度:"<<zuihouliangge[ii].shiyingdu<<endl;///////////
    // }///
    // cout<<endl;///////////
    // system("pause");/////////////
    for(jj=0;jj<jiedeweishu;jj++)
    {
     child1.geti[jj]=zuihouliangge[0].geti[jj];
     child2.geti[jj]=zuihouliangge[1].geti[jj];
    }
    // cout<<child1.geti[0]<<" "<<child1.geti[1]<<endl;///////////////////////
       // cout<<child2.geti[0]<<" "<<child2.geti[1]<<endl;///////////////////////
     //cout<<"wozai761"<<endl;//////////////////////
  }
  else
  {
   //cout<<"wozai761"<<endl;
   double alpha;
   for(jj=0;jj<jiedeweishu;jj++)
   {
    alpha=ran1(a);
    child1.geti[jj]=alpha*parent1.geti[jj]+(1-alpha)*parent2.geti[jj];
    child2.geti[jj]=alpha*parent2.geti[jj]+(1-alpha)*parent1.geti[jj];
   }
  } 
       // cout<<"wozai774"<<endl;//////////////////////
  delete [] zuihouliangge;
 // cout<<"wozai776"<<endl;//////////////////////
  delete [] red;
 // cout<<"wozai778"<<endl;//////////////////////
  delete [] getipingjunhaiming;
  delete [] beiyongyouxuanqun;
 // cout<<"wozai780"<<endl;//////////////////////
  delete [] youxuanqun;
  delete [] jingzhengqun;
  delete [] index;
  delete [] I;
  //cout<<"wozai784"<<endl;//////////////////////
 }
 else
 {
       //cout<<"wozai781"<<endl;
  for(jj=0;jj<jiedeweishu;jj++)
  {
   child1.geti[jj]=parent1.geti[jj];
   child2.geti[jj]=parent2.geti[jj];
  }
 }
}
void bianyi(individual &child)//变异
{
 int jj=0;
 for(jj=0;jj<jiedeweishu;jj++)
 {
  if(flipm(child.fitness))
  {
   double alpha,r,derta;
   alpha=ran1(a);
   if(alpha>0.5)
   {
    derta=(youbianjie[jj]-child.geti[jj])*(1-ran1(a)*pow((1-gen/maxgen),2));
    child.geti[jj]=child.geti[jj]+derta;
   }
   if(alpha<=0.5)
   {
    derta=(child.geti[jj]-zuobianjie[jj])*(1-ran1(a)*pow((1-gen/maxgen),2));
    child.geti[jj]=child.geti[jj]-derta;
   }
  }
 }
    for(jj=0;jj<jiedeweishu;jj++)
 {
 if(child.geti[jj]>youbianjie[jj]||child.geti[jj]<zuobianjie[jj])//////////////////
   system("pause");/////////////////////
 }
}
double ran1(long *idum)
{
int j;
long k;
static long idum2=123456789;
static long iy=0;
static long iv[NTAB];
float temp;
if (*idum <= 0)
{
if (-(*idum) < 1) *idum=1;
else *idum = -(*idum);
idum2=(*idum);
for (j=NTAB+7;j>=0;j--)
{
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
if (j < NTAB) iv[j] = *idum;
}
iy=iv[0];
}
k=(*idum)/IQ1;
*idum=IA1*(*idum-k*IQ1)-k*IR1;
 if (*idum < 0) *idum += IM1;
k=idum2/IQ2;
idum2=IA2*(idum2-k*IQ2)-k*IR2;
if (idum2 < 0) idum2 += IM2;
j=iy/NDIV;
iy=iv[j]-idum2;
iv[j] = *idum;
if (iy < 1) iy += IMM1;
if ((temp=AM*iy) > RNMX) return RNMX;
else return temp;
}
double suijibianli()//随机遍历
{
 double i=ran1(a);
 while(i>zhizhenjuli)
 {
  i=ran1(a);
 }
 //cout<<i<<endl;//////////////
 return i;
}
int fuzhi(float p)//复制
{
 int i;
 double sum=0;
 if(sumfitness!=0)
 {
  for(i=0;(sum<p)&&(i<zhongqunshu);i++)
   sum+=nowpop[i].fitness/sumfitness;
 }
 else
  i=rnd(1,zhongqunshu1);
 return(i-1);
}

int rnd(int low, int high)           /*在整数low和high之间产生一个随机整数*/
{
    int i;
    if(low >= high)
        i = low;
    else
    {
        i =(int)((ran1(a) * (high - low + 1)) + low);
        if(i > high) i = high;
    }
    return(i);
}
int flipc(double p,double q)//判断是否交叉
{
 double pc1=0.9,pc2=0.8;
 if((p-q)>0)
 {
  if(p>=avefitness)
  {
   pc=pc1-(pc1-pc2)*(p-avefitness)/(maxfitness-avefitness);
  }
  else
   pc=pc1;
 }
 else
 {
  if(q>=avefitness)
  {
   pc=pc1-(pc1-pc2)*(q-avefitness)/(maxfitness-avefitness);
  }
  else
   pc=pc1;
 }
    if(ran1(a)<=pc)
        return(1);
    else
        return(0);
}
int flipm(double p)//判断是否变异
{
 double pm1=0.01,pm2=0.001;
 if(p>=avefitness)
 {
  pm=(pm1-(pm1-pm2)*(maxfitness-p)/(maxfitness-avefitness));
 }
 else
 pm=pm1;
 if(ran1(a)<=pm)
        return(1);
    else
        return(0);
}
//void glp(int n,int s,int *h,int (*q)[1],float (*xx)[1])//glp
//{
// int i=0,j=0;
 //求解q
// for(i=0;i<n;i++)
// {
//  for(j=0;j<s;j++)
//  {
//   *(*(q+i)+j)=((i+1)*(*(h+j)))%n;
//  }
// }
// i=n-1;
// for(j=0;j<s;j++)
// {
//  *(*(q+i)+j)=n;
// }
 //求解x
// for(i=0;i<n;i++)
// {
//  for(j=0;j<s;j++)
//  {
//   *(*(xx+i)+j)=(float)(2*(*(*(q+i)+j))-1)/(2*n);
///  }
// }
//}
BOOL Exist(int Val, int Num, int *Array)//判断一个数是否在一个数组的前Num个数中
{
BOOL FLAG = FALSE;
int i;
for (i=0; i<Num; i++)
if (Val == *(Array + i))
{
FLAG = TRUE;
break;
}
return FLAG;
}
//double hundunsuiji()
//{
// hundun=c*hundun*(1-hundun);
// return hundun;
//}

int haimingchazhijisuan(double *getishuzhi1,double *getishuzhi2)
{
 int hai[jiedeweishu],aa=0;
 for(int kk=0;kk<jiedeweishu;kk++)
 {
  hai[kk]=0;
 }
 unsigned *p;
 unsigned *q;
// unsigned *gray;
 p=new unsigned[lchrom];
 q=new unsigned[lchrom];
// gray=new unsigned[lchrom];
 int x=0;
 int i=0,j=0,jj=0;
 if(getishuzhi1[0]<zuobianjie[0]||getishuzhi1[0]>youbianjie[0]||getishuzhi1[1]<zuobianjie[1]||getishuzhi1[1]>youbianjie[1])///////////////////
 {
  cout<<"haimingchazhijisuan一步第一个变量越界"<<endl;/////////
  system("pause");
 }
 if(getishuzhi2[0]<zuobianjie[0]||getishuzhi2[0]>youbianjie[0]||getishuzhi2[1]<zuobianjie[1]||getishuzhi2[1]>youbianjie[1])///////////////////
 {
  cout<<"haimingchazhijisuan一步第二个变量越界"<<endl;/////////
  system("pause");
 }
 //cout<<youbianjie-(zuobianjie)<<endl;
 //system("pause");
 for(jj=0;jj<jiedeweishu;jj++)
 {
  x=0,i=0,j=0;
  for(i=0;i<lchrom;i++)//p，q两个数组归零
  {
   q[i]=0;
   p[i]=0;
  }
 //对变量1进行编码
  x=(getishuzhi1[jj]-(zuobianjie[jj]))*((pow(2,lchrom)-1)/(youbianjie[jj]-(zuobianjie[jj])));
 //cout<<x<<endl;///////////
  if(x<0)
   system("pause");///////////
  i=0;
  while (x!=0&&(i!=lchrom))
  {
   q[i]=(unsigned)(x%2);
   x=x/2;
   i++;
  }
 
// for(i=0;i<lchrom;i++)//////////////////
//  cout<<q[i];///////////////
// cout<<endl;///////////
  int w=lchrom-1;
  if(q[w]!=0&&q[w]!=1)
  system("pause");
 //对变量2进行编码
  x=0;
  x=(getishuzhi2[jj]-(zuobianjie[jj]))*((pow(2,lchrom)-1)/(youbianjie[jj]-(zuobianjie[jj])));
 //cout<<x<<endl;///////////
  if(x<0)
   system("pause");///////////
  i=0;
  while (x!=0&&(i!=lchrom))
  {
   p[i]=(unsigned)(x%2);
   x=x/2;
   i++;
  }
  w=lchrom-1;
  if(p[w]!=0&&p[w]!=1)
   system("pause");
   for(j=0;j<lchrom;j++)
   {
    if(q[j]==p[j])
     aa=0;
    else
     aa=1;
    hai[jj]=hai[jj]+aa;
    //cout<<hai<<endl;////
   }
  if(hai[jj]<0)//////////////
  {
   cout<<"海明差值计算结果:"<<hai[jj]<<endl;///////////////
   system("pause");/////////////////////
  }
 }
 int chazhi=0;
 for(jj=0;jj<jiedeweishu;jj++)
 {
  chazhi+=hai[jj];
 }
 //cout<<chazhi<<endl;
// cout<<"wozai1061"<<endl;
 
// delete [] gray;
 delete [] q;
 delete []p;
 return chazhi;
}
double gasdev(long *idum)
{ 
 double ran1(long *idum);
 static int iset=0;
 static double gset;
 double fac,rsq,v1,v2;
 if (*idum < 0)
  iset=0; //初始化
 if (iset == 0)
 {
  do
  {
   v1=2.0*ran1(idum)-1.0;
   v2=2.0*ran1(idum)-1.0;
   rsq=v1*v1+v2*v2;
  }while (rsq >= 1.0 || rsq == 0.0);
  fac=sqrt(-2.0*log(rsq)/rsq);
  gset=v1*fac;
  iset=1;
  return v2*fac;
 }
 else
 {
  iset=0;
  return gset;
 }
}