精华内容
下载资源
问答
  • 基于混合粒子群算法TSP问题求解Matlab版实现
  • 遗传算法是研究TSP问题中最为广泛的一种算法,它具有全局搜索...本文基于遗传算法的交叉变异设计了混合粒子群算法,通过对TSP问题求解分析,证实该方法提高了标准粒子群的搜索能力,获得了较高的收敛速度和近似最优解。
  • 基于混合粒子群算法的TSP算法,粒子群算法解决tsp问题,matlab源码
  • 粒子群算法解决TSP问题的关键在于全局最优值的定义和本次种群最优值的定义,本算例通过对点的位置进行最优值的定义,每次迭代各个点以概率的形式朝着全局最优和本次最优靠近。程序可直接运行,有部分程序说明。
  • 粒子群算法解决TSP问题,路径规划 matlab代码
  • 粒子群算法解决TSP问题,里面有详细的代码介绍以及相应的数据附件。
  • 粒子群优化算法解决函数最值问题和TSP问题
  • 粒子群算法求解旅行商问题,实现离散与连续的转化,充分发挥粒子群算法优势!!!!!!!!!!!!!!!!!!
  • 基于混合粒子群算法求解TSP问题.pdf
  • 改进粒子群算法求解TSP问题,盛景军,王勇,在运用粒子群算法求解TSP问题时,针对粒子迭代、速度不能简单地采用连续量的运算法则进行计算的特点,通过构造插入因子,定义插入
  • 混合蚁群粒子群算法求解tsp问题
  • 改进的蚁群与粒子群算法求解TSP问题.pdf
  • 基于混合蛙跳粒子群算法TSP问题求解.pdf
  • 改进粒子群算法求解TSP问题
  • MATLAB源码集锦-混合粒子群算法求解TSP问题代码
  • 基于动态粒子群算法TSP求解 基于动态粒子群算法TSP求解 基于动态粒子群算法TSP求解 基于动态粒子群算法TSP求解
  • 基于k-means的改进粒子群算法求解TSP问题.pdf
  • 基于差分进化的离散粒子群算法求解TSP问题.pdf
  • MATLAB 粒子群算法解决经典31城市TSP问题
  • 混合粒子群算法求解TSP问题matlab代码.zip
  • 本程序基于粒子群算法,采用遗传算法进行优化,并用C#j进行·编码,对旅行商问题进行了求解。
  • 粒子群算法求解TSP问题-python实现

    千次阅读 2021-04-16 18:44:07
    粒子群算法求解TSP问题-python实现(附代码)

    粒子群算法求解TSP问题

    TSP问题简介

    旅行商人要拜访n个城市,并最终回到出发城市,要求每个城市只能拜访一次,优化目标是最小化路程之和。

    例子求解结果

    20个城市坐标:(88, 16),(42, 76),(5, 76),(69, 13),(73, 56),(100, 100),(22, 92),(48, 74),(73, 46),(39, 1),(51, 75),(92, 2),(101, 44),(55, 26),(71, 27),(42, 81),(51, 91),(89, 54),(33, 18),(40, 78)
    结果路径图如下:
    在这里插入图片描述

    粒子群算法简介

    粒子群算法基本原理

    粒子群算法模仿鸟群觅食行为,核心思想是通过向距离食物最近的鸟集聚,不断更新速度和位置以达到最优解,即表现不好的个体通过向表现好的个体学习使得自身往好的方向转变,这里存在一个前提:所有鸟知道距离食物的远近,距离食物最近包含两部分:当前最近和历史最近。标准粒子群算法适合求解函数极值问题,在TSP、背包问题上多用混合型粒子群算法。详细介绍可参考[粒子群算法研究]

    粒子群算法设计

    算法设计的关键在于如何向表现较好的个体学习,标准粒子群算法引入惯性因子w、自我认知因子c1、社会认知因子c2分别作为自身、当代最优解和历史最优解的权重,指导粒子速度和位置的更新,这在求解函数极值问题时比较容易实现,而在TSP问题上,速度位置的更新则难以直接采用加权的方式进行,一个常见的方法是采用基于遗传算法交叉算子的混合型粒子群算法进行求解,这里采用顺序交叉算子,对惯性因子w、自我认知因子c1、社会认知因子c2则以w/(w+c1+c2),c1/(w+c1+c2),c2/(w+c1+c2)的概率接受粒子本身、当前最优解、全局最优解交叉的父代之一(即按概率选择其中一个作为父代,不加权),具体算法实现如下。

    # -*- coding: utf-8 -*-
    """
    粒子群算法求解TSP问题
    随机在(0,101)二维平面生成20个点
    距离最小化
    """
    import math
    import random
    import pandas as pd
    import matplotlib.pyplot as plt
    from matplotlib.pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['SimHei']  # 添加这条可以让图形显示中文
    
    
    def calDistance(CityCoordinates):
        ''' 
        计算城市间距离
        输入:CityCoordinates-城市坐标;
        输出:城市间距离矩阵-dis_matrix
        '''
        dis_matrix = pd.DataFrame(data=None,columns=range(len(CityCoordinates)),index=range(len(CityCoordinates)))
        for i in range(len(CityCoordinates)):
            xi,yi = CityCoordinates[i][0],CityCoordinates[i][1]
            for j in range(len(CityCoordinates)):
                xj,yj = CityCoordinates[j][0],CityCoordinates[j][1]
                if (xi==xj) & (yi==yj):
                    dis_matrix.iloc[i,j] = round(math.pow(10,10))
                else:
                    dis_matrix.iloc[i,j] = round(math.sqrt((xi-xj)**2+(yi-yj)**2),2)
        return dis_matrix
    
    
    def calFitness(line,dis_matrix):
        '''
        计算路径距离,即评价函数
        输入:line-路径,dis_matrix-城市间距离矩阵;
        输出:路径距离-dis_sum
        '''
        dis_sum = 0
        dis = 0
        for i in range(len(line)-1):
            dis = dis_matrix.loc[line[i],line[i+1]]#计算距离
            dis_sum = dis_sum+dis
        dis = dis_matrix.loc[line[-1],line[0]]
        dis_sum = dis_sum+dis
        return round(dis_sum,1)
    
    
    def draw_path(line,CityCoordinates):
        '''
        #画路径图
        输入:line-路径,CityCoordinates-城市坐标;
        输出:路径图
        '''
        x,y= [],[]
        for i in line:
            Coordinate = CityCoordinates[i]
            x.append(Coordinate[0])
            y.append(Coordinate[1])
        x.append(x[0])
        y.append(y[0])
        plt.plot(x, y,'r-', color='#4169E1', alpha=0.8, linewidth=0.8)
        plt.xlabel('x')
        plt.ylabel('y')
        plt.show()
    
    
    def crossover(bird,pLine,gLine,w,c1,c2):
        '''
        采用顺序交叉方式;交叉的parent1为粒子本身,分别以w/(w+c1+c2),c1/(w+c1+c2),c2/(w+c1+c2)
        的概率接受粒子本身逆序、当前最优解、全局最优解作为parent2,只选择其中一个作为parent2;
        输入:bird-粒子,pLine-当前最优解,gLine-全局最优解,w-惯性因子,c1-自我认知因子,c2-社会认知因子;
        输出:交叉后的粒子-croBird;
        '''
        croBird = [None]*len(bird)#初始化
        parent1 = bird#选择parent1
        #选择parent2(轮盘赌操作)
        randNum = random.uniform(0, sum([w,c1,c2]))
        if randNum <= w:
            parent2 = [bird[i] for i in range(len(bird)-1,-1,-1)]#bird的逆序
        elif randNum <= w+c1:
            parent2 = pLine
        else:
            parent2 = gLine
        
        #parent1-> croBird
        start_pos = random.randint(0,len(parent1)-1)
        end_pos = random.randint(0,len(parent1)-1)
        if start_pos>end_pos:start_pos,end_pos = end_pos,start_pos
        croBird[start_pos:end_pos+1] = parent1[start_pos:end_pos+1].copy()
        
        # parent2 -> croBird
        list1 = list(range(0,start_pos))
        list2 = list(range(end_pos+1,len(parent2)))
        list_index = list1+list2#croBird从后往前填充
        j = -1
        for i in list_index:
            for j in range(j+1,len(parent2)+1):
                if parent2[j] not in croBird:
                    croBird[i] = parent2[j]
                    break
                        
        return croBird
    
    
    if __name__ == '__main__':
        #参数
        CityNum = 20#城市数量
        MinCoordinate = 0#二维坐标最小值
        MaxCoordinate = 101#二维坐标最大值
        iterMax = 200#迭代次数
        iterI = 1#当前迭代次数
        
        #PSO参数
        birdNum = 50#粒子数量
        w = 0.2#惯性因子
        c1 = 0.4#自我认知因子
        c2 = 0.4#社会认知因子
        pBest,pLine =0,[]#当前最优值、当前最优解,(自我认知部分)
        gBest,gLine = 0,[]#全局最优值、全局最优解,(社会认知部分)
        
        #随机生成城市数据,城市序号为0,1,2,3...
        # CityCoordinates = [(random.randint(MinCoordinate,MaxCoordinate),random.randint(MinCoordinate,MaxCoordinate)) for i in range(CityNum)]
        CityCoordinates = [(88, 16),(42, 76),(5, 76),(69, 13),(73, 56),(100, 100),(22, 92),(48, 74),(73, 46),(39, 1),(51, 75),(92, 2),(101, 44),(55, 26),(71, 27),(42, 81),(51, 91),(89, 54),(33, 18),(40, 78)]
        dis_matrix = calDistance(CityCoordinates)#计算城市间距离,生成矩阵
        
        birdPop = [random.sample(range(len(CityCoordinates)),len(CityCoordinates)) for i in range(birdNum)]#初始化种群,随机生成
        fits = [calFitness(birdPop[i],dis_matrix) for i in range(birdNum)]#计算种群适应度
        gBest = pBest = min(fits)#全局最优值、当前最优值
        gLine = pLine = birdPop[fits.index(min(fits))]#全局最优解、当前最优解
        
        while iterI <= iterMax:#迭代开始
            for i in range(len(birdPop)):
                birdPop[i] = crossover(birdPop[i],pLine,gLine,w,c1,c2)
                fits[i] = calFitness(birdPop[i],dis_matrix)
            
            pBest,pLine =  min(fits),birdPop[fits.index(min(fits))]
            if min(fits) <= gBest:
                gBest,gLine =  min(fits),birdPop[fits.index(min(fits))]
            
            print(iterI,gBest)#打印当前代数和最佳适应度值
            iterI += 1#迭代计数加一
        
        print(gLine)#路径顺序
        draw_path(gLine,CityCoordinates)#画路径图
    

    TSP系列目录
    智能优化算法类别启发式算法求解TSP问题系列博文
    进化算法遗传算法求解TSP问题
    仿人智能优化算法禁忌搜索算法求解TSP问题
    仿自然优化算法模拟退火算法求解TSP问题
    群智能优化算法蚁群算法求解TSP问题
    群智能优化算法粒子群算法求解TSP问题
    总结篇五种常见启发式算法求解TSP问题
    改进篇遗传-粒子群算法&遗传-禁忌搜索算法求解TSP问题

    记录学习过程,欢迎指正

    展开全文
  • 优化粒子群tsp算法。txt文本。可在c 平台运行
  • 一、粒子群算法简介 粒子群算法是在1995年由Eberhart博士和Kennedy博士一起提出的,它源于对鸟群捕食行为的研究。它的基本核心是利用群体中的个体对信息的共享从而使整个群体的运动在问题求解空间中产生从无序到...

    一、粒子群算法简介

    粒子群算法是在1995年由Eberhart博士和Kennedy博士一起提出的,它源于对鸟群捕食行为的研究。它的基本核心是利用群体中的个体对信息的共享从而使整个群体的运动在问题求解空间中产生从无序到有序的演化过程,从而获得问题的最优解。设想这么一个场景:一群鸟进行觅食,而远处有一片玉米地,所有的鸟都不知道玉米地到底在哪里,但是它们知道自己当前的位置距离玉米地有多远。那么找到玉米地的最佳策略,也是最简单有效的策略就是搜寻目前距离玉米地最近的鸟群的周围区域。

    在PSO中,每个优化问题的解都是搜索空间中的一只鸟,称之为"粒子",而问题的最优解就对应于鸟群中寻找的"玉米地"。所有的粒子都具有一个位置向量(粒子在解空间的位置)和速度向量(决定下次飞行的方向和速度),并可以根据目标函数来计算当前的所在位置的适应值(fitness value),可以将其理解为距离"玉米地"的距离。在每次的迭代中,种群中的例子除了根据自身的经验(历史位置)进行学习以外,还可以根据种群中最优粒子的"经验"来学习,从而确定下一次迭代时需要如何调整和改变飞行的方向和速度。就这样逐步迭代,最终整个种群的例子就会逐步趋于最优解。

    上面的解释可能还比较抽象,下面通过一个简单的例子来进行说明

    在一个湖中有两个人他们之间可以通信,并且可以探测到自己所在位置的最低点。初始位置如上图所示,由于右边比较深,因此左边的人会往右边移动一下小船。

    现在左边比较深,因此右边的人会往左边移动一下小船

    一直重复该过程,最后两个小船会相遇

    得到一个局部的最优解

    将每个个体表示为粒子。每个个体在某一时刻的位置表示为,x(t),方向表示为v(t)

    p(t)为在t时刻x个体的自己的最优解,g(t)为在t时刻所有个体的最优解,v(t)为个体在t时刻的方向,x(t)为个体在t时刻的位置

    下一个位置为上图所示由x,p,g共同决定了

    种群中的粒子通过不断地向自身和种群的历史信息进行学习,从而可以找到问题的最优解。

    但是,在后续的研究中表表明,上述原始的公式中存在一个问题:公式中V的更新太具有随机性,从而使整个PSO算法的全局优化能力很强,但是局部搜索能力较差。而实际上,我们需要在算法迭代初期PSO有着较强的全局优化能力,而在算法的后期,整个种群应该具有更强的局部搜索能力。所以根据上述的弊端,shi和Eberhart通过引入惯性权重修改了公式,从而提出了PSO的惯性权重模型:

    每一个向量的分量表示如下

    其中w称为是PSO的惯性权重,它的取值介于【0,1】区间,一般应用中均采用自适应的取值方法,即一开始令w=0.9,使得PSO全局优化能力较强,随着迭代的深入,参数w进行递减,从而使的PSO具有较强的局部优化能力,当迭代结束时,w=0.1。参数c1和c2称为学习因子,一般设置为1,4961;而r1和r2为介于[0,1]之间的随机概率值。

    整个粒子群优化算法的算法框架如下:

    step1种群初始化,可以进行随机初始化或者根据被优化的问题设计特定的初始化方法,然后计算个体的适应值,从而选择出个体的局部最优位置向量和种群的全局最优位置向量。

    step2 迭代设置:设置迭代次数,并令当前迭代次数为1

    step3 速度更新:更新每个个体的速度向量

    step4 位置更新:更新每个个体的位置向量

    step5 局部位置和全局位置向量更新:更新每个个体的局部最优解和种群的全局最优解

    step6 终止条件判断:判断迭代次数时都达到最大迭代次数,如果满足,输出全局最优解,否则继续进行迭代,跳转至step 3。

      对于粒子群优化算法的运用,主要是对速度和位置向量迭代算子的设计。迭代算子是否有效将决定整个PSO算法性能的优劣,所以如何设计PSO的迭代算子是PSO算法应用的研究重点和难点。

    二 、TSP模型

    三、代码

    ``` clc %清空命令行窗口 clear %从当前工作区中删除所有变量,并将它们从系统内存中释放 close all %删除其句柄未隐藏的所有图窗 tic % 保存当前时间 %% GA-PSO算法求解TSP %输入: %City 需求点经纬度 %Distance 距离矩阵 %NIND 种群个数 %MAXGEN 遗传到第MAXGEN代时程序停止

    %输出: %Gbest 最短路径 %GbestDistance 最短路径长度 %% 加载数据 load('../testdata/City.mat') %需求点经纬度,用于画实际路径的XY坐标 load('../testdata/Distance.mat') %距离矩阵

    %% 初始化问题参数 CityNum=size(City,1)-1; %需求点个数

    %% 初始化算法参数 NIND=60; %粒子数量 MAXGEN=100; %最大迭代次数

    %% 为预分配内存而初始化的0矩阵 Population = zeros(NIND,CityNum+2); %预分配内存,用于存储种群数据 PopDistance = zeros(NIND,1); %预分配矩阵内存 GbestDisByGen = zeros(MAXGEN,1); %预分配矩阵内存 用于绘制迭代图

    for i = 1:NIND %% 初始化各粒子 Population(i,2:end-1)=InitPop(CityNum); %随机生成TSP路径

    %% 计算路径长度
    PopDistance(i) = CalcDis(Population(i,:),Distance); % 计算路径长度

    end

    %% 存储Pbest数据 Pbest = Population; % 初始化Pbest为当前粒子集合 PbestDistance = PopDistance; % 初始化Pbest的目标函数值为当前粒子集合的目标函数值

    %% 存储Gbest数据 [mindis,index] = min(PbestDistance); %获得Pbest中最小值 Gbest = Pbest(index,:); % 初始Gbest粒子 GbestDistance = mindis; % 初始Gbest粒子的目标函数值

    %% 开始迭代 gen=1;

    while gen <= MAXGEN %% 每个粒子更新 for i=1:NIND %% 粒子与Pbest交叉 Population(i,2:end-1)=Crossover(Population(i,2:end-1),Pbest(i,2:end-1)); %交叉

    % 新路径长度变短则记录至Pbest
        PopDistance(i) = CalcDis(Population(i,:),Distance); %计算距离
        if PopDistance(i) < PbestDistance(i) %若新路径长度变短
            Pbest(i,:)=Population(i,:); %更新Pbest
            PbestDistance(i)=PopDistance(i); %更新Pbest距离
        end
    
    
    end
    
    %% 显示此代信息
    fprintf('Iteration = %d, Min Distance = %.2f km  \n',gen,GbestDistance)
    
    %% 存储此代最短距离
    GbestDisByGen(gen)=GbestDistance;
    
    %% 更新迭代次数
    gen=gen+1;

    end

    %% 计算结果数据输出到命令行 disp('-------------------------------------------------------------') toc %显示运行时间 TextOutput(Gbest,GbestDistance) %显示最优路径

    %% 迭代图 figure plot(GbestDisByGen,'LineWidth',2) %展示目标函数值历史变化 xlim([1 gen-1]) %设置 x 坐标轴范围 set(gca, 'LineWidth',1) xlabel('Iterations') ylabel('Min Distance(km)') title('HPSO Process')

    %% 绘制实际路线 DrawPath(Gbest,City) ```

    展开全文
  • 基于粒子群算法求解TSP问题JAVA 一TSP问题 TSP问题Travelling Salesman Problem即旅行商问题又译为旅行推销员问题货郎担问题是数学领域中著名问题之一假设有一个旅行商人要拜访n个城市他必须选择所要走的路 径路径的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 756
精华内容 302
关键字:

粒子群算法tsp问题