粒子群算法java_基于粒子群算法求解求解TSP问题（JAVA）

最新推荐文章于 2024-06-03 08:56:34 发布
最新推荐文章于 2024-06-03 08:56:34 发布
阅读量689 收藏 3
点赞数
文章标签： 粒子群算法java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42120541/article/details/114069182
版权

一、TSP问题

TSP问题(Travelling Salesman Problem)即旅行商问题，又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。

TSP问题是一个组合优化问题。该问题可以被证明具有NPC计算复杂性。TSP问题可以分为两类，一类是对称TSP问题(Symmetric TSP)，另一类是非对称问题(Asymmetric TSP)。所有的TSP问题都可以用一个图(Graph)来描述：

V={c1, c2, …, ci, …, cn}，i = 1,2, …, n，是所有城市的集合.ci表示第i个城市，n为城市的数目；

E={(r, s): r,s∈ V}是所有城市之间连接的集合；

C = {crs: r,s∈ V}是所有城市之间连接的成本度量(一般为城市之间的距离)；

如果crs = csr, 那么该TSP问题为对称的，否则为非对称的。

一个TSP问题可以表达为：

求解遍历图G = (V, E, C)，所有的节点一次并且回到起始节点，使得连接这些节点的路径成本最低。

二、粒子群算法

1、基本思想

粒子群算法简称PSO，它的基本思想是模拟鸟群的捕食行为。设想这样一个场景：一群鸟在随机搜索食物。在这个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢。最简单有效的就是搜寻目前离食物最近的鸟的周围区域。

PSO从这种模型中得到启示并用于解决优化问题。PSO中，每个优化问题的解都是搜索空间中的一只鸟。我们称之为“粒子”。所有的粒子都有一个由被优化的函数决定的适应值(fitness value)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最优粒子在解空间中搜索。

PSO 初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次迭代中，粒子通过跟踪两个"极值"来更新自己。第一个就是粒子本身所找到的最优解，这个解叫做个体极值pBest。另一个极值是整个种群目前找到的最优解，这个极值是全局极值gBest。另外也可以不用整个种群而只是用其中一部分作为粒子的邻居，那么在所有邻居中的极值就是局部极值。

2、粒子公式

在找到这两个最优值时，粒子根据如下的公式来更新自己的速度和新的位置：

v[i] = w * v[i] + c1 * rand() * (pbest[i] - present[i]) + c2 * rand() * (gbest - present[i])

present[i] = present[i] + v[i]

其中v[i]代表第i个粒子的速度，w代表惯性权值,c1和c2表示学习参数，rand()表示在0-1之间的随机数,pbest[i]代表第i个粒子搜索到的最优值,gbest代表整个集群搜索到的最优值,present[i]代表第i个粒子的当前位置。

3、个人见解

截止目前为止，粒子群优化算法大体上可以分为两大类，一类是最初的基本粒子群优化算法，一类是改进后的广义粒子群优化算法，其实PSO最初的设计主要用于处理连续优化问题，如求函数极值，在复杂的组合优化问题上它的应用相当有限，后来经过众多学者的改进才将其应用于求解TSP和单机调度之类的问题。广义粒子群算法模型和遗传算法相当类似，目前网上有关于粒子群算法求解TSP的很多论文或代码都是基于广义粒子群算法的，说简单点就是进化思想，用交叉变异代替了基本粒子群算法的迭代公式，当然他们也还是有粒子群优化的本质思想的，如与全局最优编码交叉，与局部最优编码交叉，变异等都是源自于基本粒子群算法的迭代公式。

三、粒子群优化算法求解TSP问题

关于基本粒子群优化算法的使用，可参考最近这篇文章，

自话粒子群算法 ，既然是求解TSP，使用基本的粒子群算法迭代公式肯定是不行的，在这里我也不想写一个与遗传算法差不多的粒子群算法，确实没必要，只要看了解遗传算法，分分钟就能写出来，在这里我想使用一种，比较特别的迭代方式，先来看看它的迭代公式：

11f842ba3bbf9452090cce2e26e98f46.png

我们使用TSP问题依然来自于tsplib上的att48，这是一个对称TSP问题，城市规模为48，其最优值为10628.其距离计算方法下图所示：

1366110497_2052.png

好，下面是具体代码：

package noah;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Random;

public class PSO {

private int bestNum;

private float w;

private int MAX_GEN;// 迭代次数

private int scale;// 种群规模

private int cityNum; // 城市数量，编码长度

private int t;// 当前代数

private int[][] distance; // 距离矩阵

private int[][] oPopulation;// 粒子群

private ArrayList> listV;// 每科粒子的初始交换序列

private int[][] Pd;// 一颗粒子历代中出现最好的解，

private int[] vPd;// 解的评价值

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

private int vPgd;// 最好的解的评价值

private int bestT;// 最佳出现代数

private int[] fitness;// 种群适应度，表示种群中各个个体的适应度

private Random random;

public PSO() {

}

/**

* constructor of GA

*

* @param n

* 城市数量

* @param g

* 运行代数

* @param w

* 权重

**/

public PSO(int n, int g, int s, float w) {

this.cityNum = n;

this.MAX_GEN = g;

this.scale = s;

this.w = w;

}

// 给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默

@SuppressWarnings("resource")

/**

* 初始化PSO算法类

* @param filename 数据文件名，该文件存储所有城市节点坐标数据

* @throws IOException

*/

private void init(String filename) throws IOException {

// 读取数据

int[] x;

int[] y;

String strbuff;

BufferedReader data = new BufferedReader(new InputStreamReader(

new FileInputStream(filename)));

distance = new int[cityNum][cityNum];

x = new int[cityNum];

y = new int[cityNum];

for (int i = 0; i < cityNum; i++) {

// 读取一行数据，数据格式1 6734 1453

strbuff = data.readLine();

// 字符分割

String[] strcol = strbuff.split(" ");

x[i] = Integer.valueOf(strcol[1]);// x坐标

y[i] = Integer.valueOf(strcol[2]);// y坐标

}

// 计算距离矩阵

// ，针对具体问题，距离计算方法也不一样，此处用的是att48作为案例，它有48个城市，距离计算方法为伪欧氏距离，最优值为10628

for (int i = 0; i < cityNum - 1; i++) {

distance[i][i] = 0; // 对角线为0

for (int j = i + 1; j < cityNum; j++) {

double rij = Math

.sqrt(((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])

* (y[i] - y[j])) / 10.0);

// 四舍五入，取整

int tij = (int) Math.round(rij);

if (tij < rij) {

distance[i][j] = tij + 1;

distance[j][i] = distance[i][j];

} else {

distance[i][j] = tij;

distance[j][i] = distance[i][j];

}

}

}

distance[cityNum - 1][cityNum - 1] = 0;

oPopulation = new int[scale][cityNum];

fitness = new int[scale];

Pd = new int[scale][cityNum];

vPd = new int[scale];

/*

* for(int i=0;i

*/

Pgd = new int[cityNum];

vPgd = Integer.MAX_VALUE;

// nPopulation = new int[scale][cityNum];

bestT = 0;

t = 0;

random = new Random(System.currentTimeMillis());

/*

* for(int i=0;i

* System.out.print(distance[i][j]+","); } System.out.println(); }

*/

}

// 初始化种群，多种随机生成办法

void initGroup() {

int i, j, k;

for (k = 0; k < scale; k++)// 种群数

{

oPopulation[k][0] = random.nextInt(65535) % cityNum;

for (i = 1; i < cityNum;)// 粒子个数

{

oPopulation[k][i] = random.nextInt(65535) % cityNum;

for (j = 0; j < i; j++) {

if (oPopulation[k][i] == oPopulation[k][j]) {

break;

}

}

if (j == i) {

i++;

}

}

}

/*

* for(i=0;i

* System.out.print(oldPopulation[i][j]+","); } System.out.println(); }

*/

}

void initListV() {

int ra;

int raA;

int raB;

listV = new ArrayList>();

for (int i = 0; i < scale; i++) {

ArrayList list = new ArrayList();

ra = random.nextInt(65535) % cityNum;

for (int j = 0; j < ra; j++) {

raA = random.nextInt(65535) % cityNum;

raB = random.nextInt(65535) % cityNum;

while (raA == raB) {

raB = random.nextInt(65535) % cityNum;

}

// raA与raB不一样

SO s = new SO(raA, raB);

list.add(s);

}

listV.add(list);

}

}

public int evaluate(int[] chr) {

// 0123

int len = 0;

// 编码，起始城市,城市1,城市2...城市n

for (int i = 1; i < cityNum; i++) {

len += distance[chr[i - 1]][chr[i]];

}

// 城市n,起始城市

len += distance[chr[cityNum - 1]][chr[0]];

return len;

}

// 求一个基本交换序列作用于编码arr后的编码

public void add(int[] arr, ArrayList list) {

int temp = -1;

SO s;

for (int i = 0; i < list.size(); i++) {

s = list.get(i);

temp = arr[s.getX()];

arr[s.getX()] = arr[s.getY()];

arr[s.getY()] = temp;

}

}

// 求两个编码的基本交换序列，如A-B=SS

public ArrayList minus(int[] a, int[] b) {

int[] temp = b.clone();

/*

* int[] temp=new int[L]; for(int i=0;i

*/

int index;

// 交换子

SO s;

// 交换序列

ArrayList list = new ArrayList();

for (int i = 0; i < cityNum; i++) {

if (a[i] != temp[i]) {

// 在temp中找出与a[i]相同数值的下标index

index = findNum(temp, a[i]);

// 在temp中交换下标i与下标index的值

changeIndex(temp, i, index);

// 记住交换子

s = new SO(i, index);

// 保存交换子

list.add(s);

}

}

return list;

}

// 在arr数组中查找num，返回num的下标

public int findNum(int[] arr, int num) {

int index = -1;

for (int i = 0; i < cityNum; i++) {

if (arr[i] == num) {

index = i;

break;

}

}

return index;

}

// 将数组arr下标index1与下标index2的值交换

public void changeIndex(int[] arr, int index1, int index2) {

int temp = arr[index1];

arr[index1] = arr[index2];

arr[index2] = temp;

}

// 二维数组拷贝

public void copyarray(int[][] from, int[][] to) {

for (int i = 0; i < scale; i++) {

for (int j = 0; j < cityNum; j++) {

to[i][j] = from[i][j];

}

}

}

// 一维数组拷贝

public void copyarrayNum(int[] from, int[] to) {

for (int i = 0; i < cityNum; i++) {

to[i] = from[i];

}

}

public void evolution() {

int i, j, k;

int len = 0;

float ra = 0f;

ArrayList Vi;

// 迭代一次

for (t = 0; t < MAX_GEN; t++) {

// 对于每颗粒子

for (i = 0; i < scale; i++) {

if(i==bestNum) continue;

ArrayList Vii = new ArrayList();

//System.out.println("------------------------------");

// 更新速度

// Vii=wVi+ra(Pid-Xid)+rb(Pgd-Xid)

Vi = listV.get(i);

// wVi+表示获取Vi中size*w取整个交换序列

len = (int) (Vi.size() * w);

//越界判断

//if(len>cityNum) len=cityNum;

//System.out.println("w:"+w+" len:"+len+" Vi.size():"+Vi.size());

for (j = 0; j < len; j++) {

Vii.add(Vi.get(j));

}

// Pid-Xid

ArrayList a = minus(Pd[i], oPopulation[i]);

ra = random.nextFloat();

// ra(Pid-Xid)+

len = (int) (a.size() * ra);

//越界判断

//if(len>cityNum) len=cityNum;

//System.out.println("ra:"+ra+" len:"+len+" a.size():"+a.size());

for (j = 0; j < len; j++) {

Vii.add(a.get(j));

}

// Pid-Xid

ArrayList b = minus(Pgd, oPopulation[i]);

ra = random.nextFloat();

// ra(Pid-Xid)+

len = (int) (b.size() * ra);

//越界判断

//if(len>cityNum) len=cityNum;

//System.out.println("ra:"+ra+" len:"+len+" b.size():"+b.size());

for (j = 0; j < len; j++) {

SO tt= b.get(j);

Vii.add(tt);

}

//System.out.println("------------------------------Vii.size():"+Vii.size());

// 保存新Vii

listV.add(i, Vii);

// 更新位置

// Xid’=Xid+Vid

add(oPopulation[i], Vii);

}

// 计算新粒子群适应度，Fitness[max],选出最好的解

for (k = 0; k < scale; k++) {

fitness[k] = evaluate(oPopulation[k]);

if (vPd[k] > fitness[k]) {

vPd[k] = fitness[k];

copyarrayNum(oPopulation[k], Pd[k]);

bestNum=k;

}

if (vPgd > vPd[k]) {

System.out.println("最佳长度"+vPgd+" 代数："+bestT);

bestT = t;

vPgd = vPd[k];

copyarrayNum(Pd[k], Pgd);

}

}

}

}

public void solve() {

int i;

int k;

initGroup();

initListV();

// 每颗粒子记住自己最好的解

copyarray(oPopulation, Pd);

// 计算初始化种群适应度，Fitness[max],选出最好的解

for (k = 0; k < scale; k++) {

fitness[k] = evaluate(oPopulation[k]);

vPd[k] = fitness[k];

if (vPgd > vPd[k]) {

vPgd = vPd[k];

copyarrayNum(Pd[k], Pgd);

bestNum=k;

}

}

// 打印

System.out.println("初始粒子群...");

for (k = 0; k < scale; k++) {

for (i = 0; i < cityNum; i++) {

System.out.print(oPopulation[k][i] + ",");

}

System.out.println();

System.out.println("----" + fitness[k]);

/*

ArrayList li = listV.get(k);

int l = li.size();

for (i = 0; i < l; i++) {

li.get(i).print();

}

System.out.println("----");

*/

}

// 进化

evolution();

// 打印

System.out.println("最后粒子群...");

for (k = 0; k < scale; k++) {

for (i = 0; i < cityNum; i++) {

System.out.print(oPopulation[k][i] + ",");

}

System.out.println();

System.out.println("----" + fitness[k]);

/*

ArrayList li = listV.get(k);

int l = li.size();

for (i = 0; i < l; i++) {

li.get(i).print();

}

System.out.println("----");

*/

}

System.out.println("最佳长度出现代数：");

System.out.println(bestT);

System.out.println("最佳长度");

System.out.println(vPgd);

System.out.println("最佳路径：");

for (i = 0; i < cityNum; i++) {

System.out.print(Pgd[i] + ",");

}

}

/**

* @param args

* @throws IOException

*/

public static void main(String[] args) throws IOException {

System.out.println("Start....");

PSO pso = new PSO(48, 5000, 30, 0.5f);

pso.init("c://data.txt");

pso.solve();

}

}

运行结果截图：

af4a541c3e52b52dc75af4e15ab252d6.png

四、总结

对于这个实验结果，其实我个人是不能接受的，但是目前我只能把问题归结于那篇论文提出的迭代公式上，不过那论文年代久远，它上面就试了14个点，这里是48个，差距肯定是有的，或许这里再进行一些调整，没准效果会好些，但是目前我本人时间有限，还来不及深入实验，只能让感兴趣的人来进行深入剥解！

sleepsoft
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
粒子群算法解决TSP问题
11-30 1546
1. 粒子群算法简介 粒子群算法(particle swarm optimization，PSO)由Kennedy和Eberhart在1995年提出，属于进化算法的一种，是通过对模拟鸟群扑食行为设计的。 基本思想： 从随机解出发，通过迭代寻找最优解，通过适应度来评价解的品质。 场景设定 : 一群鸟在随机搜索食物。在这个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位...
TSP+PSO+python
再来一下！
03-31 454
旅行商人要拜访n个城市，并最终回到出发城市，要求每个城市只能拜访一次，优化目标是最小化路程之和。粒子群算法模仿鸟群觅食行为，核心思想是通过向距离食物最近的鸟集聚，不断更新速度和位置以达到最优解，即表现不好的个体通过向表现好的个体学习使得自身往好的方向转变，这里存在一个前提：所有鸟知道距离食物的远近，距离食物最近包含两部分：当前最近和历史最近。标准粒子群算法适合求解函数极值问题，在TSP、背包问题上多用混合型粒子群算法。详细介绍可参考[粒子群算法研究]
粒子群算法Java实现
最新发布
weixin_42496466的博客
06-03 1097
粒子群算法（Particle Swarm Optimization，PSO）是一种受到自然界群体行为启发的优化算法，由James Kennedy和Russell Eberhart于1995年提出。该算法模拟了鸟类或其他动物群体（如鱼群）的社会和集体行为，来寻找复杂问题的最优解。
基于TSP(旅行商)问题的混合粒子群算法 附直接运行代码
好想上浙工大啊
03-02 3662
基于TSP问题的混合粒子群算法
基于粒子群算法的无约束优化问题求解
博客简介
07-01 972
粒子群算法（Particle Swarm Optimization，PSO）是由美国心理学家James Kennedy和电气工程师Russell Eberhart于1995年提出的一种算法，算是比较老也是非常经典的算法之一。采用Java编程粒子群算法求解了无约束优化问题中常用的几个测试函数。
粒子群算法求解TSp问题
05-03
在本项目中，粒子群算法被应用到解决旅行商问题（Traveling Salesman Problem, TSP），这是一个经典的组合优化问题，目标是寻找最短的可能路线，使得旅行者能够访问每个城市一次并返回起点。 旅行商问题的离散性...
粒子群求解旅行商问题TSP（JAVA实现）
07-02
使用Java实现粒子群求解旅行商问题（tsp），使用面向对象的思想，代码结构清晰易懂。详细的注释，保证能够看明白。用到单例设计模式。 参考我的博客链接 https://blog.csdn.net/u012324136/article/details/80883364
PSO.zip_PSO_TSP pso_TSP问题PSO求解JAVA代码_diseaseaj3
09-24
【标题】"PSO.zip" 是一个包含使用粒子群优化（PSO）算法解决旅行商问题（TSP）的JAVA源代码的压缩包。"PSO_TSP" 指的是将PSO算法应用于TSP问题，而"pso_TSP问题PSO求解JAVA代码"则表明该代码是用JAVA编程语言实现的...
TSP.zip_tsp遗传算法java_遗传算法 _遗传算法；城市距离优化
09-15
在实际应用中，遗传算法与其他优化技术（如模拟退火、粒子群优化等）相结合，可以进一步提升求解效果。同时，对于TSP问题的近似解算法，如Christofides算法和2-opt、3-opt改进策略，也是研究的热点，它们能在较短...
求解TSP遗传算法java代码
11-03
《使用遗传算法解决旅行商问题（TSP）的Java实现》 旅行商问题（Traveling ...总的来说，TSP问题的遗传算法Java实现是一个结合了概率、统计和优化理论的精彩实例，有助于我们理解和掌握遗传算法的基本思想和操作流程。
粒子群算法 java
05-20
粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java粒子群算法 java
粒子群算法java代码
11-26
粒子群优化代码java粒子群算法简称PSO，它的基本思想是模拟鸟群的捕食行为。设想这样一个场景：一群鸟在随机搜索食物。在这个区域里只有一块食物。所有的鸟都不知道食物在那里。但是他们知道当前的位置离食物还有多远。那么找到食物的最优策略是什么呢。最简单有效的就是搜寻目前离食物最近的鸟的周围区域。 PSO从这种模型中得到启示并用于解决优化问题。PSO中，每个优化问题的解都是搜索空间中的一只鸟。我们称之为“粒子”。所有的粒子都有一个由被优化的函数决定的适应值(fitness value)，每个粒子还有一个速度决定他们飞翔的方向和距离。然后粒子们就追随当前的最优粒子在解空间中搜索。 PSO 初始化为一群随机粒子(随机解)。然后通过迭代找到最优解。在每一次迭代中，粒子通过跟踪两个"极值"来更新自己。第一个就是粒子本身所找到的最优解，这个解叫做个体极值pBest。另一个极值是整个种群目前找到的最优解，这个极值是全局极值gBest。另外也可以不用整个种群而只是用其中一部分作为粒子的邻居，那么在所有邻居中的极值就是局部极值。
java粒子群算法_Java多线程技术实现的粒子群优化算法
weixin_28882565的博客
02-21 485
概述1 粒子群优化算法，是(Particle Swarm Optimization PSO)一种进化计算技术是基于个体间的协作与竞争来完成复杂,空间中最优解的搜索。中的粒子在解空间追随最优的粒PSO 子进行搜索，而不是像遗传算法那样通过交叉、变异等复杂操作，因此具有参数少、简单易实现等优点。非常适合PSO 于求解连续函数的优化问题，主要应用于神经网络训练，多目标优化等应用领域。的提出至今不到年，但...
粒子群算法的寻优算法——非线性函数极值寻优 实验体会
qq_43241436的博客
12-03 1751
通过老师对算法代码的简单介绍，我对于粒子寻优算法结构有了一个大致的了解 首先根据老师说的原则，c1从小变到大，c2从大变到小，权重w先从大的开始，惯性大的冲得快，后期再往小改。 初始值： 首先更改了c2的值： 在第二次迭代时发现了变异种子的作用： 解决过早收敛，跳出局部最优，得以再次迭代得出最优解，不过显然，未能完全达到预期理想结果。 在c2保持住1.59445的情况下，c1降为1.1944...
基于改进粒子群算法的微电网多目标优化调度
ZrLnHf1的博客
09-14 180
总之，基于改进粒子群算法的微电网多目标优化调度是一种非常有效的电力系统优化技术，通过对传统粒子群算法的改进，增强了粒子寻优的能力和收敛速度和精度，避免了算法陷入局部最优解的问题。该方法将微电网的运行成本和环境保护成本之和作为优化目标，以微电网中的所有电源和负荷的调度计划作为决策变量，构建了一个包含多个约束条件的优化模型。通过仿真实验，对该方法的可行性和有效性进行了验证。实验结果表明，该方法能够以较小的计算代价和较短的时间延迟，得到微电网多目标优化调度的最优解或近似最优解，具有很高的实用价值和应用前景。
java 粒子系统_Java粒子系统（烟火篇）
weixin_35213963的博客
02-13 399
用好粒子系统，自己也可以自制一场烟火！ 比如说这样的，这就是一个慢慢优化的过程。下面就上代码大家仔细体会一下吧import javax.swing.JFrame;import javax.swing.JPanel;public class FireWorksMain extends JPanel {public static void main(String[] args) {FireWorksM...
数学建模之粒子群算法详解
热门推荐
韩韩的博客
08-31 1万+
粒子群（鸟群算法）算法是典型的寻优算法。分为全局最优和局部最优。 基本思想：主要模拟自然界生物捕食的策略，群体迭代，粒子在解空间追随最优的例子进行搜索。是智能算法的一种。 算法特点： 简单易行。 收敛速度快。 设置参数少。 一般的限制条件是当达到限制步数或者达到相应的准确度的时，粒子就会停止移动。 设想一个场景：一群鸟在随机搜索食物。 已知（假设）： 1.在这块区域里只有一块食物。 2.所有的鸟...
粒子群算法（PSO）——Java实现
厉兵秣码
07-06 6303
粒子群算法是计算算法的一种，1995年由Eberhart 博士和kennedy 博士提出，源于对鸟群捕食的行为研究 。 该算法利用群体中的个体对信息的共享使整个群体的运动在问题求解空间中产生从无序到有序的演化过程，从而获得最优解。 试想一下，如果一群鸟在一片区域中寻找食物，所有的鸟都不知道食物在什么地方，但是每一只鸟都知道自己距离食物有多远，也知道这一群鸟中离食物最近的鸟在什么位置，这样每一只...
粒子群算法求解tsp问题
06-08
粒子群算法可以用来求解TSP问题。TSP问题是旅行商问题，即如何在给定的一组城市中找到一条最短的路径，使得每个城市恰好被访问一次，最后回到起点。粒子群算法是一种优化算法，通过模拟鸟群捕食行为来寻找最优解。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值