蚁群算法求包含34个国内城市的TSP，和最优解相差没那么大

已于 2023-10-29 22:16:49 修改
阅读量840 收藏 4
点赞数
分类专栏： # 运筹优化 文章标签： 蚁群算法 TSP问题 整数规划 智能优化算法
于 2023-10-29 22:03:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taozibaby/article/details/134108665
版权

文章目录

引言

上一篇介绍的差分进化算法，很适合求解连续变量的优化问题；但针对组合优化问题，就不是很适用了。

至于哪一种智能优化算法更适合求解组合优化问题，我查阅了很多资料。不幸的是，虽然有很多公开测试数据集，但并没有令人信服的证据能表明某个智能优化算法是其中最好的。

即使如此，还是想找一个适合的智能优化算法来求解组合优化问题。一番权衡后，本文选择了蚁群算法，其中的原因包括以下两点：

  1. 蚁群算法的最初设计就是解决其中一大类组合优化问题，后续的应用几乎也都是组合优化问题，所以从天性上来说，两者是契合的；
  2. 蚁群算法最早是在1991年被提出的，而且持续有人在使用和研究，是一种经典的智能优化算法，所以具有学习的价值。

正文见下。

蚁群觅食

蚁群算法的设计借鉴了蚁群觅食的过程，因此为了能深刻地理解算法，有必要先了解清楚蚁群是如何觅食的。

研究发现，蚂蚁的食物搜索行为具有协作性。当蚂蚁在蚁穴和食物之间行走时，会释放一种被称为信息素的物质，这些物质形成一条指示轨迹。其他蚂蚁可以感知到环境中这种物质的存在和强度，在移动过程中，倾向于选择信息素强度高的轨迹。

以下图为例。 t = 0 t=0 t=0时刻，有20只蚂蚁位于A（蚁穴）处，要去往E（食物）处，另有20只蚂蚁位于E处，要返回A处。

t = 1 t=1 t=1时刻，20只蚂蚁从A到达B处的岔路口，因为此时没有信息素，所以10只蚂蚁走BCD路线，10只走BD路线，并分别在各自的路线上留下信息素；同理，从E出发的20只蚂蚁在D处也分成2个等数量的小组分别走DB和DCB路线，并留下信息素；另外，还有15只蚂蚁从A处开始出发。

到了 t = 2 t=2 t=2时，从E出发沿着DB路线的10只蚂蚁到达B处，而沿DCB行走的蚂蚁仅达到C处，因此此时BD路线上的信息素强度高于BCD路线；当另外15只从A出发的蚂蚁到达B处后，多数的蚂蚁（10只）会选择走BD路线，少量的蚂蚁（5只）选择走BCD路线。


这一正反馈机制会导致，BD路线上的信息素量相比BCD路线会越来越多，最终所有蚂蚁都找到BD这条最短路径。

算法原理

蚁群算法源于蚁群觅食，所以保留了一些类似的特征，比如个体间相互合作，通过信息素进行间接通信和正反馈机制等；但又高于蚁群觅食，主要体现在具有记忆能力，信息素的释放时机可以根据具体问题设定，允许局部优化、回退甚至预测能力等。

以下借助TSP问题（旅行商问题）实例，来详细描述蚁群算法的原理和和实现步骤。TSP问题指的是：旅行家要旅行n个城市，要求各个城市经历且仅经历一次，然后回到出发城市，并要求所走的路程最短。

（1）在蚁群算法的每一代循环中，每只蚂蚁都会独立地完成自己的TSP。蚂蚁完成TSP的过程中，不会选择已经访问过的城市，并且依赖状态转移概率选择下一个城市 j j j。状态转移概率的定义为：设第 k k k只蚂蚁当前所在的城市为 i i i，则从该城市移动到 j j j城市的状态转移概率为

其中， τ ( i , j ) \tau (i,j) τ(i,j)是城市对 ( i , j ) (i,j) (i,j)上的信息素，下一段再细说； η ( i , j ) \eta (i,j) η(i,j)是城市对 ( i , j ) (i,j) (i,j)上的启发信息，在TSP问题中， η ( i , j ) \eta (i,j) η(i,j)一般选取为城市间距离的倒数。 N k i N_k^i Nki​是所有未经过的城市组成的集合， α , β \alpha,\beta α,β分别表示信息素和启发信息相对权重参数，它们控制 τ ( i , j ) \tau (i,j) τ(i,j)和 η ( i , j ) \eta (i,j) η(i,j)在决策中所占的比重。显然，信息素越多，距离越短，被选择的概率就越大。

（2）初始的信息素设置成所有城市对均相同即可。当所有蚂蚁完成了自己的TSP后，会根据自己选择的路径和路径总长度留下不同强度的信息素 τ ( i , j ) \tau (i,j) τ(i,j)。用 Δ τ i , j k \Delta\tau_{i,j}^k Δτi,jk​表示第 k k k只蚂蚁在城市对 ( i , j ) (i,j) (i,j)上释放的量。在Ant Cycle System中，其值为

其中，$Q$是常数，$L_k$表示第$k$只蚂蚁在本次循环中所走路径的长度。显然，解的质量越好，在所经过的路径上留下的信息素$\Delta\tau_{i,j}^k$就越大。

所以，针对城市对 ( i , j ) (i,j) (i,j)上，信息素的总改变量为
Δ τ i , j = ∑ k = 1 m Δ τ i , j k \Delta\tau_{i,j}=\sum_{k=1}^m \Delta\tau_{i,j}^k Δτi,j​=k=1∑m​Δτi,jk​
其中， m m m为蚂蚁数。

此外，算法中还引入了信息素会发机制。设信息素的保持系数为 ρ \rho ρ，则在完成一次完整循环后，信息素的值变为
τ i , j = ρ τ i , j + Δ τ i , j \tau_{i,j} = \rho\tau_{i,j} + \Delta\tau_{i,j} τi,j​=ρτi,j​+Δτi,j​

（3）判断是否达到退出条件，如果满足，则退出，否则便进入下一代循环。

代码实现

ACO求解TSP

求解随机生成的TSP实例，感觉有些太普通。所以决定加点难度，试着沿国内34个主要城市跑一圈，并把优化后的最短TSP可视化出来。

以下是Python代码。感恩网上大量的开源代码，让我完成可以少花很多时间来完成这些代码，同时保证TSP可视化后的颜值。

import math
import time

import numpy as np
import pandas as pd

from pyecharts import options as opts
from pyecharts.charts import Geo
from pyecharts.datasets import register_url
from pyecharts.globals import ChartType, SymbolType


def tsp_by_aco(D):
    # 城市数量
    city_cnt = D.shape[0]
    # 蚂蚁数量
    ant_cnt = 100
    # 迭代次数
    max_iter = 200
    # 信息素权重系数
    alpha = 1
    # 启发信息权重系数
    beta = 2
    # 信息素挥发速度
    rho = 0.1
    # 城市间球面距离
    distance = np.zeros((city_cnt, city_cnt))
    for i in range(city_cnt):
        for j in range(city_cnt):
            if i == j:
                # 相同城市不允许访问
                distance[i][j] = 1000000
            else:
                # 单位：km
                distance[i][j] = 6378.14 * math.acos(
                    math.cos(D[i][1]) * math.cos(D[j][1]) * math.cos(D[i][0] - D[j][0]) +
                    math.sin(D[i][1]) * math.sin(D[j][1]))
    # 启发信息，距离倒数
    eta = 1 / distance
    # 信息素矩阵
    tau = np.ones((city_cnt, city_cnt))
    # 每一代最优解
    generation_best_y = []
    generation_best_x = []
    # 种群
    population = np.zeros((ant_cnt, city_cnt)).astype(int)

    # 循环迭代
    for i in range(max_iter):
        # 城市转移概率
        prob_matrix = (tau ** alpha) * (eta ** beta)

        # TSP距离
        y = np.zeros((ant_cnt, 1))

        # 依次遍历每只蚂蚁
        for j in range(ant_cnt):
            # 设置TSP初始点为0
            population[j, 0] = 0

            # 选择后续城市
            for k in range(city_cnt - 1):
                # 已访问城市
                visit = set(population[j, :k + 1])
                # 未访问城市
                un_visit = list(set(range(city_cnt)) - visit)
                # 未访问城市转移概率归一化
                prob = prob_matrix[population[j, k], un_visit]
                prob = prob / prob.sum()
                # 轮盘赌策略选择下个城市
                next_point = np.random.choice(un_visit, size=1, p=prob)[0]
                # 添加被选择的城市
                population[j, k + 1] = next_point
                # 更新TSP距离
                y[j] += distance[population[j, k], population[j, k + 1]]
            # 更新TSP距离：最后一个城市->第0个城市
            y[j] += distance[population[j, -1], 0]

        # 保存当前代最优解
        best_index = y.argmin()
        generation_best_x.append(population[best_index, :])
        generation_best_y.append(y[best_index, :])

        # 计算信息素改变量，ACS模型，Q=1
        delta_tau = np.zeros((city_cnt, city_cnt))
        for j in range(ant_cnt):
            for k in range(city_cnt - 1):
                delta_tau[population[j, k], population[j, k + 1]] += 1 / y[j]
            delta_tau[population[j, city_cnt - 1], population[j, 0]] += 1 / y[j]

        # 信息素更新
        tau = (1 - rho) * tau + delta_tau

        print('iter: {}, best_f: {}'.format(i, generation_best_y[-1]))

    # 最优解位置
    best_generation_index = np.array(generation_best_y).argmin()

    return generation_best_x[best_generation_index], generation_best_y[best_generation_index]


def plot_tsp(cities):
    try:
        register_url("https://echarts-maps.github.io/echarts-countries-js/")
    except Exception:
        import ssl

        ssl._create_default_https_context = ssl._create_unverified_context
        register_url("https://echarts-maps.github.io/echarts-countries-js/")
    '''
    https://echarts-maps.github.io/echarts-countries-js/preview.html
    这个网站上显示的各个国家中文名称， 可以写在下面的maptype里面
    '''
    title1 = "中国主要城市TSP_by_ACO"

    c = (
        Geo().add_schema(
            maptype='china',  # 可以输入国家名字，比如"瑞士"
            itemstyle_opts=opts.ItemStyleOpts(color='#323c48', border_color='#111'), )  # 设置地图颜色和边框色
    )

    for i in range(len(cities)):
        c.add(
            "城市",  # 第一个add数据的标题
            [(cities['城市'].iloc[i], i)],
            type_=ChartType.EFFECT_SCATTER,  # 使用点的样式，并设置点的颜色，点的大小都是一样的！
            symbol_size=6,  # 设置点的大小
            color='red', )  # 点的颜色

    for i in range(len(cities) - 1):
        c.add(
            "tsp路线",
            [(cities['城市'].iloc[i], cities['城市'].iloc[i + 1])],  # 城市顺序
            type_=ChartType.LINES,
            effect_opts=opts.EffectOpts(
                symbol=SymbolType.ARROW, symbol_size=6, color='yellow'),  # 线上的小箭头的颜色
            linestyle_opts=opts.LineStyleOpts(curve=0.2))  # 设置两点间线缆的弯曲度
        c.set_series_opts(label_opts=opts.LabelOpts(is_show=False))
        c.set_global_opts(title_opts=opts.TitleOpts(title=title1),
                          toolbox_opts=opts.ToolboxOpts())

    c.render('tsp_solution_by_aco.html')


if __name__ == '__main__':
    # 城市及其经纬度
    original_cities = [['西宁', 101.74, 36.56],
                       ['兰州', 103.73, 36.03],
                       ['银川', 106.27, 38.47],
                       ['西安', 108.95, 34.27],
                       ['郑州', 113.65, 34.76],
                       ['济南', 117, 36.65],
                       ['石家庄', 114.48, 38.03],
                       ['太原', 112.53, 37.87],
                       ['呼和浩特', 111.65, 40.82],
                       ['北京', 116.407526, 39.90403],
                       ['天津', 117.200983, 39.084158],
                       ['沈阳', 123.38, 41.8],
                       ['长春', 125.35, 43.88],
                       ['哈尔滨', 126.63, 45.75],
                       ['上海', 121.473701, 31.230416],
                       ['杭州', 120.19, 30.26],
                       ['南京', 118.78, 32.04],
                       ['合肥', 117.27, 31.86],
                       ['武汉', 114.31, 30.52],
                       ['长沙', 113, 28.21],
                       ['南昌', 115.89, 28.68],
                       ['福州', 119.3, 26.08],
                       ['台北', 121.3, 25.03],
                       ['香港', 114.173355, 22.320048],
                       ['澳门', 113.54909, 22.198951],
                       ['广州', 113.23, 23.16],
                       ['海口', 110.35, 20.02],
                       ['南宁', 108.33, 22.84],
                       ['贵阳', 106.71, 26.57],
                       ['重庆', 106.551556, 29.563009],
                       ['成都', 104.06, 30.67],
                       ['昆明', 102.73, 25.04],
                       ['拉萨', 91.11, 29.97],
                       ['乌鲁木齐', 87.68, 43.77]]
    original_cities = pd.DataFrame(original_cities, columns=['城市', '经度', '纬度'])
    # 使用ACO算法求解TSP
    time0 = time.time()
    best_x, best_y = tsp_by_aco(original_cities[['经度', '纬度']].values * math.pi / 180)
    print('使用ACO求解TSP，耗时: {} s'.format(time.time() - time0))
    # 按最优解顺序，生成访问城市次序
    original_cities['seq'] = best_x
    sort_cities = original_cities.sort_values(by='seq')
    sort_cities.loc[len(sort_cities)] = sort_cities.loc[0]
    # 绘制TSP路径
    plot_tsp(sort_cities)

运行代码后，能够得到一个网页版的动图，可以表示运行的轨迹，这里截取了一帧如下。算法输出的最短路径是15944.43815449，从图里其实也能看出来，这个解应该不是全局最优解。需要说明的是，每次运行的结果大概率是不一样的，所以如果大家复跑了这段代码，最优解的值和图的形状不一样是正常的。

整数规划求解TSP

之前的文章里介绍过整数规划可以求解全局最优解，所以本节再用这个方法解一遍TSP，然后把全局最优解拿来和ACO算法的结果做一下对比。TSP问题的整数规划建模不是本文重点，这里就不多描述了，有兴趣的可以参考：优化│TSP中两种不同消除子环路的方法及callback实现（Python调用Gurobi求解）。这里直接给出使用ortools求解模型的代码。

import pandas as pd
import math
import numpy as np
import time
from ortools.linear_solver import pywraplp

from pyecharts import options as opts
from pyecharts.charts import Geo
from pyecharts.datasets import register_url
from pyecharts.globals import ChartType, SymbolType


def calc_by_ortools(data):
    # 生成ortools求解器，使用SCIP算法
    solver = pywraplp.Solver.CreateSolver('SCIP')

    # 优化变量
    x = {}
    u = {}
    for i in range(len(data)):
        u[i] = solver.NumVar(0, solver.infinity(), 'u[%i]' % i)
        for j in range(len(data)):
            x[i, j] = solver.IntVar(0, 1, 'x[%i,%i]' % (i, j))

    # 目标函数:
    obj_expr = [data[i][j] * x[i, j] for i in range(len(data)) for j in range(len(data))]
    solver.Minimize(solver.Sum(obj_expr))

    # 约束条件一: 出度为1
    for i in range(len(data)):
        constraint_expr = [x[i, j] for j in range(len(data))]
        solver.Add(solver.Sum(constraint_expr) == 1)
    # 约束条件二: 入度为1
    for j in range(len(data)):
        constraint_expr = [x[i, j] for i in range(len(data))]
        solver.Add(solver.Sum(constraint_expr) == 1)
    # 约束条件三: 消除子环
    for i in range(1, len(data)):
        for j in range(1, len(data)):
            if i != j:
                solver.Add(u[i] - u[j] + len(data) * x[i, j] <= len(data) - 1)

    # 模型求解
    status = solver.Solve()

    # 模型求解成功, 打印结果
    if status == pywraplp.Solver.OPTIMAL:

        # 最优目标函数值
        print('best_f =', solver.Objective().Value())

        # 最优次序
        cnt = 0
        print(0, end=' ')
        k = 0
        best_x = [0]
        while cnt < len(data):
            for j in range(len(data)):
                if x[k, j].solution_value() == 0:
                    continue
                print('->', j, end=' ')
                k = j
                cnt += 1
                best_x.append(j)
                break
        print('\n')
        return best_x

    else:
        print('not converge.')
        return []


def plot_optimal_routes(cities):
    try:
        register_url("https://echarts-maps.github.io/echarts-countries-js/")
    except Exception:
        import ssl

        ssl._create_default_https_context = ssl._create_unverified_context
        register_url("https://echarts-maps.github.io/echarts-countries-js/")
    '''
    https://echarts-maps.github.io/echarts-countries-js/preview.html
    这个网站上显示的各个国家中文名称， 可以写在下面的maptype里面
    '''
    title1 = "中国主要城市TSP_by_ortools"

    c = (
        Geo()
            .add_schema(
            maptype='china',  # 可以输入国家名字，比如"瑞士"
            itemstyle_opts=opts.ItemStyleOpts(color='#323c48', border_color='#111'), )  # 设置地图颜色和边框色
    )

    for i in range(len(cities)):
        c.add(
            "城市",  # 第一个add数据的标题
            [(cities['城市'].iloc[i], i)],
            type_=ChartType.EFFECT_SCATTER,  # 使用点的样式，并设置点的颜色，点的大小都是一样的！
            symbol_size=6,  # 设置点的大小
            color='red', )  # 点的颜色

    for i in range(len(cities) - 1):
        c.add(
            "tsp路线",
            [(cities['城市'].iloc[i], cities['城市'].iloc[i + 1])],  # 城市顺序
            type_=ChartType.LINES,
            effect_opts=opts.EffectOpts(
                symbol=SymbolType.ARROW, symbol_size=6, color='yellow'),  # 线上的小箭头的颜色
            linestyle_opts=opts.LineStyleOpts(curve=0.2))  # 设置两点间线缆的弯曲度
        c.set_series_opts(label_opts=opts.LabelOpts(is_show=False))
        c.set_global_opts(title_opts=opts.TitleOpts(title=title1),
                          toolbox_opts=opts.ToolboxOpts())

    c.render('tsp_solution_by_ortools.html')


if __name__ == '__main__':
    # 城市及其经纬度
    original_cities = [['西宁', 101.74, 36.56],
                       ['兰州', 103.73, 36.03],
                       ['银川', 106.27, 38.47],
                       ['西安', 108.95, 34.27],
                       ['郑州', 113.65, 34.76],
                       ['济南', 117, 36.65],
                       ['石家庄', 114.48, 38.03],
                       ['太原', 112.53, 37.87],
                       ['呼和浩特', 111.65, 40.82],
                       ['北京', 116.407526, 39.90403],
                       ['天津', 117.200983, 39.084158],
                       ['沈阳', 123.38, 41.8],
                       ['长春', 125.35, 43.88],
                       ['哈尔滨', 126.63, 45.75],
                       ['上海', 121.473701, 31.230416],
                       ['杭州', 120.19, 30.26],
                       ['南京', 118.78, 32.04],
                       ['合肥', 117.27, 31.86],
                       ['武汉', 114.31, 30.52],
                       ['长沙', 113, 28.21],
                       ['南昌', 115.89, 28.68],
                       ['福州', 119.3, 26.08],
                       ['台北', 121.3, 25.03],
                       ['香港', 114.173355, 22.320048],
                       ['澳门', 113.54909, 22.198951],
                       ['广州', 113.23, 23.16],
                       ['海口', 110.35, 20.02],
                       ['南宁', 108.33, 22.84],
                       ['贵阳', 106.71, 26.57],
                       ['重庆', 106.551556, 29.563009],
                       ['成都', 104.06, 30.67],
                       ['昆明', 102.73, 25.04],
                       ['拉萨', 91.11, 29.97],
                       ['乌鲁木齐', 87.68, 43.77]]
    original_cities = pd.DataFrame(original_cities, columns=['城市', '经度', '纬度'])
    D = original_cities[['经度', '纬度']].values * math.pi / 180

    # 城市间球面距离
    city_distance = np.zeros((len(original_cities), len(original_cities)))
    for i in range(len(original_cities)):
        for j in range(len(original_cities)):
            if i == j:
                city_distance[i][j] = 100000
            else:
                city_distance[i][j] = 6378.14 * math.acos(
                    math.cos(D[i][1]) * math.cos(D[j][1]) * math.cos(D[i][0] - D[j][0]) +
                    math.sin(D[i][1]) * math.sin(D[j][1]))

    # 使用整数规划求解TSP
    time0 = time.time()
    best_x = calc_by_ortools(city_distance)
    print('使用ortools求解TSP，耗时: {} s'.format(time.time() - time0))

    # 绘制TSP路径
    if len(best_x) > 0:
        best_routes = []
        for i in range(len(best_x)):
            best_routes.append(original_cities['城市'].iloc[best_x[i]])
        best_routes = pd.DataFrame(best_routes, columns=['城市'])
        plot_optimal_routes(best_routes)

运行程序后，得到最优解为15614.849985682848，可视化路径如下图所示，这个图里的路径看上去更符合我们对全局最优解的认知。相比之下，蚁群算法的结果距离最优解的GAP差不多是2%，看起来也没差那么多。

best_f = 15614.849985682848
0 -> 1 -> 2 -> 3 -> 4 -> 6 -> 7 -> 8 -> 13 -> 12 -> 11 -> 9 -> 10 -> 5 -> 17 -> 16 -> 14 -> 15 -> 22 -> 21 -> 20 -> 18 -> 19 -> 25 -> 23 -> 24 -> 26 -> 27 -> 31 -> 28 -> 29 -> 30 -> 32 -> 33 -> 0 
使用ortools求解TSP，耗时: 88.28608894348145 s

相关阅读

ACO实现代码1: https://github.com/guofei9987/scikit-opt/blob/master/sko/ACA.py

ACO实现代码2: https://blog.csdn.net/weixin_48241292/article/details/109312812

pyecharts绘图: https://blog.csdn.net/ycyrym/article/details/106736998#:~:text=pyecharts-%20geo%20%E5%9C%A8%E5%9C%B0%E5%9B%BE%E4%B8%8A%E7%94%BB%E7%82%B9%E5%92%8C%E4%B8%A4%E5%9C%B0%E9%97%B4%E7%9A%84%E8%BF%9E%E7%BA%BF,ChartType.EFFECT_SCATTER%20%26%20ChartType.LINES

整数规划求解TSP实例1：https://blog.csdn.net/baidu/article/details/124844167

整数规划求解TSP实例2：https://blog.csdn.net/qq_39559641/article/details/101209534

TSP问题的整数规划模型：https://zhuanlan.zhihu.com/p/261137981

蚁群智能优化方法及其应用：https://weread.qq.com/web/reader/a50328c0719b20d8a5094bek65132ca01b6512bd43d90e3

差分进化算法：https://zhuanlan.zhihu.com/p/661450130

整数规划：https://zhuanlan.zhihu.com/p/649791641

我在开水团做运筹
关注
专栏目录
中国34个三十四个省会城市的货郎担回路15531千米
duzuokanyunqi的专栏
12-20 1万+
中国34个三十四个省会城市的货郎担回路15531千米 在网上找到中国三十四个城市的经纬度，计算出各个城市之间的球面距离，做一个就近连通图，使用触摸空洞回溯法计算出了最短的几个哈密顿圈，最短的一个就是中国三十四个城市的货郎担回路了。需要说明的是三十四个城市之间的距离与原来三十一个城市之间的老距离不一样。
蚁群算法
RoadSon的博客
11-05 2103
一、基本思想 蚁群算法是受到蚂蚁觅食过程中表现的智能行为的启发，蚂蚁在觅食过程中会释放一种叫“信息素”的物质，同时蚂蚁会沿着“信息素”浓度高的位置走，最后大部分蚂蚁都能沿着最短觅食路径走。 二、算法流程 以TSP问题为例来介绍蚁群算法的基本流程，首先介绍蚁群算法最重要的两个步骤：选择路径和更新信息素 1. 选择路径 对每一个蚂蚁，以下面的概率分布来随机选择一个城市访问 pi,jk=γi,jσ∗ηi...
基于蚁群算法的中国34个主要城市TSP问题（详细注释）
牵一只蜗牛去散步
03-03 4229
%% 清屏 clear, clc; %% 导入数据 citys = [116.46 39.92 117.2 39.13 121.48 31.22 106.54 29.59 91.11 29.97 87.68 43.77 106.27 38.47 111.65 40.82 108.33 22.84 126.63 45.75
TSP问题——ACO（蚁群算法）解法（附源代码）
机器学习&数据挖掘
11-21 6181
TSP问题——ACO（蚁群算法）解法 1、蚁群算法简介   蚁群算法（Ant Colony Optimization, ACO），又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法。它由Marco Dorigo于1992年在他的博士论文“Ant system: optimization by a colony of cooperating agents”中提出，其灵感来源于蚂蚁在寻找食物过程中...
蚁群算法解决城市遍历最短路径问题TSP问题-ant.rar
08-13
蚁群算法解决城市遍历最短路径问题TSP问题-ant.rar 这个是完整的城市最短路径遍历问题，函数是从网上下载的，不过我自己做了testant.m程序，完全可以调试通过，对初学者有一定得帮助。    只需要运行testant.m程序即可，可以输出试验结果
旅行商问题(TSP) 中国34个城市 经纬度&平面坐标
ReaderWithNoEmotion
01-11 7594
经纬度通过墨卡托投影转为平面坐标，单位km； 赤道作为标准纬线 本初子午线作为中央经线 两者交点为坐标原点 向东向北为正，向西向南为负 除港澳台和海南外，30个城市的TSP问题解决见Github, 采用的是自组织映射技术（Self-organizing map, SOM）求解。克隆之后直接运行./src/main.py即可，好用记得star哟~ https://github.com/Y-Sh...
蚁群算法求解TSP问题python代码（另有基于两交换法的贪婪算法与蚁群算法的比较）
weixin_47770128的博客
10-22 814
蚁群算法求解TSP问题-基于python 本文将贪婪算法与蚁群算法求解含80个城市的TSP问题的结果进行对比 代码如下：参数或坐标点数据均可自己调整 import numpy as np from scipy import spatial import matplotlib.pyplot as plt 城市参数 num_city = 80 # 城市数量 rng1 = np.random.RandomState(0) co = rng1.rand(num_city, 2) # 城市坐标 绘制城市 plt.
【运筹优化】结合天际线启发式的蚁群算法求解二维矩形装箱问题 + Java代码实现
热门推荐
知不足而奋进，望远山而前行
11-08 2万+
让我们回顾一下蚁群算法求解TSP问题是如何处理的：在构建路径时, 蚂蚊通过当前信息素浓度, 按照一定概率选择下一个要到达的城市, 设 i\mathrm{i}i 和 j\mathrm{j}j 分别为起点和终点, τij(t)\tau_{i j}(t)τij​(t) 为时间 t\mathrm{t}t 时, 从站点 i\mathrm{i}i 到站点 j\mathrm{j}j 的信息素浓度, AkA^kAk 为第 k\mathrm{k}k 只蚂蚊的尚末访问的邻接节点的集合, pkijp^k{ }_{i j}pkij
【其他】结构技术优化算法--蚁群算法（ant colony optimization）
zsjzliziyang的博客
12-26 2916
1遗传基因算法 遗传算法（Genetic Algorithms，GA）由J.Holland教授（美国）1975年首先提出，是一种灵感源于达尔文自然进化理论的启发式搜索算法。该算法反映了自然选择的过程，即最适者被选定繁殖，并产生下一代。 运算过程为初始化→个体评价→选择运算→交叉运算→变异运算→终止条件判断，运算过程就如物竞天择、适者生存，只有被选择的个体才会把自己的基因传下去。下面就用一个有趣的例子，帮助大家理解。 我想让机器人小i画出我的梦中情人（最优解）。小i当然不知道我梦中情人长啥样。小i.
TSP问题城市数据及最优解
12-08
TSP(旅行商)问题的测试数据及最优解，用于测试算法的优劣及效率等。TSP问题研究必备。
蚁群算法与TSP问题
weixin_43998483的博客
11-05 1596
目录蚁群算法代码结果分析 蚁群算法 代码 结果分析 城市序列是随机生成的1000到8000的随机序列 语句如下： citys=round(1000+8000*rand(35,2)) save citys_new 蚂蚁数量m=50 信息素重要程度因子alpha = 1; 启发函数重要程度因子beta = 5; 信息素挥发因子rho = 0.1; 常系数Q = 1; 结果如下： 最短距离:3...
python023基于Python旅游景点推荐系统带vue前后端分离毕业源码案例设计.zip
11-05
python023基于Python旅游景点推荐系统带vue前后端分离毕业源码案例设计 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
基于Java的JFrame和JDBC数据库连接的小游戏合集.zip
11-05
本资源是专为Java初学者和数据结构学习者设计的小游戏合集，包含多个基于JFrame图形用户界面和JDBC数据库连接的简单游戏项目。这些游戏项目涵盖了Java基础语法、面向对象编程、GUI开发、事件处理机制以及JDBC数据库操作等关键技术点。每个游戏都经过测试，确保可直接运行，为学习者提供了完整的源码和资源文件，便于研究和实践。通过阅读和修改这些游戏的源代码，学习者可以加深对Java编程语言的理解和应用，同时掌握图形界面设计和数据库交互的基本技能。此外，这些小游戏还涉及数据结构与算法的应用，为初学者提供了一个练习数据结构和算法的平台。请注意，本资源仅供学习交流使用，不得用于商业用途。
Assimulo-3.2.1-cp36-cp36m-win32.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
IMG_20241105_235746.jpg
最新发布
11-05
IMG_20241105_235746.jpg
JSP基于SSM网上医院预约挂号系统毕业源码案例设计.zip
11-05
JSP基于SSM网上医院预约挂号系统毕业源码案例设计 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md或论文文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。 5、资源来自互联网采集，如有侵权，私聊博主删除。 6、可私信博主看论文后选择购买源代码。
蚁群算法TSP：寻找n个城市间最优路线和距离
然而，蚁群算法也存在一些局限性，如容易早熟收敛于局部最优解，对于参数选择较为敏感，可能需要多次调整以获得最佳性能。因此，在实际应用中需要根据问题的具体情况对算法进行适当的修改和优化。 蚁群tsp.m文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值