粒子群算法C++版Word文档格式.docx

粒子群算法C++版Word文档格式.docx

《粒子群算法C++版Word文档格式.docx》由会员分享，可在线阅读，更多相关《粒子群算法C++版Word文档格式.docx（11页珍藏版）》请在冰豆网上搜索。

usingnamespacestd;

typedeflonglongLL;

constdoubleMAX_VAL=（double）1e18;

constintMAX_GEN=30;

///最大迭代次数

constintMAX_SCALE=3000;

///最大种群规模

constintMAX_CITY=20+2;

///最大城市数

constdoubleW_VAL=0.729;

///

structSO{

intx,y;

SO（）{}

SO（intx,inty）:

x（x）,y（y）{}

};

structPoint{

doublex,y;

Point（）{}

Point（intx,inty）:

x（x）,y（y）{};

voidread（）

{

scanf（"

%lf%lf"

&

x,&

y）;

}

inlineintrandomI（intx）{returnrand（）%x;

inlinedoublerandomD（）{return（double）rand（）/RAND_MAX;

inlinedoublegetDist（Pointa,Pointb）

{

returnsqrt（（a.x-b.x）*（a.x-b.x）+（a.y-b.y）*（a.y-b.y））;

}

structPSO{

doublew;

intscale;

intcityNum;

intnowGen;

///当前代数

intmaxGen;

///迭代次数

intbestNum;

intbestGen;

///最佳出现代数

doubledist[MAX_CITY][MAX_CITY];

intoPop[MAX_SCALE][MAX_CITY];

///粒子群

doublefitness[MAX_SCALE];

///种群适应度，表示种群中各个个体的适应度

vector<

SO>

listV[MAX_SCALE];

///每科粒子的初始交换序列

intPd[MAX_SCALE][MAX_CITY];

///一颗粒子历代中出现最好的解，

doublevPd[MAX_SCALE];

///解的评价值

intPgd[MAX_CITY];

///整个粒子群经历过的的最好的解，每个粒子都能记住自己搜索到的最好解

doublevPgd;

///最好的解的评价值

PSO（）{}

PSO（ints,intc,intmG,doubleww,doubled[MAX_CITY][MAX_CITY]）

scale=s;

cityNum=c;

maxGen=mG;

w=ww;

for（inti=0;

i<

cityNum;

i++）

for（intj=0;

j<

j++）

dist[i][j]=d[i][j];

voidcopyArray（doublea[],doubleb[],intn）

n;

i++）a[i]=b[i];

voidcopyArray（inta[],intb[],intn）

voidinit（）

nowGen=0;

scale;

）

intx=randomI（cityNum）;

intr;

for（r=0;

r<

j;

r++）

if（x==oPop[i][r]）break;

if（r==j）

oPop[i][j]=x;

//cout<

<

oPop[i][j]<

'

;

j++;

endl;

"

:

"

<

intvn=randomI（cityNum）+1;

vn;

inty=randomI（cityNum）;

while（x==y）y=randomI（cityNum）;

SOso（x,y）;

listV[i].push_back（so）;

so.x<

*"

so.y<

endl;

getFitness（）;

vPd[i]=fitness[i];

copyArray（Pd[i],oPop[i],cityNum）;

bestNum=0;

vPgd=fitness[0];

bestGen=0;

i++）if（vPgd>

fitness[i]）

vPgd=fitness[i];

bestNum=i;

copyArray（Pgd,oPop[bestNum],cityNum）;

doublegetVal（intx）

doubleret=0;

intxx=oPop[x][i%cityNum];

intyy=oPop[x][（i+1）%cityNum];

ret+=dist[xx][yy];

returnret;

voidgetFitness（）

fitness[i]=getVal（i）;

voidUpdateVal（）

intj=0;

doublevj=fitness[0];

if（vPd[i]>

///?

?

if（vj>

vj=fitness[i];

j=i;

if（vj<

vPgd）

bestGen=nowGen;

bestNum=j;

vPgd=vj;

copyArray（Pgd,oPop[j],cityNum）;

voidchangeTo（inta[],vector<

v）///

intvn=v.size（）;

intx=v[i].x,y=v[i].y;

swap（a[x],a[y]）;

minus（inta[],intb[]）///

intc[MAX_CITY],d[MAX_CITY];

i++）d[i]=b[i];

i++）c[a[i]]=i;

v;

SOs;

if（d[i]!

=a[i]）

s.x=i,s.y=c[a[i]];

swap（d[s.x],d[s.y]）;

v.push_back（s）;

returnv;

voidaddTo（vector<

&

v,vector<

a,intvn）

v.push_back（a[i]）;

///Vii=wVi+ra（Pid-Xid）+rb（Pgd-Xid）

voidevolution（）

for（intig=0;

ig<

maxGen;

ig++）

nowGen=ig+1;

///nowGen

for（intis=0;

is<

is++）

if（is==bestNum）continue;

v.clear（）;

intlvn=w*listV[is].size（）;

addTo（v,listV[is],lvn）;

a=minus（Pd[is],oPop[is]）;

intan=randomD（）*a.size（）;

addTo（v,a,an）;

b=minus（Pgd,oPop[is]）;

intbn=randomD（）*b.size（）;

addTo（v,b,bn）;

listV[is]=v;

changeTo（oPop[is],listV[is]）;

listV[is].size（）<

UpdateVal（）;

voidsolve（）

init（）;

evolution（）;

printf（"

answer%lf:

\n"

vPgd）;

solution\n"

）;

if（i）printf（"

%d\n"

Pgd[i]）;