使用动态规划和深度优先搜索解决TSP问题，python编写

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_24003469/article/details/89297336

参考：
1）https://www.jianshu.com/p/a66e3166569b
2）https://www.cnblogs.com/youmuchen/p/6879579.html

一使用动态规划解决TSP（背包问题），直接上代码

import sys
def find_vertex(j):
    vertex = []
    for v in range(n-1):
        if 2**v & j != 0:
            vertex.append(v+1)
    return vertex

# 如果j=5 ,则返回vertex = {1,3},就是求二进制的1所在位置
def TSP(C):
    for i in range(C.__len__()):
        for j in range(C[i].__len__()):
            if C[i][j] == -1:
                C[i][j] = sys.maxsize
    n = len(C)
    dp = [[sys.maxsize for j in range(2 ** (n - 1))] for i in range(n)]
    for i in range(0, n):
        dp[i][0] = C[i][0]

    for j in range(1, 2**(n-1)):
        for i in range(0, n):
            temp_1 = []
            vertexs = find_vertex(j)
            if i not in vertexs:
                for k in vertexs:
                    if C[i][k] == -1:
                        continue
                    temp_1.append(C[i][k] + dp[k][j - 2**(k-1)])
            if temp_1:
                dp[i][j] = min(temp_1)
            del temp_1
    return dp
if __name__ == "__main__":
    C = [
        [-1, 10, 15, -1],
        [10, -1, 35, 25],
        [15, 35, -1, 30],
        [-1, 25, 30, -1]
    ]
#如果不能到达，必须是 -1，因为在TSP中，对于不能到达的两点间，赋值为无穷大
    n = len(C) # n nodes
    dp = TSP(C) # the  final result
    print(dp[0][2**(n-1)-1])

二深度搜索方法实现：

import sys
c = []
path_vertexs = []
path_length = []
def find_path(j,num):
    path_vertexs.append(j)
    row = c[j]
    copy_row = []
    for g in range(c[j].__len__()):
        if g not in path_vertexs:
            copy_row.append(c[j][g])
    if len(path_vertexs) < num:
        min_e = min(copy_row)
        j = row.index(min_e)
        path_length.append(min_e)
        find_path(j,num)
    else:
        min_e = c[j][0]
        path_length.append(min_e)
    return path_length

if __name__ == "__main__":
    # n = int(sys.stdin.readline().strip())
    # ans = 0
    # for i in range(n):
    #     line = sys.stdin.readline().strip()
    #     values = list(map(int, line.split()))
    #     c.append(values)
    c = [
        [0, 2, 6, 5],
        [2, 0, 4, 4],
        [6, 4, 0, 2],
        [5, 4, 2, 0]
    ]
    cost = find_path(0, c.__len__())
    print(sum(cost))

大家在使用深度搜索时，要注意一下。从逻辑分析知，这个方法假设所有节点都是连同的，而动态用的案例有些节点是不连通的。所以注意，注意，注意！！！。而且深度优先搜索，并不是最优的！！！
如果有错，请指出，感谢老铁们的支持