tsp問題-遍歷算法/隨機算法

旅行商問題，即TSP問題（Traveling Salesman Problem）又譯為旅行推銷員問題、貨郎擔問題，是數學領域中著名問題之一。假設有一個旅行商人要拜訪n個城市，他必須選擇所要走的路徑，路徑的限制是每個城市只能拜訪一次，而且最后要回到原來出發的城市。路徑的選擇目標是要求得的路徑路程為所有路徑之中的最小值。

#!/user/bin/env python
# -*- coding:utf-8 -*-

# TSP旅行商問題：若干個城市，任意兩個城市之間距離確定，要求一旅行商從某城市
# 出發必須經過每一個城市且只能在每個城市逗留一次，最后回到原出發城市，試
# 確定一條最短路徑使旅行費用最少

# 遍歷算法

# 給定某條路徑，計算它的成本
def distcal(path, dist):
    # 計算路徑成本（路徑，距離）
    sum_dist = 0  # 總成本
    for j in range(0, len(path) - 1):
        di = dist[int(path[j]) - 1][int(path[j + 1]) - 1]  # 查找第j和j+1個城市之間的成本
        sum_dist = sum_dist + di  # 累加
    di = dist[int(path[len(path) - 1]) - 1][path[0] - 1]  # 最后一個城市回到初始城市的成本
    sum_dist = sum_dist + di
    return sum_dist  # 返回路徑的成本


# 遞歸,構造所有可能路徑
def perm(l):  # 構造路徑（城市列表）
    if (len(l)) <= 1:  # 只有一個城市，選擇這個城市
        return [l]
    r = []  # 空列表
    for i in range(len(l)):  # 對每個城市，構建不包括這個城市的所有可能序列
        s = l[:i] + l[i + 1:]  # 去除當前城市的列表
        p = perm(s)  # 調用自身，構造不包含這個城市的序列
        for x in p:
            r.append(l[i:i + 1] + x)  # 將序列和該城市合並，得到完整的序列
    return r


if __name__ == '__main__':
    city = [1, 2, 3, 4, 5]

    dist = ((0, 1, 3, 4, 5),
            (1, 0, 1, 2, 3),
            (3, 1, 0, 1, 2),
            (4, 2, 1, 0, 1),
            (5, 3, 2, 1, 0))

    for i in range(0, 5):
        print(dist[i][:])

    print('=============')

    allpath = perm(city)  # 調用路徑產生函數，產生所有可能的路徑

    optimal = 1000000  # 初始化最優路徑的總成本和索引號

    index = 1

    for i in range(0, len(allpath)):
        pd = distcal(allpath[i], dist)
        if pd < optimal:  # 比較是否總成本更低，如果是替換最優解
            optimal = pd
            index = i
        # print(pd)

    print(optimal)
    print(allpath[index])
------------------------------------------------------------------------
(0, 1, 3, 4, 5)
(1, 0, 1, 2, 3)
(3, 1, 0, 1, 2)
(4, 2, 1, 0, 1)
(5, 3, 2, 1, 0)
=============
9
[1, 2, 3, 4, 5]

#!/user/bin/env python
# -*- coding:utf-8 -*-

import random

# 給定某條路徑，計算它的成本
def distcal(path, dist):
    # 計算路徑成本（路徑，距離）
    sum_dist = 0  # 總成本
    for j in range(0, len(path) - 1):
        di = dist[int(path[j]) - 1][int(path[j + 1]) - 1]  # 查找第j和j+1個城市之間的成本
        sum_dist = sum_dist + di  # 累加
    di = dist[int(path[len(path) - 1]) - 1][path[0] - 1]  # 最后一個城市回到初始城市的成本
    sum_dist = sum_dist + di
    return sum_dist  # 返回路徑的成本

# 構造隨機路徑
def randompath(inc):  # Inc城市列表
    allcity = inc[:]  # 城市列表
    path = []  # 路徑
    loop = True
    while loop:
        if 1 == len(allcity):  # 如果是最后一個城市
            tmp = random.choice(allcity)
            path.append(tmp)
            loop = False  # 結束
        else:  # 如果不是最后一個城市
            tmp = random.choice(allcity)  # 在城市列表中隨機選擇一個城市
            path.append(tmp)  # 添加路徑
            allcity.remove(tmp)  # 在城市列表中移除該城市
    return path

if __name__ == '__main__':
    city = [1, 2, 3, 4, 5]

    dist = ((0, 1, 3, 4, 5),
            (1, 0, 1, 2, 3),
            (3, 1, 0, 1, 2),
            (4, 2, 1, 0, 1),
            (5, 3, 2, 1, 0))

    for i in range(0, 5):
        print(dist[i][:])

    print('=============')

    num = 10  # 隨機產生10條路徑

    optimal = 1000000  # 初始化最優路徑的總成本和索引號

    for i in range(0, num):
        pd = distcal(randompath(city), dist)
        if pd < optimal:  # 比較是否總成本更低，如果是替換最優解
            optimal = pd
        print(pd)

    print(optimal)
------------------------------------------------------------
(0, 1, 3, 4, 5)
(1, 0, 1, 2, 3)
(3, 1, 0, 1, 2)
(4, 2, 1, 0, 1)
(5, 3, 2, 1, 0)
=============
9
12
11
14
12
11
14
9
14
9
最優： 9