旅行商问题的虚拟节点

Question

最近我读了很多关于 TSP 的文章，我需要创建一个 TSP 的变体

1. 我不关心起点（可以是任何城市）和
2. 结束城市不必与起始城市相同

显然，这可以使用虚拟节点来实现 - 到每个其他节点的距离为 0：source 这是否意味着输入：cityA、cityB、cityC、cityD、cityE 矩阵表示应如下所示：

[
[0,9,6,1,3]
[9,0,4,2,1]
[6,4,0,9,1]
[1,2,9,0,8]
[3,1,1,8,0]
[0,0,0,0,0]
]

这是正确的方法，如果不是，那为什么？我仍然对理解为什么额外的虚拟节点工作以获取我的变体的路径感到困惑。谢谢

Answer 1

根据上面的评论，这是一个没有虚拟节点的示例：

import functools
import math

def shortest_path(arr):
    
    n = len(arr)
    bitmask = [1 << i for i in range(n)]
    target = (1 << n) - 1
    
    @functools.lru_cache(None)
    def helper(city, visited):
        nonlocal target, n
        
        if visited == target:
            return 0, [city]
        
        best = math.inf, []
        for neigh in range(n):
            if not (visited & bitmask[neigh]):
                cost, path = helper(neigh, visited | bitmask[neigh])
                cost += arr[city][neigh]
                path = [city] + path
                if cost < best[0]:
                    best = cost, path
        return best
    
    best, best_path = math.inf, []
    for start in range(n):
        total_distance, path = helper(start, bitmask[start])
        if total_distance < best:
            best, best_path = total_distance, path
    
    return best, best_path

def shortest_path_padded(arr):
    n = len(arr)
    bitmask = [1 << i for i in range(n)]
    target = (1 << n) - 1
    
    @functools.lru_cache(None)
    def helper(city, visited):
        nonlocal target, n
        
        if visited == target:
            return 0, [city]
        
        best = math.inf, []
        for neigh in range(n):
            if not (visited & bitmask[neigh]):
                cost, path = helper(neigh, visited | bitmask[neigh])
                cost += arr[city][neigh]
                path = [city] + path
                if cost < best[0]:
                    best = cost, path
        return best
    
    return helper(0, bitmask[0])


if __name__ == "__main__":
    arr = [
            [0,9,6,1,3],
            [9,0,4,2,1],
            [6,4,0,9,1],
            [1,2,9,0,8],
            [3,1,1,8,0]
          ]
    arr2 = [[0]*(len(arr[0])+1)] + [[0] + row for row in arr]
    
    print(shortest_path(arr))
    print(shortest_path_padded(arr2))

Out: (5, [0, 3, 1, 4, 2])
Out: (5, [0, 1, 4, 2, 5, 3]) # city names + 1 because city 0 is dummy city

使用虚拟节点与尝试每个城市作为起始城市有什么不同？

没什么，如果你从一个距离任何其他城市的虚拟节点 0 开始，它的第一选择就是选择第一个去的城市。

这个没有for循环和零填充数组的解决方案与使用for循环和数组的解决方案相同。

---

#NO LIBRARIES
def shortest_path_padded_no_libs(arr):
    n = len(arr)
    bitmask = [1 << i for i in range(n)]
    target = (1 << n) - 1
    
    def helper(city, visited):
        nonlocal target, n
        
        h = (city, visited)
        if h in memo:
            return memo[h]
        
        if visited == target:
            return 0, [city]
        
        best = float('inf'), []
        for neigh in range(n):
            if not (visited & bitmask[neigh]):
                cost, path = helper(neigh, visited | bitmask[neigh])
                cost += arr[city][neigh]
                path = [city] + path
                if cost < best[0]:
                    best = cost, path
                    
        memo[h] = best
        return best
    
    memo = {}
    
    return helper(0, bitmask[0])


if __name__ == "__main__":
    arr = [
            [0,9,6,1,3],
            [9,0,4,2,1],
            [6,4,0,9,1],
            [1,2,9,0,8],
            [3,1,1,8,0]
          ]
    arr2 = [[0]*(len(arr[0])+1)] + [[0] + row for row in arr]
    print(shortest_path_padded_no_libs(arr2))