人工蜂群算法求解TSP旅行商问题C++（2020.11.13）

最新推荐文章于 2024-09-19 23:23:57 发布
最新推荐文章于 2024-09-19 23:23:57 发布
阅读量2.6k 收藏 28
点赞数 6
分类专栏： C++ 实践经验 文章标签： 人工蜂群算法 旅行商问题 C++ 路径优化 全局最优解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jing_zhong/article/details/109677492
版权

ABC算法求解TSP问题的C++实现

1、输入数据文件：bayg29.tsp

   1    1150.0  1760.0
   2     630.0  1660.0
   3      40.0  2090.0
   4     750.0  1100.0
   5     750.0  2030.0
   6    1030.0  2070.0
   7    1650.0   650.0
   8    1490.0  1630.0
   9     790.0  2260.0
  10     710.0  1310.0
  11     840.0   550.0
  12    1170.0  2300.0
  13     970.0  1340.0
  14     510.0   700.0
  15     750.0   900.0
  16    1280.0  1200.0
  17     230.0   590.0
  18     460.0   860.0
  19    1040.0   950.0
  20     590.0  1390.0
  21     830.0  1770.0
  22     490.0   500.0
  23    1840.0  1240.0
  24    1260.0  1500.0
  25    1280.0   790.0
  26     490.0  2130.0
  27    1460.0  1420.0
  28    1260.0  1910.0
  29     360.0  1980.0

2、头文件

#include <iostream>
#include <string>
#include <fstream>
#include <random>
#include <time.h>
using namespace std;

3、所需的类

        程序中用到了城市类City、包含城市的地图类Graph、蜜蜂类Bee和人工蜂群算法类ABC

3.1 城市类City

class City
{
public:
	string name;//城市名称
	double x, y;//城市点的二维坐标
	void shuchu()
	{
		std::cout << name + ":" << "(" << x << "," << y << ")" << endl;
	}
};

3.2 包含城市的地图类Graph

class Graph
{
public:
	int Citycount;
	City *city;//城市数组
	double distance[citycount][citycount];//城市间的距离矩阵
	void Readcoordinatetxt(string txtfilename)//读取城市坐标文件的函数
	{
		Citycount = citycount;
		city = new City[Citycount];
		ifstream myfile(txtfilename, ios::in);
		double x = 0, y = 0;
		int z = 0;
		if (!myfile.fail())
		{
			int i = 0;
			while (!myfile.eof() && (myfile >> z >> x >> y))
			{
				city[i].name = to_string(_Longlong(z));//城市名称转化为字符串
				city[i].x = x; city[i].y = y;
				i++;
			}
		}
		else
			cout << "文件不存在";
		myfile.close();//计算城市距离矩阵
		for (int i = 0; i < citycount; i++)
			for (int j = 0; j < citycount; j++)
			{
				distance[i][j] = sqrt((pow((city[i].x - city[j].x), 2) + pow((city[i].y - city[j].y), 2)) / 10.0);//计算城市ij之间的伪欧式距离
				if (round(distance[i][j] < distance[i][j]))distance[i][j] = round(distance[i][j]) + 1;
				else distance[i][j] = round(distance[i][j]);
			}
	}
	void shuchu()
	{
		cout << "城市名称 " << "坐标x" << " " << "坐标y" << endl;
		for (int i = 0; i < citycount; i++)
			city[i].shuchu();
		cout << "距离矩阵： " << endl;
		for (int i = 0; i < citycount; i++)
		{
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					std::cout << distance[i][j] << endl;
				else
					std::cout << distance[i][j] << "  ";
			}
		}
	}
};

3.3 蜜蜂类Bee

class Bee
{
	public:
		int dimension;//变量的维数
		int *x;
		double fitdegreevalue = 0;
		double selectprobability = 0;
		int limitcishu = 0;
		void Init(int Dimension)
		{
			dimension = Dimension;
			x = new int[dimension];
			for (int j = 0; j < citycount; j++)
			{
				*(x + j) = round(xmin + u(random)*(xmax - xmin));//随机初始化可行解
			}
			Adjuxt_validParticle(x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
		}
		void shuchu()
		{
			for (int j = 0; j < dimension; j++)
			{
				if (j == dimension - 1)std::cout << x[j] << ")"<< endl;
				else if (j == 0)
					std::cout << "(" << x[j] << ", ";
				else
					std::cout << x[j] << ", ";
			}
		}
};

3.4 人工蜂群算法类ABC

class ABC
{
public:
	Bee *miyuan, bestmiyuan, *employedbee, *onlookerbee;//蜜源、最好蜜源、雇佣蜂、观察蜂
	int SN;//雇佣蜂的数量、蜜源的数量、观察蜂的数量相等
	int Dimension;//可行解的维数
	int MCN;//终止代数
	int Limit;//为防止算法陷入局部最优，蜜源最大改进次数
	void Init(int sn, int dimension, int mcn, int limit)
	{
		SN = sn;
		Dimension = dimension;
		MCN = mcn;
		Limit = limit;
		miyuan = new Bee[SN];
		employedbee = new Bee[SN];
		onlookerbee = new Bee[SN];
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->Init(Dimension);
			double beefunvalue = CalculateFitValue(*(miyuan + i));
			(miyuan + i)->fitdegreevalue = CalculateFitDegree(beefunvalue);

			(employedbee + i)->Init(Dimension);
			double employedbeefunvalue = CalculateFitValue(*(employedbee + i));
			(employedbee + i)->fitdegreevalue = CalculateFitDegree(employedbeefunvalue);

			(onlookerbee + i)->Init(Dimension);
			double onlookerbeefunvalue = CalculateFitValue(*(onlookerbee + i));
			(onlookerbee + i)->fitdegreevalue = CalculateFitDegree(onlookerbeefunvalue);
		}
		bestmiyuan.Init(Dimension);//最好蜜源初始化
		for (int j = 0; j < Dimension; j++)
		{
			bestmiyuan.x[j] = miyuan->x[j];
		}
		bestmiyuan.fitdegreevalue = miyuan->fitdegreevalue;
	}
	double CalculateFitValue(Bee be)//适应值计算函数，即计算路径长度
	{
		double funvalue = 0;
		for (int i = 0; i < citycount - 1; i++)
			funvalue += Map_City.distance[be.x[i]-1][be.x[i + 1]-1];
		funvalue += Map_City.distance[be.x[citycount - 1]-1][be.x[0]-1];
		return funvalue;
	}
	double CalculateFitDegree(double fi)//计算适应度的函数
	{
		double fitnessdu = 0;
		if (fi > 0)
			fitnessdu = 1.0 / (1 + fi);
		else
			fitnessdu = 1 + abs(fi);
		return fitnessdu;
	}
	void EmployedBeeOperate()//雇佣蜂操作函数
	{
		std::uniform_int_distribution<int> uD(1, Dimension); //随机数分布对象
		std::uniform_int_distribution<int> uSN(1, SN); //随机数分布对象
		for (int i = 0; i < SN; i++)
		{
			for (int j = 0; j < Dimension; j++)//雇佣峰利用先前的蜜源信息寻找新的蜜源
			{
				(employedbee + i)->x[j] = (miyuan + i)->x[j];
			}
			int k, jie;//随机生成且 k≠i k∈[1,SN]
			jie = uD(random) - 1;//jie为【1，Dimension】上的随机数
			double φ = u1(random);//φ表示[-1,1]之间的随机数
			while (true)
			{
				k = uSN(random) - 1;
				if (k != i)break;
			}
			(employedbee + i)->x[jie] = (miyuan + i)->x[jie] + φ*((miyuan + i)->x[jie] - (miyuan + k)->x[jie]);//搜索新蜜源
			//保证蜜源位置不越界
			if ((employedbee + i)->x[jie] > xmax) (employedbee + i)->x[jie] = xmax;
			else if ((employedbee + i)->x[jie] < xmin) (employedbee + i)->x[jie] = xmin;
			Adjuxt_validParticle((employedbee + i)->x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
			(employedbee + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(employedbee + i)));//计算适应度值																							  //雇佣蜂根据贪心策略选择蜜源
			if (CalculateFitValue(*(employedbee + i)) < CalculateFitValue(*(miyuan + i)))
			{
				for (int j = 0; j < Dimension; j++)
					(miyuan + i)->x[j] = (employedbee + i)->x[j];
				(miyuan + i)->limitcishu = 0;
				(miyuan + i)->fitdegreevalue = (employedbee + i)->fitdegreevalue;
			}
			else
				(miyuan + i)->limitcishu++;//蜜源未改进次数加一
		}
	}
	void CalculateProbability()//计算蜜源概率的函数
	{
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(miyuan + i)));
		}
		double sumfitdegreevalue = 0;
		for (int i = 0; i < SN; i++)
		{
			sumfitdegreevalue += (miyuan + i)->fitdegreevalue;
		}
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->selectprobability = (miyuan + i)->fitdegreevalue / sumfitdegreevalue;
		}
	}
	void OnLookerBeeOperate()//观察蜂操作
	{
		std::uniform_int_distribution<int> uD(1, Dimension); //随机数分布对象
		std::uniform_int_distribution<int> uSN(1, SN); //随机数分布对象
		int m = 0;
		while (m < SN)//为所有的观察蜂按照概率选择蜜源并搜索新蜜源，计算新蜜源适应值
		{
			double m_choosedprobability = u(random);//0~1之间的随机数
			for (int i = 0; i < SN; i++)
			{
				if (m_choosedprobability < (miyuan + i)->selectprobability)
				{
					int k, jie;//随机生成且 k≠i k∈[1,SN]
					jie = uD(random) - 1;//jie为【1，Dimension】上的随机数
					double φ = u1(random);//φ表示[-1,1]之间的随机数
					while (true)
					{
						k = uSN(random) - 1;
						if (k != i)break;
					}
					for (int j = 0; j < Dimension; j++)
						(onlookerbee + m)->x[j] = (miyuan + i)->x[j];
					(onlookerbee + m)->x[jie] = (miyuan + i)->x[jie] + φ*((miyuan + i)->x[jie] - (miyuan + k)->x[jie]);//搜索新蜜源
					if ((onlookerbee + m)->x[jie] > xmax) (onlookerbee + m)->x[jie] = xmax;
					else if ((onlookerbee + m)->x[jie] < xmin) (onlookerbee + m)->x[jie] = xmin;//判断是否越界
					Adjuxt_validParticle((onlookerbee + m)->x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
					(onlookerbee + m)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(onlookerbee + m)));
					//贪心策略选择蜜源
					if (CalculateFitValue(*(onlookerbee + m)) < CalculateFitValue(*(miyuan + i)))
					{
						for (int j = 0; j < Dimension; j++)
							(miyuan + i)->x[j] = (onlookerbee + m)->x[j];
						(miyuan + i)->fitdegreevalue = (onlookerbee + m)->fitdegreevalue;
					}
					else
						(miyuan + i)->limitcishu++;
					m++;
				}break;
			}
		}
	}
	void ScoutBeeOperate()//侦查蜂操作,决定蜜源是否放弃，并随机产生新位置替代原蜜源
	{
		for (int i = 0; i < SN; i++)
		{
			if ((miyuan + i)->limitcishu >= Limit)
			{
				for (int j = 0; j < Dimension; j++)
				{
					(miyuan + i)->x[j] = round(xmin + u(random)*(xmax - xmin));//随机初始化可行解;//随机产生可行解
				}
				Adjuxt_validParticle((miyuan + i)->x);
				(miyuan + i)->limitcishu = 0;
				(miyuan + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(miyuan + i)));
			}
		}
	}
	void SaveBestMiyuan()//记录最优解的函数
	{
		for (int i = 0; i < SN; i++)
		{
			if (CalculateFitValue(*(miyuan + i)) < CalculateFitValue(bestmiyuan))
			{
				for (int j = 0; j < Dimension; j++)
					bestmiyuan.x[j] = (miyuan + i)->x[j];
			}
		}
	}
	void shuchumiyuan()
	{
		for (int i = 0; i < SN; i++)
		{
			std::cout << "蜜源" << i + 1<<"->";
			for (int j = 0; j < Dimension; j++)
			{
				if (j == Dimension - 1)std::cout << (miyuan + i)->x[j] <<")对应的距离为： "<<CalculateFitValue(*(miyuan+i))<< endl;
				else if(j==0)
					std::cout <<"("<< (miyuan + i)->x[j] << ", ";
				else
					std::cout << (miyuan + i)->x[j] << ", ";
			}
		}
	}
	void ShuchuBestmiyuan()
	{
		for (int j = 0; j < Dimension; j++)
		{
			if (j == Dimension - 1) std::cout << bestmiyuan.x[j] << ")" << "对应的距离为：" << CalculateFitValue(bestmiyuan) << endl;
			else if (j == 0) std::cout << "(" << bestmiyuan.x[j] << ",";
			else std::cout << bestmiyuan.x[j] << ",";
		}
	}
	void DoABC(int sn, int dimension, int mcn, int limit,string filename)//运行人工蜂群算法的函数
	{
		ofstream outfile;
		outfile.open("result.txt", ios::trunc);
		Map_City.Readcoordinatetxt(filename);
		Map_City.shuchu();
		outfile << "城市名称 " << "坐标x" << " " << "坐标y" << endl;
		for (int i = 0; i < citycount; i++)
			outfile << Map_City.city[i].name << " " << Map_City.city[i].x << " " << Map_City.city[i].y << endl;
		outfile << "距离矩阵： " << endl;
		for (int i = 0; i < citycount; i++)
		{
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << Map_City.distance[i][j] << endl;
				else
					outfile << Map_City.distance[i][j] << "  ";
			}
		}
		Init(sn, dimension, mcn, limit);//初始化
		shuchumiyuan();
		outfile << "初始化后的蜜源如下：" << endl;
		for (int i = 0; i < SN; i++)
		{
			outfile << "蜜源" << i + 1 << "->";
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << (miyuan + i)->x[j] << ") = " << CalculateFitValue(*(miyuan + i)) << endl;
				else if (j == 0)
					outfile << "f(" << (miyuan + i)->x[j] << ",";
				else
					outfile << (miyuan + i)->x[j] << ",";
			}
		}
		SaveBestMiyuan();//保存最好蜜源
		ShuchuBestmiyuan();
		for (int k = 0; k < MCN; k++)
		{
			EmployedBeeOperate();
			CalculateProbability();
			OnLookerBeeOperate();
			SaveBestMiyuan();
			ScoutBeeOperate();
			SaveBestMiyuan();
			std::cout << "第" << k + 1 << "次迭代的最优解为：";
			ShuchuBestmiyuan();
			outfile << "第"<<k+1<<"次迭代后的蜜源如下：" << endl;
			for (int i = 0; i < SN; i++)
			{
				outfile << "蜜源" << i + 1 << "->";
				for (int j = 0; j < citycount; j++)
				{
					if (j == citycount - 1)
						outfile << (miyuan + i)->x[j] << ") = " << CalculateFitValue(*(miyuan + i)) << endl;
					else if (j == 0)
						outfile << "f(" << (miyuan + i)->x[j] << ",";
					else
						outfile << (miyuan + i)->x[j] << ",";
				}
			}
			outfile << "第" << k + 1 << "次迭代的最优蜜源为：";
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << bestmiyuan.x[j] << ") = " << CalculateFitValue(bestmiyuan) << endl;
				else if (j == 0)
					outfile << "f(" << bestmiyuan.x[j] << ",";
				else
					outfile << bestmiyuan.x[j] << ",";
			}
		}
		outfile.close();
	}
};

4、自定义函数

        自定义的函数有两个：四舍五入取整函数、蜜源路径有效性调整函数

4.1 四舍五入取整函数

double round(double r) { return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5); }

4.2 调整蜜源路径有效性的函数

void Adjuxt_validParticle(int x[citycount])//调整蜜源路径有效性的函数，使得蜜源的位置符合TSP问题解的一个排列
{
	int route[citycount];//1-citycount
	bool flag[citycount];//对应route数组中是否在位置中存在的数组，参考数组为route
	int biaoji[citycount];//对每个元素进行标记的数组,参考数组为粒子位置x
	for (int j = 0; j < citycount; j++)
	{
		route[j] = j + 1;
		flag[j] = false;
		biaoji[j] = 0;
	}
	//首先判断位置中是否有某个城市且唯一，若有且唯一，则对应flag的值为true,
	for (int j = 0; j < citycount; j++)
	{
		int num = 0;
		for (int k = 0; k < citycount; k++)
		{
			if (x[k] == route[j])
			{
				biaoji[k] = 1;//说明k号元素对应的城市在route中，并且是第一次出现才进行标记
				num++; break;
			}
		}
		if (num == 0) flag[j] = false;//路线中没有route[j]这个城市
		else if (num == 1) flag[j] = true;//路线中有route[j]这个城市
	}
	for (int k = 0; k < citycount; k++)
	{
		if (flag[k] == false)//路线中没有route[k]这个城市，需要将这个城市加入到路线中
		{
			int i = 0;
			for (; i < citycount; i++)
			{
				if (biaoji[i] != 1)break;
			}
			x[i] = route[k];//对于标记为0的进行替换
			biaoji[i] = 1;
		}
	}
}

5、全局变量

const int citycount = 29;
double xmax = citycount, xmin = 1;
std::default_random_engine random((unsigned int)time(NULL));
std::uniform_real_distribution<double> u(0, 1); //随机数分布对象
std::uniform_real_distribution<double> u1(-1, 1); //随机数分布对象
Graph Map_City;//定义全局对象图,放在Graph类后

6、主函数

int main()
{
	system("mode con cols=200");
	system("color fc");
	std::cout << "人工蜂群算法求解TSP旅行商问题！" << endl;
	ABC abc;
	abc.DoABC(50, citycount, 200, 20, "E:\\计算智能代码\\ABC_TSP\\ABC_TSP\\bayg29.tsp");
	system("pause");
	return 0;
}

7、运行结果

7.1 控制台结果

在这里插入图片描述

7.2 生成的result.txt文件结果

在这里插入图片描述
在这里插入图片描述

8、MATLAB绘制最优路径结果

在这里插入图片描述

附录（完整代码）

#include <iostream>
#include <string>
#include <fstream>
#include <random>
#include <time.h>
using namespace std;
const int citycount = 29;
double xmax = citycount, xmin = 1;
std::default_random_engine random((unsigned int)time(NULL));
std::uniform_real_distribution<double> u(0, 1); //随机数分布对象
std::uniform_real_distribution<double> u1(-1, 1); //随机数分布对象
class City
{
public:
	string name;//城市名称
	double x, y;//城市点的二维坐标
	void shuchu()
	{
		std::cout << name + ":" << "(" << x << "," << y << ")" << endl;
	}
};
class Graph
{
public:
	int Citycount;
	City *city;//城市数组
	double distance[citycount][citycount];//城市间的距离矩阵
	void Readcoordinatetxt(string txtfilename)//读取城市坐标文件的函数
	{
		Citycount = citycount;
		city = new City[Citycount];
		ifstream myfile(txtfilename, ios::in);
		double x = 0, y = 0;
		int z = 0;
		if (!myfile.fail())
		{
			int i = 0;
			while (!myfile.eof() && (myfile >> z >> x >> y))
			{
				city[i].name = to_string(_Longlong(z));//城市名称转化为字符串
				city[i].x = x; city[i].y = y;
				i++;
			}
		}
		else
			cout << "文件不存在";
		myfile.close();//计算城市距离矩阵
		for (int i = 0; i < citycount; i++)
			for (int j = 0; j < citycount; j++)
			{
				distance[i][j] = sqrt((pow((city[i].x - city[j].x), 2) + pow((city[i].y - city[j].y), 2)) / 10.0);//计算城市ij之间的伪欧式距离
				if (round(distance[i][j] < distance[i][j]))distance[i][j] = round(distance[i][j]) + 1;
				else distance[i][j] = round(distance[i][j]);
			}
	}
	void shuchu()
	{
		cout << "城市名称 " << "坐标x" << " " << "坐标y" << endl;
		for (int i = 0; i < citycount; i++)
			city[i].shuchu();
		cout << "距离矩阵： " << endl;
		for (int i = 0; i < citycount; i++)
		{
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					std::cout << distance[i][j] << endl;
				else
					std::cout << distance[i][j] << "  ";
			}
		}
	}
};
Graph Map_City;//定义全局对象图,放在Graph类后
double round(double r) { return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5); }
void Adjuxt_validParticle(int x[citycount])//调整蜜源路径有效性的函数，使得蜜源的位置符合TSP问题解的一个排列
{
	int route[citycount];//1-citycount
	bool flag[citycount];//对应route数组中是否在位置中存在的数组，参考数组为route
	int biaoji[citycount];//对每个元素进行标记的数组,参考数组为粒子位置x
	for (int j = 0; j < citycount; j++)
	{
		route[j] = j + 1;
		flag[j] = false;
		biaoji[j] = 0;
	}
	//首先判断位置中是否有某个城市且唯一，若有且唯一，则对应flag的值为true,
	for (int j = 0; j < citycount; j++)
	{
		int num = 0;
		for (int k = 0; k < citycount; k++)
		{
			if (x[k] == route[j])
			{
				biaoji[k] = 1;//说明k号元素对应的城市在route中，并且是第一次出现才进行标记
				num++; break;
			}
		}
		if (num == 0) flag[j] = false;//路线中没有route[j]这个城市
		else if (num == 1) flag[j] = true;//路线中有route[j]这个城市
	}
	for (int k = 0; k < citycount; k++)
	{
		if (flag[k] == false)//路线中没有route[k]这个城市，需要将这个城市加入到路线中
		{
			int i = 0;
			for (; i < citycount; i++)
			{
				if (biaoji[i] != 1)break;
			}
			x[i] = route[k];//对于标记为0的进行替换
			biaoji[i] = 1;
		}
	}
}
class Bee
{
	public:
		int dimension;//变量的维数
		int *x;
		double fitdegreevalue = 0;
		double selectprobability = 0;
		int limitcishu = 0;
		void Init(int Dimension)
		{
			dimension = Dimension;
			x = new int[dimension];
			for (int j = 0; j < citycount; j++)
			{
				*(x + j) = round(xmin + u(random)*(xmax - xmin));//随机初始化可行解
			}
			Adjuxt_validParticle(x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
		}
		void shuchu()
		{
			for (int j = 0; j < dimension; j++)
			{
				if (j == dimension - 1)std::cout << x[j] << ")"<< endl;
				else if (j == 0)
					std::cout << "(" << x[j] << ", ";
				else
					std::cout << x[j] << ", ";
			}
		}
};
class ABC
{
public:
	Bee *miyuan, bestmiyuan, *employedbee, *onlookerbee;//蜜源、最好蜜源、雇佣蜂、观察蜂
	int SN;//雇佣蜂的数量、蜜源的数量、观察蜂的数量相等
	int Dimension;//可行解的维数
	int MCN;//终止代数
	int Limit;//为防止算法陷入局部最优，蜜源最大改进次数
	void Init(int sn, int dimension, int mcn, int limit)
	{
		SN = sn;
		Dimension = dimension;
		MCN = mcn;
		Limit = limit;
		miyuan = new Bee[SN];
		employedbee = new Bee[SN];
		onlookerbee = new Bee[SN];
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->Init(Dimension);
			double beefunvalue = CalculateFitValue(*(miyuan + i));
			(miyuan + i)->fitdegreevalue = CalculateFitDegree(beefunvalue);

			(employedbee + i)->Init(Dimension);
			double employedbeefunvalue = CalculateFitValue(*(employedbee + i));
			(employedbee + i)->fitdegreevalue = CalculateFitDegree(employedbeefunvalue);

			(onlookerbee + i)->Init(Dimension);
			double onlookerbeefunvalue = CalculateFitValue(*(onlookerbee + i));
			(onlookerbee + i)->fitdegreevalue = CalculateFitDegree(onlookerbeefunvalue);
		}
		bestmiyuan.Init(Dimension);//最好蜜源初始化
		for (int j = 0; j < Dimension; j++)
		{
			bestmiyuan.x[j] = miyuan->x[j];
		}
		bestmiyuan.fitdegreevalue = miyuan->fitdegreevalue;
	}
	double CalculateFitValue(Bee be)//适应值计算函数，即计算路径长度
	{
		double funvalue = 0;
		for (int i = 0; i < citycount - 1; i++)
			funvalue += Map_City.distance[be.x[i]-1][be.x[i + 1]-1];
		funvalue += Map_City.distance[be.x[citycount - 1]-1][be.x[0]-1];
		return funvalue;
	}
	double CalculateFitDegree(double fi)//计算适应度的函数
	{
		double fitnessdu = 0;
		if (fi > 0)
			fitnessdu = 1.0 / (1 + fi);
		else
			fitnessdu = 1 + abs(fi);
		return fitnessdu;
	}
	void EmployedBeeOperate()//雇佣蜂操作函数
	{
		std::uniform_int_distribution<int> uD(1, Dimension); //随机数分布对象
		std::uniform_int_distribution<int> uSN(1, SN); //随机数分布对象
		for (int i = 0; i < SN; i++)
		{
			for (int j = 0; j < Dimension; j++)//雇佣峰利用先前的蜜源信息寻找新的蜜源
			{
				(employedbee + i)->x[j] = (miyuan + i)->x[j];
			}
			int k, jie;//随机生成且 k≠i k∈[1,SN]
			jie = uD(random) - 1;//jie为【1，Dimension】上的随机数
			double φ = u1(random);//φ表示[-1,1]之间的随机数
			while (true)
			{
				k = uSN(random) - 1;
				if (k != i)break;
			}
			(employedbee + i)->x[jie] = (miyuan + i)->x[jie] + φ*((miyuan + i)->x[jie] - (miyuan + k)->x[jie]);//搜索新蜜源
			//保证蜜源位置不越界
			if ((employedbee + i)->x[jie] > xmax) (employedbee + i)->x[jie] = xmax;
			else if ((employedbee + i)->x[jie] < xmin) (employedbee + i)->x[jie] = xmin;
			Adjuxt_validParticle((employedbee + i)->x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
			(employedbee + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(employedbee + i)));//计算适应度值																							  //雇佣蜂根据贪心策略选择蜜源
			if (CalculateFitValue(*(employedbee + i)) < CalculateFitValue(*(miyuan + i)))
			{
				for (int j = 0; j < Dimension; j++)
					(miyuan + i)->x[j] = (employedbee + i)->x[j];
				(miyuan + i)->limitcishu = 0;
				(miyuan + i)->fitdegreevalue = (employedbee + i)->fitdegreevalue;
			}
			else
				(miyuan + i)->limitcishu++;//蜜源未改进次数加一
		}
	}
	void CalculateProbability()//计算蜜源概率的函数
	{
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(miyuan + i)));
		}
		double sumfitdegreevalue = 0;
		for (int i = 0; i < SN; i++)
		{
			sumfitdegreevalue += (miyuan + i)->fitdegreevalue;
		}
		for (int i = 0; i < SN; i++)
		{
			(miyuan + i)->selectprobability = (miyuan + i)->fitdegreevalue / sumfitdegreevalue;
		}
	}
	void OnLookerBeeOperate()//观察蜂操作
	{
		std::uniform_int_distribution<int> uD(1, Dimension); //随机数分布对象
		std::uniform_int_distribution<int> uSN(1, SN); //随机数分布对象
		int m = 0;
		while (m < SN)//为所有的观察蜂按照概率选择蜜源并搜索新蜜源，计算新蜜源适应值
		{
			double m_choosedprobability = u(random);//0~1之间的随机数
			for (int i = 0; i < SN; i++)
			{
				if (m_choosedprobability < (miyuan + i)->selectprobability)
				{
					int k, jie;//随机生成且 k≠i k∈[1,SN]
					jie = uD(random) - 1;//jie为【1，Dimension】上的随机数
					double φ = u1(random);//φ表示[-1,1]之间的随机数
					while (true)
					{
						k = uSN(random) - 1;
						if (k != i)break;
					}
					for (int j = 0; j < Dimension; j++)
						(onlookerbee + m)->x[j] = (miyuan + i)->x[j];
					(onlookerbee + m)->x[jie] = (miyuan + i)->x[jie] + φ*((miyuan + i)->x[jie] - (miyuan + k)->x[jie]);//搜索新蜜源
					if ((onlookerbee + m)->x[jie] > xmax) (onlookerbee + m)->x[jie] = xmax;
					else if ((onlookerbee + m)->x[jie] < xmin) (onlookerbee + m)->x[jie] = xmin;//判断是否越界
					Adjuxt_validParticle((onlookerbee + m)->x);//对蜜源路径进行有效性调整，确保是TSP问题的一个可行解
					(onlookerbee + m)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(onlookerbee + m)));
					//贪心策略选择蜜源
					if (CalculateFitValue(*(onlookerbee + m)) < CalculateFitValue(*(miyuan + i)))
					{
						for (int j = 0; j < Dimension; j++)
							(miyuan + i)->x[j] = (onlookerbee + m)->x[j];
						(miyuan + i)->fitdegreevalue = (onlookerbee + m)->fitdegreevalue;
					}
					else
						(miyuan + i)->limitcishu++;
					m++;
				}break;
			}
		}
	}
	void ScoutBeeOperate()//侦查蜂操作,决定蜜源是否放弃，并随机产生新位置替代原蜜源
	{
		for (int i = 0; i < SN; i++)
		{
			if ((miyuan + i)->limitcishu >= Limit)
			{
				for (int j = 0; j < Dimension; j++)
				{
					(miyuan + i)->x[j] = round(xmin + u(random)*(xmax - xmin));//随机初始化可行解;//随机产生可行解
				}
				Adjuxt_validParticle((miyuan + i)->x);
				(miyuan + i)->limitcishu = 0;
				(miyuan + i)->fitdegreevalue = CalculateFitDegree(CalculateFitValue(*(miyuan + i)));
			}
		}
	}
	void SaveBestMiyuan()//记录最优解的函数
	{
		for (int i = 0; i < SN; i++)
		{
			if (CalculateFitValue(*(miyuan + i)) < CalculateFitValue(bestmiyuan))
			{
				for (int j = 0; j < Dimension; j++)
					bestmiyuan.x[j] = (miyuan + i)->x[j];
			}
		}
	}
	void shuchumiyuan()
	{
		for (int i = 0; i < SN; i++)
		{
			std::cout << "蜜源" << i + 1<<"->";
			for (int j = 0; j < Dimension; j++)
			{
				if (j == Dimension - 1)std::cout << (miyuan + i)->x[j] <<")对应的距离为： "<<CalculateFitValue(*(miyuan+i))<< endl;
				else if(j==0)
					std::cout <<"("<< (miyuan + i)->x[j] << ", ";
				else
					std::cout << (miyuan + i)->x[j] << ", ";
			}
		}
	}
	void ShuchuBestmiyuan()
	{
		for (int j = 0; j < Dimension; j++)
		{
			if (j == Dimension - 1) std::cout << bestmiyuan.x[j] << ")" << "对应的距离为：" << CalculateFitValue(bestmiyuan) << endl;
			else if (j == 0) std::cout << "(" << bestmiyuan.x[j] << ",";
			else std::cout << bestmiyuan.x[j] << ",";
		}
	}
	void DoABC(int sn, int dimension, int mcn, int limit,string filename)//运行人工蜂群算法的函数
	{
		ofstream outfile;
		outfile.open("result.txt", ios::trunc);
		Map_City.Readcoordinatetxt(filename);
		Map_City.shuchu();
		outfile << "城市名称 " << "坐标x" << " " << "坐标y" << endl;
		for (int i = 0; i < citycount; i++)
			outfile << Map_City.city[i].name << " " << Map_City.city[i].x << " " << Map_City.city[i].y << endl;
		outfile << "距离矩阵： " << endl;
		for (int i = 0; i < citycount; i++)
		{
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << Map_City.distance[i][j] << endl;
				else
					outfile << Map_City.distance[i][j] << "  ";
			}
		}
		Init(sn, dimension, mcn, limit);//初始化
		shuchumiyuan();
		outfile << "初始化后的蜜源如下：" << endl;
		for (int i = 0; i < SN; i++)
		{
			outfile << "蜜源" << i + 1 << "->";
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << (miyuan + i)->x[j] << ") = " << CalculateFitValue(*(miyuan + i)) << endl;
				else if (j == 0)
					outfile << "f(" << (miyuan + i)->x[j] << ",";
				else
					outfile << (miyuan + i)->x[j] << ",";
			}
		}
		SaveBestMiyuan();//保存最好蜜源
		ShuchuBestmiyuan();
		for (int k = 0; k < MCN; k++)
		{
			EmployedBeeOperate();
			CalculateProbability();
			OnLookerBeeOperate();
			SaveBestMiyuan();
			ScoutBeeOperate();
			SaveBestMiyuan();
			std::cout << "第" << k + 1 << "次迭代的最优解为：";
			ShuchuBestmiyuan();
			outfile << "第"<<k+1<<"次迭代后的蜜源如下：" << endl;
			for (int i = 0; i < SN; i++)
			{
				outfile << "蜜源" << i + 1 << "->";
				for (int j = 0; j < citycount; j++)
				{
					if (j == citycount - 1)
						outfile << (miyuan + i)->x[j] << ") = " << CalculateFitValue(*(miyuan + i)) << endl;
					else if (j == 0)
						outfile << "f(" << (miyuan + i)->x[j] << ",";
					else
						outfile << (miyuan + i)->x[j] << ",";
				}
			}
			outfile << "第" << k + 1 << "次迭代的最优蜜源为：";
			for (int j = 0; j < citycount; j++)
			{
				if (j == citycount - 1)
					outfile << bestmiyuan.x[j] << ") = " << CalculateFitValue(bestmiyuan) << endl;
				else if (j == 0)
					outfile << "f(" << bestmiyuan.x[j] << ",";
				else
					outfile << bestmiyuan.x[j] << ",";
			}
		}
		outfile.close();
	}
};
int main()
{
	system("mode con cols=200");
	system("color fc");
	std::cout << "人工蜂群算法求解TSP旅行商问题！" << endl;
	ABC abc;
	abc.DoABC(50, citycount, 200, 20, "E:\\计算智能代码\\ABC_TSP\\ABC_TSP\\bayg29.tsp");
	system("pause");
	return 0;
}
jing_zhong
关注
专栏目录
【TSP问题】基于人工蜂群算法求解旅行商问题含Matlab源码
qq_59747472的博客
04-23 1092
1 简介 采用人工蜂群算法对旅行商问题进行求解,给出了人工蜂群算法求解该问题的具体方案,对不同的旅行商问题算例进行了仿真实验。结果表明,算法可以有效、快速地找到较小规模问题的最优解。 2 部分代码 function varargout = dsxy2figxy(varargin)if length(varargin{1}) == 1 && ishandle(varargin{1}) ... && s
【基于人工蜂群算法的TSP商旅最优路线规划matlab仿真及对比】——用AI实现最优路线规划
.
04-01 447
交通在我们的生活中扮演着极其重要的角色，而最优路线规划则是让我们把时间和距离都用得最妙的重要手段。本文将介绍一种基于人工蜂群算法的TSP商旅最优路线规划matlab仿真，并且将对比计算出的最优路线和原始路线之间的差异。本文介绍了一种基于人工蜂群算法的TSP商旅最优路线规划matlab仿真，并且展示了如何对比计算出的最优路线和原始路线之间的不同之处。最后，我们可以使用计算出的最优路线和原始路线之间的差异来对比两者之间的区别。首先，我们需要创建一个包含所有城市坐标的矩阵，并根据这些坐标计算出城市间的距离矩阵。
仿生智能 群体智能 人工蜂群算法解决TSP旅行商问题 共50页.pptx
09-19
很多实际问题都属于TSP问题的范畴 1、旅游景区规划问题，描述的是游客应如何规划旅游线路，使得所经过的路径总和最小； 2、物流配送问题，对车辆的配送网络进行优化，缩短配送时间，从而提高顾客满意度； 3、公交线路规划问题只在规划路径网络，寻找最优的公交路线设置，从而满足群体的需求。 ……. 旅行商问题(TSP，traveling salesman problem)是一个为学术界广泛研究的问题，长期以来它吸引了众多学者对其进行研究。深入地研究TSP问题能够为解决实际的管理问题提供一定的理论基础。 群体智能算法 群体智能算法(Swarm Intelligence Algorithm，SIA)是模拟自然界生物的群体行为而构造的随机优化算法，是在群体智能领域中随着计算智能研究的逐步深入而产生的一种新兴的计算智能模式，它是群体智能研究中的一个重要分支。群体智能算法是从某种由大量个体表现出来的群体行为出发，从它们的群体行为中提取模型，为这些行为建立一些规则，从而提出优化算法。在群体智能算法中，每一个个体都是具有经验和智慧的智能体(Agent)，个体之间存在互相作用机制，通过相互作用形成强大的群体智慧，并用于解决那些因为难以建立有效的形式化模型而用传统优化方法又难以解决甚至无法解决的问题。
人工蜂群算法求解TSP问题
怡宝2号
10-19 8357
人工蜂群算法求解TSP问题 【标签】 ABC TSP Matlab data:2018-10-19 author:怡宝2号 【总起】利用人工蜂群算法（Artificial Bee Colony Algorithm, 简称ABC算法）求解TSP问题，语言：matlab 1. 算法简介 人工蜂群算法(Artificial Bee Colony Algorithm, 简称ABC算法)是一个由蜂群行为...
【智能算法应用】人工蜂群算法求解TSP问题
最新发布
Logic_9527的博客
09-19 1074
旅行商问题（TSP）是一种著名的组合优化问题，它涉及寻找给定一组城市及其之间的距离或成本，如何规划一条最短的路径，使得旅行商从起点出发，访问每个城市一次，最后回到起点。这个问题的目标是最小化总行驶距离或总成本，同时确保每个城市都被访问且只被访问一次。[2] 刘海龙,雷斌,王菀莹,等.求解TSP问题的改进融合遗传灰狼优化算法[J].计算机仿真,2023,40(09):333-338.[1] 王芬,杨媛.基于猎人猎物优化算法求解TSP问题[J].宁夏师范学院学报,2022,43(07):59-63+71.
人工蜂群算法求解TSP / 优化机器学习(SVM) / 优化决策树
weixin_42616101的博客
07-13 745
Artificial Bee Colony (ABC) 算法是一种基于自然界蜜蜂觅食行为的优化算法，由Karaboga于2005年首次提出。它是一种群体智能算法，用于在多维和高度复杂的搜索空间中寻找全局最优解。该算法在很多领域都有广泛的应用，如函数优化、数据挖掘和机器学习等。
【TSP问题】基于改进蜜蜂算法解决旅行商问题（Matlab代码实现）
weixin_66436111的博客
09-24 487
旅行商问题(TSP)是优化领域长期研究的热门问题。用于解决这些问题的最成功的方法是元启发式算法。在本研究中，改进版的 Bee 算法用于求解 GSP。除了经典蜜蜂算法之外，还开发了两种不同的城市选择和搬迁功能。使用这些功能，可以更改多个城市的位置，并且数量不定。这些新功能是在经典蜜蜂算法的延续中加入的，并且只在精英区使用，让这个版块更加精英化。因此，与现有的 Bee 算法相比，通过更少的迭代和搜索获得了更好的结果。
【TSP问题】基于人工蜂群算法求解旅行商问题含Matlab源码.zip
04-28
【TSP问题】，全称为旅行商问题（Traveling Salesman Problem），是运筹学领域一个经典的组合优化问题。该问题描述如下：给定一组城市和每对城市间的距离，寻找一条访问每个城市一次并返回起点的最短路径。这个问题...
仿生智能 群体智能 人工蜂群算法解决TSP旅行商问题 共50页.rar
09-29
尤其在面对复杂问题如旅行商问题（Traveling Salesman Problem, TSP）时，传统的方法往往力不从心，而人工蜂群算法（Artificial Bee Colony, ABC）则因其高效和适应性强的特点，被广泛应用于解决这类问题。...
【路径规划-TSP问题】基于人工蜂群算法求解旅行商问题含Matlab源码.zip
04-10
2.领域：智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，更多内容可点击博主头像 3.内容：标题所示，对于介绍可点击主页搜索博客 4.适合人群：本科，硕士...
【TSP问题】基于蜜蜂算法求解旅行商问题附matlab代码
qq_59747472的博客
12-13 494
旅行商问题(TSP)是经典的 组合优化问题之一.人工蜂群算法是近年来被提出的一种新的智能启发式算法.根据旅行商问题的模型特点,设计蜜蜂算法对算例进行仿真求解.,结果表明:蜜蜂算法可以有效的求解旅行商问题,在收敛速度,计算效率,稳定性方面相对遗传算法具有一定的优势.转存失败重新上传取消正在上传…重新上传取消。
蜂群算法优化旅行商问题
04-14
ABC_TSP，人工蜂群算法优化旅行商问题matlab代码，完整无误。
人工蜂群算法源代码（c++，matlab）
04-25
压缩包含有matlab文档，c语言源程序，并注明有详细的注释。
ABC人工蜂群算法求解函数优化实例C++（2020.11.5）
I have a dream, here my dreams come true!
11-05 4205
ABC人工蜂群算法C++人工蜂群算法原理算法流程函数优化实例 人工蜂群算法 原理         最常见的基于蜜蜂采蜜行为的蜂群算法是Karaboga(2005)提出的人工蜂群算法，通常称该算法为标准（或原始）人工蜂群算法，其主要是为了解决多维和多模的函数优化问题。         标准的人工蜂群算法通过模拟实际蜜蜂的采蜜机制将人工蜂群分为三类：雇佣
C++动态规划解决TSP(旅行商)问题
weixin_61892595的博客
05-23 1419
题目描述：某旅行商希望从某城市出发经过一系列的城市最后再回到出发的城市。这些城市之间均可直航，他希望只经过这些城市一次且旅行的总线路最短。设有n个城市，城市的编号从1到n。输入第一行为整数n，表示城市的数量。其后n行，每行有n个整数，用空格隔开，表示城市之间的距离。其中的第1个数表示城市1和城市2之间的距离，第2个数表示城市1和城市3之间的距离,…，第 n-1个数表示城市1和城市n之间的距离，依次类推。解题思路：给出一个样例，5个城市二维表格表示城市之间的距离显然我们可以想到有很多种路线，
前端js调用后端API获取数据的三种方法（2022.7.25）
热门推荐
I have a dream, here my dreams come true!
07-25 4万+
js调用后台API进行http请求的三种方法（get-post)
自己动手实现广义逆矩阵求解（2022.5.4）
I have a dream, here my dreams come true!
05-04 3059
自己动手求解广义逆矩阵（Matlab、C#、Java、Python、C++、R）
js实现浏览与保存本地常见文件 （2022.10.24）
I have a dream, here my dreams come true!
10-24 5761
javascript实现本地文件读取与保存，方便开发者使用浏览器作为IDE，解决文件查看器的烦恼！
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值