精华内容
下载资源
问答
  • 蚁群算法原理介绍;蚁群算法起源;蚁群行为描述;蚁群行为描述;基本蚁群算法的机制原理;基本蚁群算法的系统学特征;蚁群算法是一个系统;蚁群算法满足分布式计算;蚁群算法具有自组织的特征;蚁群算法具有正反馈的特征;自...
  • 根据蚁群算法信息素更新的特性,提出了求解旅行商问题的混合信息素递减的蚁群算法。把基本蚁群的三种不同的信息素更新方式混合在一起,同时提出了信息素递减更新的方法。新的更新方式避免了蚂蚁在寻找最优解的过程中,...
  • 每只蚂蚁在构造出一条从起点到终点的路径后,蚁群算法还要求根据路径的总长度来更新这条路径所包含的每条边上信息素的浓度(在旅行商问题中每座城市是图中的一个节点,城市两两间有一条边相连)。下面给出了蚁群...

    信息素的局部更新策略  

      每只蚂蚁在构造出一条从起点到终点的路径后,蚁群算法还要求根据路径的总长度来更新这条路径所包含的每条边上信息素的浓度(在旅行商问题中每座城市是图中的一个节点,城市两两间有一条边相连)。下面给出了蚁群算法更新信息素的公式:

    .

      上面的第一个公式体现了信息素的更新值的计算,其中,Ck代表第k只蚂蚁所构造的路径的总长度,Q是凭经验设定的一个参数,通常置为1。component(i,j)表示从城市i到城市j的一条边,m是蚂蚁的总数。上面的第二个公式是说i和j这条边的信息素值tau等于这条边上原有的信息素加上在上一次构造路径活动中所有经过这条边的蚂蚁贡献的信息素更新值(即第一个公式)。

    假设三只蚂蚁构造的路径长度如下所示:

    Tour 1: 450
    Tour 2: 380
    Tour 1: 460

    则它们的信息素的更新值相加结果为:componentNewPheromone = (Q / 450) + (Q / 380) + (Q / 460)

    最后把它加到各个蚂蚁的路径中每条边原来的信息素值之上:

    componentPheromone = componentPheromone + componentNewPheromone

    上述信息素更新过程的伪代码如下所示:

     

    for ant in colony do //蚁群中每条蚂蚁都逐个更新自己路径经过边上的的信息素
        tour = ant.getTour(); //蚂蚁计算路径的总长度
        pheromoneToAdd = getParam('Q') / tour.distance(); //蚂蚁计算信息素的更新值
        for cityIndex in tour do //回溯路径中的每个城市
            if lastCity(cityIndex) do // 如果当前城市是路径上的最后一个城市,取出它和第一个城市间的边
                edge = getEdge(cityIndex, 0)
            else do
                edge = getEdge(cityIndex, cityIndex+1) //否则,取当前城市和路径上下一个城市间的边
            end if
            currentPheromone = edge.getPheromone(); //获得边上之前的信息素
            edge.setPheromone(currentPheromone + pheromoneToAdd)//原有信息素加上更新值后得到新信息素
        end for // ant路径上所有的边的信息素更新完毕
    end for //蚁群中所有蚂蚁都处理完毕

     信息素的挥发

    在自然界中蚂蚁遗留下来的信息素经过一段时间后会挥发,我们在算法中也模拟上述过程,具体公式如下:

    rho是一个人为设定的参数,称为挥发率,一般为0-1间的数。

    相应的伪代码如下所示:

    for edge in edges
        updatedPheromone = (1 - getParam('rho')) * edge.getPheromone()
        edge.setPheromone(updatedPheromone)
    end for

    精英蚂蚁策略

     精英蚂蚁是对蚁群算法的一种改进,所谓精英蚂蚁是指当全部蚂蚁都构造完各自的路径之后,所有路径中最短的那条路径所对应的蚂蚁。精英蚂蚁策略的公式如下所示,它和上面的信息素局部更新公式的唯一区别在于精英蚂蚁在像其它蚂蚁一样更新完自己路径上的信息素后,还要再重复一遍信息素的更新过程,只不过这次要把更新值乘上一个参数e,e通常选在0和1之间。

     

    转载于:https://www.cnblogs.com/zhaogeatdlnu/p/5706033.html

    展开全文
  • 有限级信息素蚁群算法

    千次阅读 2019-01-14 11:39:41
    有限级信息素蚁群算法使用路径等级作为信息素更新的依据,相比于传统的蚁群算法,舍弃了目标函数作为信息素更新的依据这一方法。在TSP问题中,目标函数实际就是路径长度,在传统的蚁群算法信息素更新量为Q/f(x),...

    有限级信息素蚁群算法使用路径等级作为信息素更新的依据,相比于传统的蚁群算法,舍弃了目标函数作为信息素更新的依据这一方法。在TSP问题中,目标函数实际就是路径长度,在传统的蚁群算法中信息素更新量为Q/f(x),其中Q为某一常数,而f(x)就是目标函数值,即路径长度。而在有限级信息素蚁群算法中在这一点做出了改变。

    首先给出算法的基本步骤:

    步骤1:设定初始参数,初始化信息素

    步骤2:按照路径选择规则构造问题的解

    步骤3:按照信息素更新规则更新信息素

    步骤4:判断是否达到停止条件,若满足,则停止迭代,否则跳至步骤2

    有限级信息素蚁群算法主要变动就在步骤3,记h(i,j)为弧(i,j)的级别,g(x)是一个单调递增函数,用于将弧的级别映射为信息素。在有限级信息素蚁群算法中,弧级别越大则弧上的信息素也就越高。r_1表示路径惩罚等级,r_2表示路径奖励等级。假设路径最小等级为1,路径最大等级为M\widehat{w}为当前最优解,w_t为当前次迭代最优解。

    步骤3可以细分为以下几步:

    <1>.\forall (i,j):h(i,j)\leftarrow h(i,j)-r_1

    <2>.如果f(\widehat{w})> f(w_t),则\widehat{w}=w_t

    <3>.对于\widehat{w}\forall (i,j)\in \widehat{w},h(i,j)\leftarrow h(i,j)+r_2,即将当前最优解路径上的所有弧等级加r_2r_2> r_1

    <4>.\forall (i,j):h(i,j)\leftarrow max(1, h(i, j)),保证弧等级最小为1

    <5>.\forall (i,j):h(i,j)\leftarrow min(M, h(i, j)),保证弧等级最大为M

    <6>.\forall (i,j):\tau (i,j)=g(h(i,j))g(x)通常选取为\frac{\tau_{max} - 1}{M - 1}(x-1)+1或者\sqrt{\frac{\tau_{max}^2 - 1}{M - 1}(x-1)+1}\tau_{max}为每条弧上的最大信息素

    有限级信息素蚁群算法代码如下:

    
    # coding: utf-8
    
    # In[8]:
    
    
    import numpy as np
    from numpy import random as rd
    import os
    import matplotlib.pyplot as plt
    np.set_printoptions(linewidth=1000, suppress=True)
    
    
    # In[2]:
    
    # 数据下载地址:https://www.iwr.uni-heidelberg.de/groups/comopt/software/TSPLIB95/tsp/
    # 将数据存放在在代码存放目录的tspdata文件夹内
    with open("./tspdata/kroA100.tsp", "r", encoding="utf-8") as file:
        data = file.read()
    data = np.array([p.split(" ")[1:] for p in data.split("\n")[6:-2]]).astype(np.float32)
    data
    
    
    # In[3]:
    
    
    def calc_distance_matrix(city_position_matrix):
        """
            city_position_matrix:城市坐标矩阵,形状为N行2列,N为城市数
            返回城市间距离矩阵distance_matrix,假设城市i到城市j的距离等于城市j到城市i的距离,因此,distance_matrix为上三角矩阵
        """
        city_number = city_position_matrix.shape[0]
        distance_matrix = np.zeros(shape=[city_number, city_number], dtype=np.float32)
        for i in range(city_number):
            from_city_position = city_position_matrix[i]
            for j in range(i + 1, city_number):
                to_city_position = city_position_matrix[j]
                distance_matrix[i, j] = np.sqrt(np.sum(np.power(city_position_matrix[i] - city_position_matrix[j], 2)))
        return distance_matrix
    
    
    # In[4]:
    
    
    class FGP_ACO(object):
        
        def __init__(self, initial_pheromone, r_2, r_1, M, beta, max_pheromone, run_times, city_position_matrix, ant_count, initial_route_level):
            """
                initial_pheromone:每条路径上的信息素初始值
                r_2:路径奖励等级
                r_1:路径惩罚级别
                M:路径最大级别
                beta:启发信息重要程度
                max_pheromone:信息素最大值
                run_times:最大循环次数
                city_position_matrix:城市坐标矩阵,形状为N行2列,N为城市数
                ant_count:蚂蚁数量
                initial_route_leve:表示每条路径的初始级别
            """
            self.r_2 = r_2
            self.r_1 = r_1
            self.M = M
            self.beta = beta
            self.max_pheromone = max_pheromone
            self.run_times = run_times
            self.city_position_matrix = city_position_matrix
            self.ant_count = ant_count
            # 城市间距离矩阵
            self.distance_matrix = calc_distance_matrix(city_position_matrix)
            # 城市数量
            self.N = city_position_matrix.shape[0]
            # 启发信息矩阵
            self.heuristic_information_matrix = np.triu(1 / self.distance_matrix, k=1)
            self.pheromone_matrix = np.triu(initial_pheromone * np.ones_like(self.distance_matrix), k=1)
            # 路径级别矩阵
            self.route_level_matrix = np.triu(np.ones_like(self.distance_matrix) * initial_route_level, k=1)
            # 每一代的最优距离列表
            self.optimal_distance_of_every_iteration = []
            # 每一代的当前最优距离列表
            self.current_optimal_distance_of_every_iteration = []
        
        def calc_move_prob_matrix(self, passed_city, not_passed_city):
            """
                passed_city:每只蚂蚁已经经过的城市
                not_passed_city:每只蚂蚁未经过的城市
                返回未经过城市中每个城市被选择的概率矩阵move_prob_matrix,形状为[self.ant_count, np.array(not_passed_city).shape[1]]
            """
            move_prob_matrix = []
            for i in range(self.ant_count):
                # 由于都是上三角矩阵,因此,如果路径为i到j,且i > j的,需要对掉,变为j到i
                start = np.array([passed_city[i][-1]] * len(not_passed_city[i]))
                end = np.array(not_passed_city[i])
                bool_index = start > end
                start[bool_index] = end[bool_index]
                end[bool_index] = passed_city[i][-1]
                # 找出每条未经过路径上的信息素not_passed_route_pheromone以及启发信息not_passed_route_heuristic_information,
                # 其长度均为未经过城市的个数
                not_passed_route_pheromone = self.pheromone_matrix[start, end]
                not_passed_route_heuristic_information = self.heuristic_information_matrix[start, end]
                move_prob_matrix.append(not_passed_route_pheromone * not_passed_route_heuristic_information ** self.beta / np.sum(not_passed_route_pheromone * not_passed_route_heuristic_information ** self.beta))
            return np.array(move_prob_matrix)
        
        def calc_route_distance(self, route):
            """
                route:表示一次循环的路径,例如[0, 2, 1, 4, 3],表示0->2->1->4->3->0
                返回这条路径的长度
            """
            distance = 0
            for i in range(len(route) - 1):
                min_value, max_value = sorted([route[i], route[i + 1]])
                distance += self.distance_matrix[min_value, max_value]
            min_value, max_value = sorted([route[0], route[1]])
            distance += self.distance_matrix[min_value, max_value]
            return distance
        
        def g_function(self):
            """
                更新信息素矩阵
            """
            self.pheromone_matrix = np.sqrt((self.max_pheromone ** 2 - 1) / (self.M - 1) * (self.route_level_matrix - 1) + 1)
            
        def run(self):
            """
                迭代寻优,返回最优路径以及最优路径长度
            """
            # 随即初始化一个当前最优解, current_optimal_route表示当前最优路径,current_optimal_distance表示当前最优路径的长度
            current_optimal_route = rd.permutation(np.arange(self.N))
            current_optimal_distance = self.calc_route_distance(current_optimal_route)
            self.current_optimal_distance_of_every_iteration.append(current_optimal_distance)
            # 控制循环代数
            for times in range(1, 1 + self.run_times):
                if times % int(0.1 * self.run_times) == 0:
                    print("第%d次迭代:" % times)
                    print("最优路径:", current_optimal_route)
                    print("最优路径长度:", current_optimal_distance)
                # 每只蚂蚁已经经过的城市列表[lst1, lst2, lst3, ...],lst1表示第一只蚂蚁经过城市列表,lst1[-1]表示蚂蚁1当前所在城市,以此类推
                passed_city = [[rd.randint(0, self.N)] for i in range(self.ant_count)]
                # 每只蚂蚁未经过的城市列表[lst1, lst2, ...],lst1表示第一只蚂蚁未经过的城市列表,以此类推
                not_passed_city = [list(set(range(self.N)) - set(i)) for i in passed_city]
                # 判断每只蚂蚁是否均遍历完所有城市,如果遍历完则跳出循环
                while len(np.unique(not_passed_city)) != 0:
                    # 每次循环所有蚂蚁选择一个城市进行状态转移
                    # 计算未经过城市中每个城市被选择的概率矩阵move_prob_matrix,形状为[self.ant_count, np.array(not_passed_city).shape[1]]
                    move_prob_matrix = self.calc_move_prob_matrix(passed_city, not_passed_city)
                    # 求取被选择概率最大的城市索引
                    select_city_index = np.argmax(move_prob_matrix, axis=1)
                    # 进行状态转移,更新已经经过的城市列表以及未经过的城市列表
                    for i in range(self.ant_count):
                        passed_city[i].append(not_passed_city[i].pop(select_city_index[i]))
                # 更新路径等级,首先进行惩罚
                self.route_level_matrix -= self.r_1
                self.route_level_matrix[self.route_level_matrix < 1] = 1
                # 更新当前最优路径以及当前最优路径长度
                # 计算所有蚂蚁经过的路径的路径长度
                distance_lst = [self.calc_route_distance(r) for r in passed_city]
                # 最优蚂蚁索引
                optimal_index = np.argmin(distance_lst)
                current_iter_optimal_route = passed_city[optimal_index]
                current_iter_optimal_distance = distance_lst[optimal_index]
                self.optimal_distance_of_every_iteration.append(current_iter_optimal_distance)
                if current_iter_optimal_distance < current_optimal_distance:
                    current_optimal_distance = current_iter_optimal_distance
                    current_optimal_route = current_iter_optimal_route
                self.current_optimal_distance_of_every_iteration.append(current_optimal_distance)
                # 更新路径等级,进行奖励
                for i in range(len(current_optimal_route) - 1):
                    min_value, max_value = sorted([current_optimal_route[i], current_optimal_route[i + 1]])
                    self.route_level_matrix[min_value, max_value] += self.r_2
                min_value, max_value = sorted([current_optimal_route[0], current_optimal_route[-1]])
                self.route_level_matrix[min_value, max_value] += self.r_2
                self.route_level_matrix[self.route_level_matrix > self.M] = self.M
                # 更新信息素
                self.g_function()
    #             print("最优路径:", current_optimal_route)
    #             print("最优路径长度:", current_optimal_distance)
            return current_optimal_route, current_optimal_distance
    
    
    # In[6]:
    
    
    fgp_aco = FGP_ACO(100, 3, 1, 50, 5, 50, 2000, data, 25, 100)
    print("城市坐标:\n", fgp_aco.city_position_matrix)
    print("城市间距离矩阵:\n", fgp_aco.distance_matrix)
    print("信息素矩阵:\n", fgp_aco.pheromone_matrix)
    print("启发信息矩阵:\n", fgp_aco.heuristic_information_matrix)
    fgp_aco.run()
    
    
    # In[16]:
    
    
    ax = plt.subplot(1, 1, 1)
    ax.scatter(np.arange(len(fgp_aco.optimal_distance_of_every_iteration)), fgp_aco.optimal_distance_of_every_iteration, alpha=0.3)
    plt.show()
    
    

     

    展开全文
  • 蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年...国内外,对于离散域蚁群算法的改进研究成果很多,例如自适应蚁群算法、基于信息素扩散的蚁群算法等,这里仅介绍离散域...

    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上。

    人工蚁群与真实蚁群对比:

    蚁群算法基本流程:

    蚁群算法中主要参数的选择:

    蚁群算法中主要参数的理想选择如下:

    国内外,对于离散域蚁群算法的改进研究成果很多,例如自适应蚁群算法、基于信息素扩散的蚁群算法等,这里仅介绍离散域优化问题的自适应蚁群算法。

    自适应蚁群算法:对蚁群算法的状态转移概率、信息素挥发因子、信息量等因素采用自适应调节策略为一种基本改进思路的蚁群算法。 自适应蚁群算法中两个最经典的方法:蚁群系统(AntColony System, ACS)和最大-最小蚁群系统(MAX-MINAnt System, MMAS)。

    蚁群系统对基本蚁群算法改进:

    ①蚂蚁的状态转移规则不同;

    ②全局更新规则不同;

    ③新增了对各条路径信息量调整的局部更新规则

    原文地址:https://blog.csdn.net/zuochao_2013/article/details/71872950

    展开全文
  • 它修改了基本蚁群算法信息素的更新规则,使得每轮搜索后信息素的增量能更好地反映解的质量,以加快收敛;另外,它采用了一种启发式变异方法对路径进行优化,以产生搅动效应,避免早熟。以TSP问题为例进行的实验...
  • 展开全部说明:信息素权重,路径权重和信息素蒸发率对最后的结果影响很大,需要微调。目前发现2 / 5 / 0.5 能达到稍e68a...本蚁群算法为AS算法。用法:1.new一个对象ACOforTSP tsp = new ACPforTSP(tsp数据文...

    展开全部

    说明:信息素权重,路径权重和信息素蒸发率对最后的结果影响很大,需要微调。

    目前发现2 / 5 / 0.5 能达到稍e68a843231313335323631343130323136353331333236366362微让人满意的效果。本程序离完美的ACO还差很远,仅供参考。

    本蚁群算法为AS算法。

    用法:

    1.new一个对象

    ACOforTSP tsp = new ACPforTSP(tsp数据文件名,迭代次数,蚂蚁数量,信息素权重,路径权重,信息素蒸发率);

    2.用go()方法运行

    tsp.go();

    ACOforTSP.java

    ___________________________________________________________________

    import java.io.File;

    import static java.lang.Math.pow;

    import static java.lang.Math.sqrt;

    import static java.lang.Math.random;

    import java.util.HashMap;

    import java.io.FileReader;

    import java.io.BufferedReader;

    /**

    *

    * @author dvdface

    */

    public class ACOforTSP {

    //城市的距离表

    private double[][] distance;

    //距离的倒数表

    private double[][] heuristic;

    //启发信息表

    private double[][] pheromone;

    //权重

    private int alpha, beta;

    //迭代的次数

    private int iterationTimes;

    //蚂蚁的数量

    private int numbersOfAnt;

    //蒸发率

    private double rate;

    ACOforTSP (String file, int iterationTimes, int numbersOfAnt, int alpha, int beta, double rate) {

    //加载文件

    this.initializeData(file);

    //初始化参数

    this.iterationTimes = iterationTimes;

    //设置蚂蚁数量

    this.numbersOfAnt = numbersOfAnt;

    //设置权重

    this.alpha = alpha;

    this.beta = beta;

    //设置蒸发率

    this.rate = rate;

    }

    private void initializeData(String filename) {

    //定义内部类

    class City {

    int no;

    double x;

    double y;

    City(int no, double x, double y) {

    this.no = no;

    this.x = x;

    this.y = y;

    }

    private double getDistance(City city) {

    return sqrt(pow((x - city.x), 2) + pow((y - city.y), 2));

    }

    }

    try {

    //定义HashMap保存读取的坐标信息

    HashMap map = new HashMap();

    //读取文件

    BufferedReader reader = new BufferedReader(new FileReader(new File(filename)));

    for (String str = reader.readLine(); str != null; str = reader.readLine()) {

    //将读到的信息保存入HashMap

    if (str.matches("([0-9]+)(\\s*)([0-9]+)(.?)([0-9]*)(\\s*)([0-9]+)(.?)([0-9]*)")) {

    String[] data = str.split("(\\s+)");

    City city = new City(Integer.parseInt(data[0]),

    Double.parseDouble(data[1]),

    Double.parseDouble(data[2]));

    map.put(city.no, city);

    }

    }

    //分配距离矩阵存储空间

    distance = new double[map.size() + 1][map.size() + 1];

    //分配距离倒数矩阵存储空间

    heuristic = new double[map.size() + 1][map.size() + 1];

    //分配信息素矩阵存储空间

    pheromone = new double[map.size() + 1][map.size() + 1];

    for (int i = 1; i < map.size() + 1; i++) {

    for (int j = 1; j < map.size() + 1; j++) {

    //计算城市间的距离,并存入距离矩阵

    distance[i][j] = map.get(i).getDistance(map.get(j));

    //计算距离倒数,并存入距离倒数矩阵

    heuristic[i][j] = 1 / distance[i][j];

    //初始化信息素矩阵

    pheromone[i][j] = 1;

    }

    }

    } catch (Exception exception) {

    System.out.println("初始化数据失败!");

    }

    }

    class Ant {

    //已访问城市列表

    private boolean[] visited;

    //访问顺序表

    private int[] tour;

    //已访问城市的个数

    private int n;

    //总的距离

    private double total;

    Ant() {

    //给访问顺序表分配空间

    tour = new int[distance.length+1];

    //已存入城市数量为n,刚开始为0

    n = 0;

    //将起始城市1,放入访问结点顺序表第一项

    tour[++n] = 1;

    //给已访问城市结点分配空间

    visited = new boolean[distance.length];

    //第一个城市为出发城市,设置为已访问

    visited[tour[n]] = true;

    }

    private int chooseCity() {

    //用来random的随机数

    double m = 0;

    //获得当前所在的城市号放入j,如果和j相邻的城市没有被访问,那么加入m

    for (int i = 1, j = tour[n]; i < pheromone.length; i++) {

    if (!visited[i]) {

    m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);

    }

    }

    //保存随机到的数

    double p = m * random();

    //寻找被随机到的城市

    double k = 0;

    //保存找到的城市

    int q = 0;

    for (int i = 1, j = tour[n]; k < p; i++) {

    if (!visited[i]) {

    k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);

    q = i;

    }

    }

    return q;

    }

    private void constructSolution () {

    while (n != (distance.length-1) ) {

    //选取下一个城市

    int p = chooseCity();

    //计算总的距离

    total += distance[tour[n]][p];

    //将选取到的城市放入已访问列表

    tour[++n] = p;

    //将选取到的城市标记为已访问

    visited[p] = true;

    }

    //回到起点

    total += distance[tour[1]][tour[n]];

    //将起点加入访问顺序表的最后

    tour[++n] = tour[1];

    }

    private void releasePheromone() {

    //释放信息素的大小

    double t = 1/total;

    //释放信息素

    for (int i=1;i

    pheromone[tour[i]][tour[i+1]] += t;

    pheromone[tour[i+1]][tour[i]] += t;

    }

    }

    }

    public void go() {

    //保存最好的路径和路径长度

    double bestTotal = Double.MAX_VALUE;

    int[] bestTour = new int[distance.length+1];

    //新建蚂蚁数组,用来引用所创建的蚂蚁

    Ant[] ant = new Ant[numbersOfAnt];

    //进行iterationTimes次迭代

    while (iterationTimes != 0) {

    //初始化新的一批蚂蚁(这里用构造新的蚂蚁代替重置蚂蚁状态)

    for (int i=0; i

    ant[i] = new Ant();

    }

    //进行一次迭代(即让所有的蚂蚁构建一条路径)

    for (int i=0; i

    ant[i].constructSolution();

    //如果蚂蚁构建的路径长度比上次最好的还好,那么保存这个长度和它所走的路径

    if (ant[i].total

    bestTotal = ant[i].total;

    System.arraycopy(ant[i].tour, 1, bestTour, 1, bestTour.length-1);

    }

    }

    //蒸发信息素

    evaporatePheromone();

    //释放信息素

    for (int i=0; i

    ant[i].releasePheromone();

    }

    //报告本次迭代的信息

    System.out.format("本次为倒数第%d次迭代,当前最优路径长度为%10.2f\n",iterationTimes,bestTotal);

    //迭代总数减去1,进行下次迭代

    iterationTimes--;

    }

    //输出最好的路径长度

    System.out.format("得到的最优的路径长度为:%10.2f\n",bestTotal);

    //输出最好的路径

    System.out.println("最优路径如下:");

    for (int i=1; i

    System.out.print("→"+bestTour[i]);

    }

    }

    private void evaporatePheromone() {

    for (int i = 1; i < pheromone.length; i++)

    for (int j = 1; j < pheromone.length; j++) {

    pheromone[i][j] *= 1-rate;

    }

    }

    }

    本回答由提问者推荐

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • 对于基本蚁群算法(ACA)不适用求解连续空间问题,并且极易陷入局部最优的缺点,提出了一种基于自适应的蚁群算法。路径搜索策略采用基于目标函数值搜索筛选局部最优解的策略,确保能够迅速找到可行解。信息素更新...
  • 一、蚁群算法简介蚁群算法是对自然界蚂蚁的寻径方式进行模似而得出的一种仿生算法:蚂蚁在运动过程中,能够在它所经过的路径上留下信息素(pheromone)的物质进行信息传递,而且蚂蚁在运动过程中能够感知这种物质,并...
  • 蚁群算法基本思想蚁群算法的基本原理来源于自然界中蚂蚁觅食的最短路径问题。根据昆虫学家的观察,发现自然界的蚂蚁虽然视觉不发达,但它可以在没有任何提示的情况下找到从食物源到巢穴的最短路径,并且能在环境发生...
  • 蚁群算法

    万次阅读 多人点赞 2017-05-13 20:23:13
    蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上。 之后,又系统研究了蚁群算法的基本原理和数学模型. 蚁群算法的基本思想...
  • 代码实现运行结果及参数展示alpha=1beta=5rho=0.1alpha=1beta=1rho=0.1alpha=0.5beta=1rho=0.1概念蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由...蚁群算法的基本原理:1、蚂蚁在路径上释放信息素...
  • pdf的,信息素增量动态更新的改进蚁群算法,感觉不错
  • 针对蚁群算法加速收敛和早熟、停滞现象的矛盾,提出一种基于自适应路径选择和动态信息素更新的蚁群算法,以求在加速收敛和防止早熟、停滞现象之间取得很好的平衡。该算法根据优化过程中解的分布状况,自适应的调整...
  • 为了提高ACO算法的解题能力,提出一种新型信息素更新策略(PACS),然后将PACS算法与其他蚁群算法分别应用于旅行商问题(TSP)进行仿真实验。仿真结果表明,PACS算法具有优良的全局优化性能,可抑制算法过早收敛于次...
  • 1、蚂蚁在路径上释放信息素。2、碰到还没走过的路口,就随机挑选一...人工蚁群与真实蚁群对比:基于TSP问题的基本蚁群算法:TSP求解中,假设蚁群算法中的每只蚂蚁是具有以下特征的简单智能体:每次周游,每只蚂蚁在其...
  • 针对传统的蚁群算法在求解大规模旅行商问题时容易导致搜索时间过长或陷入停滞的问题, 提出了一种基于改进信息素蚁群算法。通过蚁群算法的改进, 使得每轮搜索之后的信息素都能更好地反映解的质量。实验仿真结果表明...
  • 针对连续域混合蚁群算法(HACO)易陷入局部最优和收敛速度较慢的问题,提出了基于信息素的自适应连续域混合蚁群算法(QAHACO)。首先提出了一种新的解更新方式,对档案中的解进行信息素挥发,扩大了搜索范围,提高了...
  • 蚁群算法解决TSP问题一、引言蚁群算法是一种受自然界生物行为启发而产生的“自然”算法,产生于对蚂蚁行为的研究。蚁群中的蚂蚁以“信息素”为媒介,间接异步的相互联系。蚂蚁在行动中,会在他们经过的地方留下...
  • 针对火灾背景下煤矿应急救援路径的优化问题,...利用各影响因素的量化值更新蚁群算法信息素,寻找并保存最优路径。仿真结果表明,采用基于蚁群算法的井下救援路径优化方法能够选出最优路径,同时最优解具有较好的收敛性。
  • 为了避免蚁群算法陷入停滞状态,研究了信息素的更新规则,并在信息素增量更新式中加入动态调节因子,使得次优路径上的信息素增量较大,其他路径则没有明显的变化,从而有利于蚂蚁在较短的时间内找到更好的解。...
  • 蚁群算法(ant colony optimization, ACO)1 原理介绍​蚁群算法(Ant Colony Algorithm)最初于1992年由意大利学者M.Dorigo等人提出,它是一种模拟自然界中真实蚁群觅食行为的仿生优化算法。研究发现:每只蚂蚁觅食时在...
  • 蚂蚁总能找到食物到窝的最优路径 ;我们模拟一下过程:(1) 正常情况下,食物到巢穴,小蚂蚁走直线(2) 这时候我们把路打断,放块大石头 ...蚁群算法的基本原理:蚂蚁在路径上释放信息素。碰到还没走过的路口,就随机...
  • 控制蚁群算法走向的关键是信息素信息素类似遗传算法的适应性函数,类似退火算法的评价函数,影响着其中一只蚂蚁的下一步的选择。蚂蚁:类似遗传算法的染色体,就是一条解,在tsp问题中蚂蚁的路径就是tsp的解。信息...
  • 过程采用蚂蚁算法,在有一定初始信息素分布的情况下,充分利用蚂蚁算法的并 行性、正反馈机制以及求解效率高等特性,提高求解效率。实验结果表明,该算 法是一种时间效率和求解效率都比较好的求解函数优化问题的有效...
  • %蚁群算法求解TSP问题 %输入城市间的横纵坐标C %输出蚁群算法得到的较优值minLen及其遍历路径minLuJing %测试环境:MATLAB2018b %% 参数定义 n = size(C,1); %城市个数 m = floor(1.5*n); %蚂蚁个数 arfa = 1; %...
  • 基于信息权重自适应蚁群算法求解TSP问题,王敏,,为了提高蚁群算法求解TSP问题的寻优效果和计算效率,在传统蚁群算法的基础上,将信息权重系数引入路径选择机制及信息素调节机制,

空空如也

空空如也

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

蚁群算法信息素