antclass.h

一个很好的蚁群算法程序,我读研的时候写的.

#include <iostream>
#include <fstream>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "MapClass.h"

using namespace std;

const int  iAntNumber=60;
const double dAlpha=1;
const double dBeta=5;
const double Q=100.0;
int iCount=0;



class Ant{
private:
	double PathLength;
	int iA_Tabu[iCityNumber];
	int iCityCount;
	//MapInfo * Map;
	
public:
	Ant();
    int iA_Allowed[iCityNumber];
    void NextCity(MapInfo * Map);
	void AddCity(int CityIndex);
	double GetOneDirectProbility(MapInfo * Map,int i,int j);
	double GetPathLength(void);
	void SetPathLength(MapInfo * Map);
	void  UpDateDeltaPheromone(MapInfo * Map);
	int getTabu(int index);
	void Reset();

   
};
Ant::Ant(){
  
   for(int i=0;i<iCityNumber;i++){

	    iA_Tabu[i]=0;
	    iA_Allowed[i]=1;
   }

	PathLength=0.0;
	iCityCount=0;
	
   

}

void Ant::AddCity(int CityIndex)
{

	
	iA_Tabu[iCityCount]=CityIndex;
	iCityCount++;
	iA_Allowed[CityIndex]=0;
}

double Ant::GetOneDirectProbility(MapInfo * Map,int i,int j){
      double p=0.0;
	  p=pow((1.0/ Map->GetDistance(i,j)  ),dBeta)*pow((Map->GetPheromone(i,j)),dAlpha);	
	  if( p<=0)p=rnd(0,1)*pow( (1.0 / Map->GetDistance(i,j)), dBeta);  
	   return p;
	  

	

}

void Ant::NextCity(MapInfo * Map){
	int i,to=-1;
	double TotalP=0.0;	
	int curCity=iA_Tabu[iCityCount-1];	

	if(iCount<6)	
	{
		for (i=0;i<iCityNumber;i++) {
			if((iA_Allowed[i]==1)) {
				
				TotalP += GetOneDirectProbility(Map,curCity,i);
			}
		}

		if(TotalP==0.0)
		{
			to=rand()%iCityNumber;
		}
		else
		{
			for(to=0;to<iCityNumber;to++)
			{
				double p;
				if(iA_Allowed[to]==1)
				{
					p=GetOneDirectProbility(Map,curCity,to)/TotalP;
					if(rnd(0,1)<p)	
						break;
				}
			}
		}
		if(to==iCityNumber)
		{
			TotalP=-1;
			for(i=0;i<iCityNumber;i++)
				if(iA_Allowed[i]==1)
				{
					if (TotalP<GetOneDirectProbility(Map,curCity,i)) {
						TotalP=GetOneDirectProbility(Map,curCity,i);	
						to=i;
					}
				}
		}
	}
	
	if(iCount>=6)	//当连续6代都没有产生更短的路径，则
	{
		for ( i=0;i<iCityCount;i++) {
			if((iA_Allowed[i]==1)) {
				to=i;
				iCount=0;
				dRou=0.5;
				if(rnd(0.0,1.0)>0.5)	//随机选择一个还没访问的城市
				{
					break;
				}
			}
		}
	}

	AddCity(to);
     

}

double Ant::GetPathLength(){

	return PathLength;
}

void Ant::SetPathLength(MapInfo * Map){

	for(int i=0;i<iCityNumber-1;i++)
	{
		PathLength+=Map->GetDistance(iA_Tabu[i],iA_Tabu[i+1]);
	}
	PathLength+=Map->GetDistance(iA_Tabu[iCityNumber-1],iA_Tabu[0]);
}

void Ant::UpDateDeltaPheromone(MapInfo * Map){
     
	int from,to;
	for (int j=0;j<iCityNumber-1;j++) { 
			from=iA_Tabu[j];
			to=iA_Tabu[j+1];
			Map->AddDeltaPheromone(from,to,Q/PathLength);
			Map->AddDeltaPheromone(to,from,Q/PathLength);
			//Map->w_dDeltaPheromone[from][to]+=Q/PathLength;  
			//Map->w_dDeltaPheromone[to][from]=Map->w_dDeltaPheromone[from][to]; //两个方向的信息量相等
		}
		from=iA_Tabu[iCityCount-1];
		to=iA_Tabu[0];
		Map->w_dDeltaPheromone[from][to]+=Q/PathLength ;	//加上起点和终点之间的信息量
		Map->w_dDeltaPheromone[to][from]=Map->w_dDeltaPheromone[from][to]; //两个方向的信息量相等

    
}
int Ant::getTabu(int index)
{
	return iA_Tabu[index];
}

void Ant::Reset(){

	iCityCount=0;
    
	for(int i=0;i<iCityNumber;i++){
	
		
		iA_Allowed[i]=1;
	}
	
	PathLength=0.0;

    AddCity(iA_Tabu[iCityNumber-1]);


}