精华内容
下载资源
问答
  • Tabu search

    2014-05-10 16:58:16
    Tabu search for solving variety problem. 用於求解JSP.FSP及各類演算法之區域解
  • Tabu Search

    2013-05-27 16:02:47
    禁忌搜尋法、Tabu Search,演算法PPT
  • tabu汇总

    2007-05-05 11:04:45
    我从不同地方下载了tabu资源,上传共享.
  • 一个tabu search算法框架-a tabu search algorithm framework, 简言之就是lib库,有文档说明和原代码!
  • 利用Tabu 搜索的强大局部搜索性能, 提出一种新的非线性遗传算法. 该方法将Tabu 搜索技术内嵌于遗传 算子中, 构造了基于Tabu 搜索的非线性杂交及变异算子, 它能有效地提高算子的局部搜索能力, 通过实例仿真证明...
  • 禁忌搜索Tabu Search.rar

    2020-06-18 10:52:58
    禁忌搜索(Tabu Search,TS,又称禁忌搜寻法)是一种现代启发式算法,由美国科罗拉多大学教授Fred Glover在1986年左右提出的,是一个用来跳脱局部最优解的搜索方法。其先创立一个初始化的方案;基于此,算法“移动”...
  • 有关更多信息,请参阅以下链接: http://yarpiz.com/243/ypea116-tabu-search
  • Multistart Iterated Tabu Search for Bandwidth Coloring Problem
  • Iterated tabu search for the circular open dimension problem
  • tabu_search

    2016-02-25 17:44:42
    Tabu Search is a Global Optimization algorithm and a Metaheuristic or Meta-strategy for controlling an embedded heuristic technique. Tabu Search is a parent for a large family of derivative approaches


    Tabu Search is a Global Optimization algorithm and a Metaheuristic or Meta-strategy for controlling an embedded heuristic technique. Tabu Search is a parent for a large family of derivative approaches that introduce memory structures in Metaheuristics, such as Reactive Tabu Search and Parallel Tabu Search.


    CITY_SIZE = 52;
    
    CITIES =  [565,575,25,185,345,750,945,685,845,655,880,660,25,230,525,1000,580,1175,650,1130,1605,620,1220,580 , 1465,200 , 1530,5 , 845,680 , 725,370 , 145,665 ,415,635 , 510,875 , 560,365 , 300,465 , 520,585 , 480,415 ,835,625 , 975,580 , 1215,245 , 1320,315 , 1250,400 , 660,180 ,410,250 , 420,555 , 575,665 , 1150,1160 , 700,580 , 685,595 ,685,610 , 770,610 , 795,645 , 720,635 , 760,650 , 475,960 ,95,260 , 875,920 , 700,500 , 555,815 , 830,485 , 1170,65 ,830,610,605,625,595,360,1340,725,1740,245 ];
    CITIES = matrix(CITIES,2,CITY_SIZE);
    CITY_SIZE = 52;
    CITIES = CITIES';
    CITIES = CITIES(1:CITY_SIZE,:)
    function y = euc_2d(c1, c2)
        x1 = c1(1) - c2(1);
        x1 = x1 * x1;
        x2 = c1(2) - c2(2);
        x2 = x2 * x2;
        y = round(sqrt( x1 + x2));
    endfunction
    
    
    function distance = cost(perm, cities)
        distance = 0;
        c1 = [1:CITY_SIZE];
        c2 = [2:CITY_SIZE,1];
        for i = 1:CITY_SIZE
            distance = distance + euc_2d(cities(perm(c1(i)),:), cities(perm(c2(i)),:));
        end
    endfunction
    
    function perm = random_permutation()
        perm = [1:CITY_SIZE];
        for i = 1:CITY_SIZE
            r = rand(1) * (CITY_SIZE - i) + i;
            r = round(r);
            if r == 0 then
                r = 1;
            end
            tp = perm(i);
            perm(i) = perm(r);
            perm(r) = tp; 
        end 
    endfunction
    
    
    function [perm, edges] = stochastic_two_opt(parent)
        perm =  parent;
        c = round(rand(1,2) * (CITY_SIZE - 2) + 2);
        while c(1) == c(2)
            c = round(rand(1,2) * (CITY_SIZE - 2) + 2);
        end
        c1 = c(1);
        c2 = c(2);
        if c2 < c1 then
            tp = c2;
            c2 = c1;
            c1 = tp;
        end
        
        //perm(c1:c2) = perm(c2:-1:c1);
        tp = perm(c1);
        perm(c1) = perm(c2);
        perm(c2) = tp;
        //edges = [parent(c1-1), parent(c1),parent(c2-1), parent(c2)];
        edges = [ parent(c1),parent(c2)];
    endfunction
    
    function ist = is_tabu(permutation, tabu_list)
        sz = size(tabu_list);
        sz = sz(2)
        for i = 1:CITY_SIZE
            c1 = i;
            c2 = i + 1;
            if i == CITY_SIZE then
                c2 = 1;
            end
            for j = 1 : sz
               if permutation(c1) == tabu_list(1,j) & permutation(c2) == tabu_list(2,j) then
                   ist = 1;
                   return;
                end
            end
        end
        ist = 0;
    endfunction
    
    
    function [candidate, edges] = generate_candidate(best, tabu_list)
        [perm, edges] = stochastic_two_opt(best)
        while is_tabu(perm, tabu_list) == 1 do
            [perm, edges] = stochastic_two_opt(best);
        end
        candidate = perm;
        edges = edges;
    endfunction
    
    function [best,tabu_list] = search(cities, tabu_list_size, candidate_list_size, max_iter)
        current = random_permutation();
        best = current;
        tabu_list = [];
        candidates=[];
        edges =[];
        [candidates, edges] = generate_candidate(current, tabu_list);
        for i = 1: max_iter
            for j = 1 : candidate_list_size
                [tp, edges_] = generate_candidate(current, tabu_list);
                if cost(candidates, cities) > cost(tp, cities) then
                    disp([cost(candidates, cities) ,cost(tp, cities),i]);
                    candidates = tp;
                    edges = edges_;
                end
           end
           if cost(candidates, cities) < cost(current, cities) then
               current = candidates;
               if cost(candidates, cities) < cost(best, cities) then
                   best = candidates;
               end
               //tabu_list = [tabu_list, [edges(1:2)'],[edges(3:4)']];
               sz = size(tabu_list);
               sz = sz(2);
               has = 0;
               for k = 1:sz
                   if edges(1) == tabu_list(1,k) & edges(2) == tabu_list(2,k) then 
                       has = 1;
                       break;
                    end
               end
               if has == 0 then 
                   tabu_list = [tabu_list, [edges(1:2)']];
               end
               sz = size(tabu_list);
               sz = sz(2);
               if sz > tabu_list_size then
                   tabu_list = tabu_list(:, sz - tabu_list_size  + 1: sz);
               end
           end
        end
    endfunction
    
    max_iter = 200;
    tabu_list_size = 15;
    candidate_list_size = 100;
    cities = CITIES;
    [best,tabu_list] = search(cities, tabu_list_size, candidate_list_size, max_iter);
    cost_ = cost(best, cities);
    disp(cost_)
    plot(cities( [best,best(1)] ,1), cities([best,best(1)],2), '-o');
    
    
    
    
    


    展开全文
  • 团队尝试使用此存储库的所有目的是提供一些必要的紧急修复程序(足够困难),这是因为在LaTeX内核中进行了最新更正之后, tabu完全停止了工作。 但是,事实证明,我们无法解决此程序包中的所有问题,因此我们不太...
  • 语言:English 快速和简单的新选项卡,带有快速拨号,推荐的站点和空白页选项。 -快速拨号-最常用和最新的网站-选择空白页-节省云-4K兼容*需要时可以...* 4k兼容– TABU随您的显示器缩放:您无需斜视即可看到小字体。
  • 基于TABU算法的层叠滤波器优化设计,赵春晖,崔颖,图像处理中非线性数字滤波器得到广泛应用,层叠滤波器是基于信号阈值分解而发展起来的一种具有层叠性和阈值性的非线性数字滤波器
  • 使用禁忌搜索(Tabu)算法寻找函数的最大值
  • 现代优化算法之Tabu Search 讲演人肖维 指导老师张少华 为什么我们需要去研究这些个现代优化算法呢 几个概念 现代优化算法 主要指的是禁忌Tabu Search搜索模拟退火遗传算法蚁群优化算发和人工神经网络等 启发式算法 ...
  • 基于混合遗传-Tabu优化算法的应急救援主动调度优化
  • 禁忌搜索(Tabu Search)算法及python实现

    万次阅读 多人点赞 2018-08-16 13:46:51
    禁忌搜索(Tabu Search)算法解决及python实现 禁忌搜索(Tabu Search,TS,又称禁忌搜寻法)是一种现代启发式算法,由美国科罗拉多大学教授Fred Glover在1986年左右提出的,是一个用来跳脱局部最优解的搜索方法。其先...

    禁忌搜索(Tabu Search)算法及python实现

    版权声明:本文为博主原创文章,博客地址:https://blog.csdn.net/adkjb,未经博主允许不得转载。

    禁忌搜索(Tabu Search,TS,又称禁忌搜寻法)是一种现代启发式算法,由美国科罗拉多大学教授Fred Glover在1986年左右提出的,是一个用来跳脱局部最优解的搜索方法。其先创立一个初始化的方案;基于此,算法“移动”到一相邻的方案。经过许多连续的移动过程,提高解的质量。 [ 百度百科 ]

    由于网上提供的代码大多是C和Java的,这里笔者使用Python实现该算法

    【目录】
    - TS算法原理详解
    - 举例详述TS算法过程
    - Python实现TS算法
    - 总结


    TS算法原理详解

    • 邻域

      对于组合优化问题,给定任意可行解x,x∈D,D是决策变量的定义域,对于D上的一个映射:N:x∈D→N(x)∈2(D) 其中2(D)表示D的所有子集组成的集合,N(x)成为x的一个邻域,y∈N(x)称为x的一个邻居。

    • 候选集合

      候选集合一般由邻域中的邻居组成,可以将某解的所有邻居作为候选集合,也可以通过最优提取,也可以随机提取,例如某一问题的初始解是[1,2,3],若通过两两交换法则生成候选集合,则可以是[1,3,2],[2,1,3],[3,2,1]中的一个或几个。

    • 禁忌表

      禁忌表包括禁忌对象和禁忌长度。由于在每次对当前解的搜索中,需要避免一些重复的步骤,因此将某些元素放入禁忌表中,这些元素在下次搜索时将不会被考虑,这些被禁止搜索的元素就是禁忌对象;
      禁忌长度则是禁忌表所能接受的最多禁忌对象的数量,若设置的太多则可能会造成耗时较长或者算法停止,若太少则会造成重复搜索。

    • 评价函数

      用来评价当前解的好坏,TSP问题中是总旅程距离。

    • 特赦规则

      禁忌搜索算法中,迭代的某一步会出现候选集的某一个元素被禁止搜索,但是若解禁该元素,则会使评价函数有所改善,因此我们需要设置一个特赦规则,当满足该条件时该元素从禁忌表中跳出。

    • 终止规则

      一般当两次迭代得到的局部最优解不再变化,或者两次最优解的评价函数差别不大,或者迭代n次之后停止迭代,通常选择第三种方法。

    举例详述TS算法过程

    现有一架飞机,从A点出发,需要经过B,C,D,E,F之后返回A点,且每个点只能经过一次,最后返回A点,求最短路径。

    该问题是一个Hamilton回路问题,其中起点和终点已经固定,因此我们可以将解形式记为,例如【A,D,C,F,E,A】,每次只需变换中间两个元素即可,现在我们将禁忌长度设置为2,候选集合长度定义为4,迭代次数为100,通过以下步骤能使读者更清洗的了解TS算法的步骤。

    给定任意初始解 x1=【A,D,C,F,E,A】f(x1)=10,历史最优为10

    候选集合禁忌表
    【A,C,D,F,E,A】 f=15
    【A,D,C,E,F,A】 f=20
    【A,D,F,C,E,A】 f=8
    【A,E,C,F,D,A】 f=6

    我们发现对x1交换D和E时,f最优,此时x2=【A,E,C,F,D,A】 f(x2)=6,历史最优为6,将D-E放入禁忌表中

    候选集合禁忌表
    【A,E,F,C,D,A】 f=9D-E
    【A,F,C,E,D,A】 f=15
    【A,C,E,F,D,A】 f=6
    【A,E,D,F,C,A】 f=5

    我们发现对x2交换C和D时,f最优,此时x3=【A,E,D,F,C,A】 f(x3)=5,历史最优为5,将D-C放入禁忌表中

    候选集合禁忌表
    【A,E,C,F,D,A】 f=8D-E
    【A,E,F,D,C,A】 f=10D-C
    【A,E,D,C,F,A】 f=14
    【A,C,D,F,E,A】 f=16

    此时我们发现对x3交换D和C时最优,但是由于D-C已经在禁忌表中,因此我们退而求其次,对x3交换F和D,此时x4=【A,E,F,D,C,A】 f(x4)=10,历史最优为5,将F-D放入禁忌表中,由于禁忌长度为2,因此将最先放入禁忌表中的D-E移除禁忌表

    候选集合禁忌表
    【A,E,F,C,D,A】 f=4D-C
    【A,E,C,D,F,A】 f=5F-D
    【A,F,E,D,C,A】 f=7
    【A,C,F,D,C,A】 f=10

    此时我们发现对x4交换D和C时最优,虽然D-C已经在禁忌表中,但是f(D-C)<历史最优5,因此满足特赦规则,现在将D-C移除禁忌表,此时x5=【A,E,F,C,D,A】 f(x5)=4,历史最优为4,然后再将D-C放入禁忌表

    候选集合禁忌表
    【A,C,F,E,D,A】 f=5D-F
    【A,E,C,F,D,A】 f=7C-D
    【A,D,F,C,E,A】 f=9
    【A,F,E,C,D,A】 f=29

    依次迭代下去,当迭代次数超过100时停止迭代,历史最优值即为输出解

    Python实现TS算法

    此处以一个简单版的TSP问题为例

    现有29个城市,提供了经纬度,一架飞机需要从1号城市出发,途径剩下的28个城市然后返回1号城市,求最短距离

    数据如下

    地点经度维度
    11150.01760.0
    2630.01660.0
    340.02090.0
    4750.01100.0
    5750.02030.0
    61030.02070.0
    71650.0650.0
    81490.01630.0
    9790.02260.0
    10710.01310.0
    11840.0550.0
    121170.02300.0
    13970.01340.0
    14510.0700.0
    15750.0900.0
    161280.01200.0
    17230.0590.0
    18460.0860.0
    191040.0950.0
    20590.01390.0
    21830.01770.0
    22490.0500.0
    231840.01240.0
    241260.01500.0
    251280.0790.0
    26490.02130.0
    271460.01420.0
    281260.01910.0
    29360.01980.0

    解的形式为例如[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28],这去除了开头结尾的0,即1号城市,只用计算中间的航程即可

    import random
    import datetime
    city = []
    eg=
    for line in open("tsp.txt"):
        place,lon,lat = line.strip().split(" ")
        city.extend([(place,(lon,lat))])  #导入城市的坐标
    def printtravel(vec):
        print(city[0],city[vec[0]])
        for i in range(len(vec)-1):
            print(city[vec[i]],city[vec[i+1]])
        print(city[vec[i+1]],city[0])  #打印结果函数  
     eg=[i for i in range(1,29)]  #一个例子
     printtravel(eg)

    【下面是打印出来的路径,即1→2→3→4→…→29→1】
    (‘1’, (‘1150.0’, ‘1760.0’)) (‘2’, (‘630.0’, ‘1660.0’))
    (‘2’, (‘630.0’, ‘1660.0’)) (‘3’, (‘40.0’, ‘2090.0’))
    (‘3’, (‘40.0’, ‘2090.0’)) (‘4’, (‘750.0’, ‘1100.0’))
    (‘4’, (‘750.0’, ‘1100.0’)) (‘5’, (‘750.0’, ‘2030.0’))
    (‘5’, (‘750.0’, ‘2030.0’)) (‘6’, (‘1030.0’, ‘2070.0’))
    (‘6’, (‘1030.0’, ‘2070.0’)) (‘7’, (‘1650.0’, ‘650.0’))
    (‘7’, (‘1650.0’, ‘650.0’)) (‘8’, (‘1490.0’, ‘1630.0’))
    (‘8’, (‘1490.0’, ‘1630.0’)) (‘9’, (‘790.0’, ‘2260.0’))
    (‘9’, (‘790.0’, ‘2260.0’)) (‘10’, (‘710.0’, ‘1310.0’))
    (‘10’, (‘710.0’, ‘1310.0’)) (‘11’, (‘840.0’, ‘550.0’))
    (‘11’, (‘840.0’, ‘550.0’)) (‘12’, (‘1170.0’, ‘2300.0’))
    (‘12’, (‘1170.0’, ‘2300.0’)) (‘13’, (‘970.0’, ‘1340.0’))
    (‘13’, (‘970.0’, ‘1340.0’)) (‘14’, (‘510.0’, ‘700.0’))
    (‘14’, (‘510.0’, ‘700.0’)) (‘15’, (‘750.0’, ‘900.0’))
    (‘15’, (‘750.0’, ‘900.0’)) (‘16’, (‘1280.0’, ‘1200.0’))
    (‘16’, (‘1280.0’, ‘1200.0’)) (‘17’, (‘230.0’, ‘590.0’))
    (‘17’, (‘230.0’, ‘590.0’)) (‘18’, (‘460.0’, ‘860.0’))
    (‘18’, (‘460.0’, ‘860.0’)) (‘19’, (‘1040.0’, ‘950.0’))
    (‘19’, (‘1040.0’, ‘950.0’)) (‘20’, (‘590.0’, ‘1390.0’))
    (‘20’, (‘590.0’, ‘1390.0’)) (‘21’, (‘830.0’, ‘1770.0’))
    (‘21’, (‘830.0’, ‘1770.0’)) (‘22’, (‘490.0’, ‘500.0’))
    (‘22’, (‘490.0’, ‘500.0’)) (‘23’, (‘1840.0’, ‘1240.0’))
    (‘23’, (‘1840.0’, ‘1240.0’)) (‘24’, (‘1260.0’, ‘1500.0’))
    (‘24’, (‘1260.0’, ‘1500.0’)) (‘25’, (‘1280.0’, ‘790.0’))
    (‘25’, (‘1280.0’, ‘790.0’)) (‘26’, (‘490.0’, ‘2130.0’))
    (‘26’, (‘490.0’, ‘2130.0’)) (‘27’, (‘1460.0’, ‘1420.0’))
    (‘27’, (‘1460.0’, ‘1420.0’)) (‘28’, (‘1260.0’, ‘1910.0’))
    (‘28’, (‘1260.0’, ‘1910.0’)) (‘29’, (‘360.0’, ‘1980.0’))
    (‘29’, (‘360.0’, ‘1980.0’)) (‘1’, (‘1150.0’, ‘1760.0’))

    def costroad(road):
        cost = ((float(city[0][1][0])-float(city[road[0]][1][0]))**2+(float(city[0][1][1])-float(city[road[0]][1][1]))**2)**0.5
        for i in range(len(road)-1):
            cost = cost+((float(city[road[i+1]][1][0])-float(city[road[i]][1][0]))**2+(float(city[road[i+1]][1][1])-float(city[road[i]][1][1]))**2)**0.5
        cost=cost+((float(city[road[-1]][1][0])-float(city[0][1][0]))**2+(float(city[-1][1][1])-float(city[0][1][1]))**2)**0.5
        return(cost)  #计算所求解的距离,这里为了简单,视作二位平面上的点,使用了欧式距离
     costroad(eg)  #计算上例中的总路程

    【结果】
    25814.877362907795

    def tabusearch(diedaitimes,cacu_time,tabu_length,origin_times,costf,printf):
        s1=datetime.datetime.now()  #获取运行前的时间
        print("The program now is executing...")
        def pan_move(move_step,tabu_move):  #判断移动是否在禁忌区域中,如果是返回True和该点索引,否则返回False和0
            if move_step in tabu_move:
                index = tabu_move.index(move_step)
                return(True,index)
            else:
                return(False,0)
        def pan_cost(cost,tabu_cost,t):  #判断该移动是否比禁忌区域中该移动小,如果小则返回True,否则返回False
            if cost<tabu_cost[t]:
                return(True)
            else:
                return(False)  
        def add_tabu(cost,move,tabu_cost,tabu_move,t):  #为禁忌区域添加移动和成本,若超过T则剔除最先进入的禁忌
            tabu_cost.append(cost)
            tabu_move.append(move)
            if len(tabu_cost)>t:
                del tabu_cost[0]
            if len(tabu_move)>t:
                del tabu_move[0]
            return(tabu_cost,tabu_move)
        def cacu(vec,t):    #为每一个初始解计算t次
            vec_set = []
            m_set = []
            cost_set = []
            h = []
            for i in range(t):
                v,m,c,h = move(vec,h)
                vec_set.append(v)
                m_set.append(m)
                cost_set.append(c)
            return(vec_set,m_set,cost_set)
        def cacu_tiqu(v1,m1,c1):    #从上述t次筛选最小的解向量,移动和成本
            t = c1.index(min(c1))
            v_max = v1[t]
            m_max = m1[t]
            c_max = c1[t]
            return(v_max,m_max,c_max)
        def move(vec,h):  #输出移动后的向量,和成本
            i = 1
            while i==1:
                m = random.sample(vec,2)
                m.sort()
                if m not in h:
                    h.append(m)
                    vec_copy = vec[:]
                    vec_copy[vec_copy.index(m[0])] = m[1]
                    vec_copy[vec_copy.index(m[1])] = m[0]
                    cost = costf(vec_copy)
                    i = 0
                    return(vec_copy,m,cost,h)   
        finall_road = []
        finall_cost = []
        for t1 in range(origin_times):
            road = [i for i in range(1,29)]
            random.shuffle(road)
            tabu_cost = []
            tabu_move = []
            for t in range(diedaitimes):
                i = 0
                while i==0:
                    v1,m1,c1 = cacu(road,cacu_time)
                    v_m,m_m,c_m = cacu_tiqu(v1,m1,c1)
                    key1 = pan_move(m_m,tabu_move)
                    if key1[0]:
                        if pan_cost(c_m,tabu_cost,key1[1]):
                            road = v_m
                            finall_road.append(road)
                            finall_cost.append(c_m)
                            tabu_cost,tabu_move = add_tabu(c_m,m_m,tabu_cost,tabu_move,tabu_length)
                            i=1
                        else:
                            v1.remove(v_m)
                            m1.remove(m_m)
                            c1.remove(c_m)
                            if len(v1)==0:
                                i = 1
                    else:
                        tabu_cost,tabu_move = add_tabu(c_m,m_m,tabu_cost,tabu_move,tabu_length)
                        road = v_m
                        finall_road.append(road)
                        finall_cost.append(c_m)
                        i = 1
        index = finall_cost.index(min(finall_cost))
        s2 = datetime.datetime.now()
        print("Successfully execute!,the program has executed for "+str((s2-s1).seconds)+" seconds!")
        return(finall_road[index],min(finall_cost),printf(finall_road[index]))
    
    tabusearch(diedaitimes=100,cacu_time=100,tabu_length=10,origin_times=100,costf=costroad,printf=printtravel)

    其中diedaitimes为每一个初始解的迭代次数,cacu_time为候选集合长度,tabu_length为禁忌长度,origin_times为整个程序循环次数,可以理解为使用不同个初始解,costf为成本函数,printtravel为打印结果函数,运行上一条程序可得结果:

    The program now is executing…
    Successfully execute!,the program has executed for 71 seconds!
    (‘1’, (‘1150.0’, ‘1760.0’)) (‘6’, (‘1030.0’, ‘2070.0’))
    (‘6’, (‘1030.0’, ‘2070.0’)) (‘13’, (‘970.0’, ‘1340.0’))
    (‘13’, (‘970.0’, ‘1340.0’)) (‘15’, (‘750.0’, ‘900.0’))
    (‘15’, (‘750.0’, ‘900.0’)) (‘4’, (‘750.0’, ‘1100.0’))
    (‘4’, (‘750.0’, ‘1100.0’)) (‘10’, (‘710.0’, ‘1310.0’))
    (‘10’, (‘710.0’, ‘1310.0’)) (‘2’, (‘630.0’, ‘1660.0’))
    (‘2’, (‘630.0’, ‘1660.0’)) (‘26’, (‘490.0’, ‘2130.0’))
    (‘26’, (‘490.0’, ‘2130.0’)) (‘3’, (‘40.0’, ‘2090.0’))
    (‘3’, (‘40.0’, ‘2090.0’)) (‘29’, (‘360.0’, ‘1980.0’))
    (‘29’, (‘360.0’, ‘1980.0’)) (‘5’, (‘750.0’, ‘2030.0’))
    (‘5’, (‘750.0’, ‘2030.0’)) (‘9’, (‘790.0’, ‘2260.0’))
    (‘9’, (‘790.0’, ‘2260.0’)) (‘12’, (‘1170.0’, ‘2300.0’))
    (‘12’, (‘1170.0’, ‘2300.0’)) (‘21’, (‘830.0’, ‘1770.0’))
    (‘21’, (‘830.0’, ‘1770.0’)) (‘20’, (‘590.0’, ‘1390.0’))
    (‘20’, (‘590.0’, ‘1390.0’)) (‘18’, (‘460.0’, ‘860.0’))
    (‘18’, (‘460.0’, ‘860.0’)) (‘14’, (‘510.0’, ‘700.0’))
    (‘14’, (‘510.0’, ‘700.0’)) (‘17’, (‘230.0’, ‘590.0’))
    (‘17’, (‘230.0’, ‘590.0’)) (‘22’, (‘490.0’, ‘500.0’))
    (‘22’, (‘490.0’, ‘500.0’)) (‘11’, (‘840.0’, ‘550.0’))
    (‘11’, (‘840.0’, ‘550.0’)) (‘7’, (‘1650.0’, ‘650.0’))
    (‘7’, (‘1650.0’, ‘650.0’)) (‘25’, (‘1280.0’, ‘790.0’))
    (‘25’, (‘1280.0’, ‘790.0’)) (‘19’, (‘1040.0’, ‘950.0’))
    (‘19’, (‘1040.0’, ‘950.0’)) (‘16’, (‘1280.0’, ‘1200.0’))
    (‘16’, (‘1280.0’, ‘1200.0’)) (‘23’, (‘1840.0’, ‘1240.0’))
    (‘23’, (‘1840.0’, ‘1240.0’)) (‘8’, (‘1490.0’, ‘1630.0’))
    (‘8’, (‘1490.0’, ‘1630.0’)) (‘27’, (‘1460.0’, ‘1420.0’))
    (‘27’, (‘1460.0’, ‘1420.0’)) (‘24’, (‘1260.0’, ‘1500.0’))
    (‘24’, (‘1260.0’, ‘1500.0’)) (‘28’, (‘1260.0’, ‘1910.0’))
    (‘28’, (‘1260.0’, ‘1910.0’)) (‘1’, (‘1150.0’, ‘1760.0’))
    ([5,12,14,3,9,1,25,2,28,4,8,11,20,19,17,13,16,21,10,6,24,18,15,22,7,26,23,27],
    11356.612831196624,None)
    所得到的路径如下图,总航程约为11356

    下面是路径,黑色为起点(这个是用R绘制的,就不上代码了)
    这里写图片描述

    总结

    从本例出发,28个城市进行排列,共有28!≈3*10^29种组合,笔者使用暴力枚举测试了一百万个组合,耗费76秒得到里程为16270的一条航程,相比本文讨论的禁忌搜索算法,仅使用71秒就得到了11356的一条行程,因此具有非常好的效果,虽然从图像来看好像不是最优路径,但是通过调整参数会逐渐接近最优解。

    数据集链接:https://pan.baidu.com/s/1DOUCHkgX_8KoxUtrmV-aTw

    展开全文
  • 一种搜索模糊聚类全局最优解的Tabu算法.pdf
  • tabu search for TSP matlab

    2009-03-25 21:55:32
    a tabu search algorithm wrote by Zhaokai
  • 为了在聚类数不确定的情况下实现聚类分析,本文提出了一种新的结合人工免疫网络和Tabu搜索的动态聚类算法―DCBIT。新算法主要包含两个阶段:先使用人工免疫网络算法获得一个候选聚类中心集,然后使用Tabu搜索在候选...
  • 这里用Tabu搜索算法去解决N皇后的问题 只要点击菜单上的“查找Queens”便可以进行搜索
  • 论文研究-关于Tabu Swarch算法收敛性的研究.pdf,
  • An example to apply tabu search to find optimal routes for TSP prblem
  • TABU流水车间生产调度

    2011-05-28 12:12:48
    可以进行流水车间调度,使用C++编写,TABU算法
  • 禁忌搜索算法的matlab代码
  • A Discrete differential evolution with tabu list approach to no-wait flow-shop scheduling
  • tabu search --fred glover

    2010-10-16 09:27:16
    tabu search --fred glovertabu search --fred glovertabu search --fred glovertabu search --fred glovertabu search --fred glover
  • Tabu源代码和教案

    2007-12-14 15:36:11
    Tabu源代码和教案,也称为禁忌算法,纯c编写

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,438
精华内容 575
关键字:

Tabu