进击的小白Day029——遗传算法解决TSP问题（三）（完结）

最新推荐文章于 2023-08-24 20:25:00 发布
最新推荐文章于 2023-08-24 20:25:00 发布
阅读量141 收藏
点赞数
分类专栏： C语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011232393/article/details/88344284
版权
博主分享了在Day029中应用遗传算法解决旅行商问题（TSP）的实践过程。通过这次实现，博主强调了在编程中使用完数组、指针或变量后，如果后续仍需使用且与之前值无关，应及时初始化的重要性。
摘要由CSDN通过智能技术生成

完成，结果如下：
在这里插入图片描述
收获：
数组或者指针或者变量，用完后，如果之后的程序仍然需要用到而且与之前所得的值没有关系，一定要及时初始化，一面影响后面的使用。

贴代码：

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <math.h>
#include <time.h>
#define BOUND_DOWN 1
#define BOUND_UP 14
#define POP_SIZE 200
#define CHROM_LEN 14
#define EVO_NUM 500
#define CROSS_PROBABILITY 0.6
#define VARY_PROBABILITY 0.1

typedef struct best
{
	int num;
	float funcVal;
	int bestChrom[CHROM_LEN];
}Best;

float sglDistance(float city_1[2], float city_2[2])
{
	float s = 0;
	s = sqrt(pow((city_1[0] - city_2[0]), 2) + pow((city_1[1] - city_2[1]), 2));
	return s;
}

void wholeDistance(int chrom[POP_SIZE][CHROM_LEN], float dist[POP_SIZE], float city[CHROM_LEN][2])
{
	float sglDist[POP_SIZE][CHROM_LEN - 1];
	int i = 0, j = 0;

	for (i = 0; i < POP_SIZE; i++)
	{
		memset(sglDist[i], 0, sizeof(sglDist[i]));
	}

	for (i = 0; i < POP_SIZE; i++)
	{
		for (j = 0; j < CHROM_LEN - 1; j++)
		{
			sglDist[i][j] = sglDistance(city[chrom[i][j] - 1], city[chrom[i][j + 1] - 1]);
			dist[i] += sglDist[i][j];
		}
	}
}

void testPrint(int chrom[POP_SIZE][CHROM_LEN])
{
	int i = 0, j = 0;
	for (i = 0; i < POP_SIZE; i++)
	{
		for (j = 0; j < CHROM_LEN; j++)
		{
			if (j == (CHROM_LEN - 1))
			{
				printf("%d", chrom[i][j]);
			}
			else
			{
				printf("%d-", chrom[i][j]);
			}
		}
		printf("\n");
	}
}

void creat(int chrom[POP_SIZE][CHROM_LEN])
{
	int i = 0, j = 0, k = 0, m = 0, flag = 1;
	for (i = 0; i < POP_SIZE; i++)
	{
		for (j = 0; j < CHROM_LEN; )
		{
			flag = 1;
			m = rand() % CHROM_LEN + 1;
			for (k = 0; k < j; k++)
			{
				if (chrom[i][k] == m)
				{
					flag = 0;
					break;
				}
			}
			if (flag == 1)
			{
				chrom[i][j] = m;
				j++;
			}
			else
			{
				continue;
			}
		}
	}
}

void fit(float dist[POP_SIZE], float fitness[POP_SIZE])
{
	int i = 0;
	for (i = 0; i < POP_SIZE; i++)
	{
		fitness[i] = 1 / dist[i];
	}
}

void fitnessP(float fitness[POP_SIZE], float chooseP[POP_SIZE], float accuP[POP_SIZE])
{
	float wholeFit = 0;
	int i = 0, j = 0;
	for (i = 0; i < POP_SIZE; i++)
	{
		wholeFit += fitness[i];
	}
	for (i = 0; i < POP_SIZE; i++)
	{
		chooseP[i] = fitness[i] / wholeFit;
	}
	accuP[0] = chooseP[0];
	for (i = 1; i < POP_SIZE; i++)
	{
		accuP[i] = accuP[i - 1] + chooseP[i];
	}
}

void roulette(int chrom[POP_SIZE][CHROM_LEN], float chooseP[POP_SIZE], float accuP[POP_SIZE])
{
	float r = 0;
	int i = 0, j = 0, k = 0, m = 0;
	int tmp[POP_SIZE][CHROM_LEN];

	for (i = 0; i < POP_SIZE; i++)
	{
		memset(tmp[i], 0, sizeof(tmp[i]));
	}

	for (i = 0; i < POP_SIZE; i++)
	{
		r = ((float)rand()) / (RAND_MAX + 1);
		if (r < accuP[0])
		{
			for (j = 0; j < CHROM_LEN; j++)
			{
				tmp[k][j] = chrom[0][j];
			}
			k++;
		}
		else
		{
			for (m = 1; m < POP_SIZE; m++)
			{
				if ((r >= accuP[m - 1]) && (r < accuP[m]))
				{
					for (j = 0; j < CHROM_LEN; j++)
					{
						tmp[k][j] = chrom[m][j];
					}
					k++;
				}
			}
		}
	}

	for (i = 0; i < POP_SIZE; i++)
	{
		for (j = 0; j < CHROM_LEN; j++)
		{
			chrom[i][j] = tmp[i][j];
		}
	}
}

void cross(int chrom[POP_SIZE][CHROM_LEN])
{
	int tmp_1[2][CHROM_LEN], tmp_2[2][CHROM_LEN];
	int tmp;
	int choice_1 = 0, choice_2 = 0, tmp_0 = 0, r_1 = 0, r_2 = 0, i = 0, j = 0, k = 0, m = 0, n = 0;
	float pCross = 0;

	for (i = 0; i < (POP_SIZE - 1); i++)
	{
		choice_2 = choice_1 + 1;

		pCross = ((float)rand()) / RAND_MAX;

		if (pCross < CROSS_PROBABILITY)
		{
			r_1 = rand() % CHROM_LEN;
			r_2 = rand() % CHROM_LEN;

			if (r_1 > r_2)
			{
				tmp_0 = r_1;
				r_1 = r_2;
				r_2 = tmp_0;
			}

			for (j = r_1; j < (r_2 + 1); j++)
			{
				tmp = chrom[choice_1][j];
				chrom[choice_1][j] = chrom[choice_2][j];
				chrom[choice_2][j] = tmp;
			}

			for (j = 0; j < 2; j++)
			{
				for (k = 0; k < CHROM_LEN; k++)
				{
					tmp_1[j][k] = -1;
					tmp_2[j][k] = -1;
				}
			}

			m = 0;
			n = 0;
			for (j = 0; j < CHROM_LEN; j++)
			{
				if ((j >= r_1) && (j <= r_2))
				{
					continue;
				}
				for (k = r_1; k < (r_2 + 1); k++)
				{
					if (chrom[choice_1][j] == chrom[choice_1][k])
					{
						tmp_1[0][m] = j;
						tmp_1[1][m] = chrom[choice_1][j];
						m++;
					}
				}
				for (k = r_1; k < (r_2 + 1); k++)
				{
					if (chrom[choice_2][j] == chrom[choice_2][k]) 
					{
						tmp_2[0][n] = j;
						tmp_2[1][n] = chrom[choice_2][j];
						n++;
					}
				}
			}

			for (j = 0; j < CHROM_LEN; j++)
			{
				if (tmp_1[0][j] != -1)
				{
					chrom[choice_1][tmp_1[0][j]] = tmp_2[1][j];
				}

				if (tmp_2[0][j] != -1)
				{
					chrom[choice_2][tmp_2[0][j]] = tmp_1[1][j];
				}

			}
		}		

		choice_1++;

		
	}
}

void vary(int chrom[POP_SIZE][CHROM_LEN])
{
	int i = 0, r_1 = 0, r_2 = 0, tmp = 0;
	float pVary = 0;

	for (i = 0; i < POP_SIZE; i++)
	{
		pVary = ((float)rand()) / RAND_MAX;

		if (pVary > VARY_PROBABILITY)
		{
			continue;
		}

		do
		{
			r_1 = rand() % CHROM_LEN;
			r_2 = rand() % CHROM_LEN;
		} while (r_1 == r_2);



		tmp = chrom[i][r_1];
		chrom[i][r_1] = chrom[i][r_2];
		chrom[i][r_2] = tmp;
	}
}

void evolution(int chrom[POP_SIZE][CHROM_LEN], float city[CHROM_LEN][2])
{
	int i = 0, j = 0, k = 0, r_1 = 0, r_2 = 0, tmp_0 = 0;
	int before[POP_SIZE][CHROM_LEN];
	int tmp[CHROM_LEN];
	float sglDist_before[CHROM_LEN - 1], dist_before = 0, fitness_before = 0;
	float sglDist_after[CHROM_LEN - 1], dist_after = 0, fitness_after = 0;

	for (i = 0; i < POP_SIZE; i++)
	{
		memset(tmp, 0, sizeof(tmp));

		memset(sglDist_before, 0, sizeof(sglDist_before));
		for (j = 0; j < CHROM_LEN - 1; j++)
		{
			sglDist_before[j] = sglDistance(city[chrom[i][j] - 1], city[chrom[i][j + 1] - 1]);
			dist_before += sglDist_before[j];
		}
		fitness_before = 1 / dist_before;

		for (j = 0; j < CHROM_LEN; j++)
		{
			before[i][j] = chrom[i][j];
		}

		do
		{
			r_1 = rand() % CHROM_LEN;
			r_2 = rand() % CHROM_LEN;
		} while (r_1 == r_2);

		if (r_1 > r_2)
		{
			tmp_0 = r_1;
			r_1 = r_2;
			r_2 = tmp_0;
		}
		
		for (j = r_2, k = 0; j >= r_1; j--)
		{
			tmp[k] = chrom[i][j];
			k++;
		}

		for (j = r_1, k = 0; j <= r_2; j++)
		{
			chrom[i][j] = tmp[k];
			k++;
		}
		
		memset(sglDist_after, 0, sizeof(sglDist_after));
		for (j = 0; j < CHROM_LEN - 1; j++)
		{
			sglDist_after[j] = sglDistance(city[chrom[i][j] - 1], city[chrom[i][j + 1] - 1]);
			dist_after += sglDist_after[j];
		}
		fitness_after = 1 / dist_after;

		if (fitness_before > fitness_after)
		{
			for (j = 0; j < CHROM_LEN; j++)
			{
				 chrom[i][j] = before[i][j];
			}
		}
		
	}
}

void main(void)
{
	float city[CHROM_LEN][2] = { {16.47, 96.10}, {16.47, 94.44}, {20.09, 92.54}, {22.39, 93.37},
								 {25.23, 97.24}, {22.00, 96.05}, {20.47, 97.02}, {17.20, 96.29}, 
								 {16.30, 97.38}, {14.05, 98.12}, {16.53, 97.38}, {21.52, 95.59}, 
								 {19.41, 97.13}, {20.09, 92.55} };
	float dist[POP_SIZE], fitness[POP_SIZE], chooseP[POP_SIZE], accuP[POP_SIZE], tmp = 0;
	int chrom[POP_SIZE][CHROM_LEN];
	int i = 0, j = 0, k = 0;
	Best best;

	best.num = 0;
	best.funcVal = 0;
	memset(best.bestChrom, 0, sizeof(best.bestChrom));
	
	memset(dist, 0, sizeof(dist));
	memset(fitness, 0, sizeof(fitness));
	memset(chooseP, 0, sizeof(chooseP));
	memset(accuP, 0, sizeof(accuP));
	for (i = 0; i < POP_SIZE; i++)
	{
		memset(chrom[i], 0, sizeof(chrom[i]));
	}
	

	srand(time(NULL));

	creat(chrom);

	wholeDistance(chrom, dist, city);

	fit(dist, fitness);

	for (i = 0; i < EVO_NUM; i++)
	{
		memset(dist, 0, sizeof(dist));

		wholeDistance(chrom, dist, city);

		fit(dist, fitness);

		fitnessP(fitness, chooseP, accuP);

		roulette(chrom, chooseP, accuP);

		cross(chrom);

		vary(chrom);

		evolution(chrom, city);

		memset(dist, 0, sizeof(dist));
		
		wholeDistance(chrom, dist, city);

		fit(dist, fitness);

		for (j = 0; j < POP_SIZE; j++)
		{
			if (tmp < fitness[j])
			{
				tmp = fitness[j];
				best.num = i;
				best.funcVal = dist[j];
				for (k = 0; k < CHROM_LEN; k++)
				{
					best.bestChrom[k] = chrom[j][k];
				}
			}
		}
	}

	printf("最短路径出现在第%d代\n", best.num);
	printf("最短路径为");
	for (i = 0; i < CHROM_LEN; i++)
	{
		if (i == (CHROM_LEN - 1))
		{
			printf("%d", best.bestChrom[i]);
		}
		else
		{
			printf("%d-", best.bestChrom[i]);
		}
	}
	printf("\n");
	printf("最短路径长度为%f\n", best.funcVal);
}
雨不落
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现用Hopfiled网络解决TSP问题
11-12
C++实现用Hopfiled网络解决TSP问题
遗传算法求解旅行推销员问题时算子的设计与选择.pdf
04-17
很好，遗传算法求解旅行推销员问题时算子的设计与选择
【遗传算法】求解TSP问题
不曾走远的博客
06-26 8517
旅行商问题，即TSP问题（Traveling Salesman Problem）又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。 遗传算法求解TSP问题 ​...
旅行商问题中国34省会的
05-13
中国34省会旅行商问题，最优路径求解，不同于一般的31省会 设计比较简单 大家可以讨论讨论
旅行商问题 C语言解法
06-23
C语言解决旅行商问题（货郎担问题），包括程序文件、源代码、程序测试图。
遗传算法解决TSP问题
最新发布
你的问题在于，读书太少而想得太多。
08-24 2257
利用一种改进的遗传算法，解决大型tsp问题！
基于Matlab的遗传算法解决TSP问题的报告-综合文档
05-24
《基于Matlab的遗传算法解决TSP问题的报告》 旅行商问题（TSP，Traveling Salesman Problem）是一个经典的组合优化问题，旨在寻找访问多个城市的最短路线，且每个城市仅访问一次，并最终返回起点。遗传算法...
遗传算法解决 TSP 问题（附matlab源程序）.docx-综合文档
05-25
《遗传算法解决TSP问题（附matlab源程序）》 旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，涉及到寻找最短路径以遍历一系列城市并返回起点。在这个问题中，假设存在一个推销员需要访问...
sga_TSP问题适应度_用遗传算法解决TSP问题_
10-02
**遗传算法解决TSP问题详解** 旅行商问题（Traveling Salesman Problem，简称TSP）是运筹学中一个经典的问题，它描述了一个旅行商如何规划最短的路线，以便访问给定城市的每个城市一次并返回原点。这个问题在实际...
遗传算法解决商旅问题_遗传算法解决TSP问题_
10-03
在解决旅行商问题（Traveling Salesman Problem，TSP）时，遗传算法表现出了强大的能力。 旅行商问题是一个经典的组合优化问题，它询问的是：给定一组城市和每对城市之间的距离，找到访问每个城市一次并返回起始...
遗传算法解决TSP问题（C++版）
03-29
遗传算法解决TSP问题（C++版），内容详细，可以很好地帮助初学者学习遗传算法
蚂蚁算法TSP的C++代码
08-11
此代码可正常运行，是蚂蚁算法的TSP问题的基本算法
A-Star算法求解旅行商问题
02-03
数据结构是用线性链表实现的，非常的简单易懂，
遗传算法解决TSP问题 旅行商问题 程序代码
05-29
遗传算法（Genetic Algorithm）即是通过模拟自然进化过程，搜索出最优解的方法，如可用来解决组合优化问题。 TSP问题即旅行商问题，假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。 程序用Microsoft Visual C++ 2010编写运行成功，更改各个城市坐标数据文件，即可输出最优路径。
TSP旅行商问题
12-20
用爬山法在VS2010环境下实现。初始邻接矩阵是随机生出。运行速度较快，这是一个NP完全问题，但是用爬上发可以极大地剪枝，节省计算机资源。
用遗传算法解决TSP问题
07-12
《用遗传算法解决TSP问题》 TSP（旅行商问题）是运筹学领域一个经典且具有挑战性的问题，其目标是寻找最短的路径，使得旅行商能够访问每个城市一次并返回起点。这个问题在实际中有着广泛的应用，如物流配送、电路...
多旅行商问题代码
09-19
多旅行商问题代码，是MATLAB编程得到的，对处理这类问题很有帮助
C++实现的旅行商问题
12-02
里面含有两种使用C++语言实现的A*算法解决旅行商问题的程序，都可执行且结果精确，并且附带人工智能大作业
ACO蚁群优化算法求解TSP旅行商问题（C++仅main.cpp文件共300行代码）
10-12
求解旅行商问题的蚁群优化算法，包含路径的构造、轮盘赌法进行城市的选择、信息素的更新等函数，仅300行代码一个main.cpp即可实现全部功能，程序运行后会输出城市坐标、距离矩阵、迭代后的最优路径及最短路径长度。
"基于Matlab的遗传算法解决TSP问题的综合报告
基于Matlab的遗传算法解决TSP问题的报告-综合文档 本报告基于Matlab编程工具，旨在通过遗传算法解决TSP（Traveling Salesman Problem）问题，即寻找最短路径以访问每个城市一次并返回出发城市的问题。报告中将详细...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值