39、TSP的几种精确求解方法（DFJ、MTZ、最短边破圈式、行生成式）和启发式方法（插入法、近邻法、2-opt、3-opt、模拟退火）

最新推荐文章于 2025-03-27 19:58:05 发布
最新推荐文章于 2025-03-27 19:58:05 发布
阅读量8.5k 收藏 68
点赞数 9
分类专栏： 选址、路径规划、最大流问题 文章标签： python 算法 启发式算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaoyuzhang/article/details/100078071
版权
本文深入探讨了旅行商问题（TSP），包括定义、整数模型（DFJ与MTZ）、行生成模型、近似算法及测试结果。详细解析了各种算法的原理、实现方式与适用范围，对比了不同算法的求解效率与精度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

0、定义

TSP(Traveling Salesman Problem)，旅行商问题，又名旅行推销员问题、货郎担问题

假设一个旅行商要拜访n个城市，每个城市只能经过一次，且最后要回到起点，问如何走路程最短

1、整数模型

设cij为第i个点到第j个点的距离，xij表示是否从走到

1.1、DFJ整数模型

该模型较好理解，前面两个约束保证对每个点入度为1，出度也为1，第三个约束保证每个非空集合到其补集一定有边相连

def TSP_IP_DFJ(Dis, n, time_limit):

    model = Model("TSP_IP_DFJ")

    A = [[model.addVar(vtype="B", name="A[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]

    # 以总成本最小为目标
    model.setObjective(quicksum(Dis[i][j] * A[i][j] for i in range(n) for j in range(n)))

    #一度约束
    for i in range(n):
        model.addCons(quicksum(A[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(A[j][i] for j in range(n) if i != j) == 1)

    #无子环约束
    SS = subset([i for i in range(n)])
    for S in SS:
        model.addCons(quicksum(A[i][j] for i in S for j in range(n) if j not in S) >= 1)

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)
    model.optimize()
    print("\ngap:", model.getGap())

    A1 = [[round(model.getVal(A[i][j])) for j in range(n)] for i in range(n)]
    return A1

1.2、MTZ整数模型

两个模型区别在于无子环约束形式的不同，下面证明两者等价

证明

MTZ模型的好处在于其约束相较于DFJ明显变少(2^n到n^2)

def TSP_IP_MTZ(Dis, n, time_limit):

    model = Model("TSP_IP_MTZ")

    A = [[model.addVar(vtype="B", name="A[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]
    U = [model.addVar(name="U[%s]"%i) for i in range(n)]

    # 以总成本最小为目标
    model.setObjective(quicksum(Dis[i][j] * A[i][j] for i in range(n) for j in range(n)))

    # 一度约束
    for i in range(n):
        model.addCons(quicksum(A[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(A[j][i] for j in range(n) if i != j) == 1)

    #MTZ无子环约束
    for i in range(1, n):
        for j in range(1, n):
            if i != j:
                model.addCons(U[i]-U[j]+(n-1)*A[i][j] <= n-2)

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)
    model.optimize()
    print("\ngap:", model.getGap())

    A1 = [[round(model.getVal(A[i][j])) for j in range(n)] for i in range(n)]
    return A1

1.3、行生成模型

这里先解上面其松弛模型，再判定解是否满足条件，再不断添加不满足的约束，添加约束的方案一般为约束已生成的子环不会发生，下面列举一些方法

让其与补集有边相连，或让其内部连边不够，代码块里通过type区分（精确解）

1.3.1、多次调用模式

  • def sub_TSP_row_generate(Dis, n, L_S, time_limit, type=2):

    model = Model("sub_TSP_row_generate")

    A = [[model.addVar(vtype="B", name="A[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]

    # 以总成本最小为目标
    model.setObjective(quicksum(Dis[i][j] * A[i][j] for i in range(n) for j in range(n)))

    # 一度约束
    for i in range(n):
        model.addCons(quicksum(A[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(A[j][i] for j in range(n) if i != j) == 1)

    #两个方向限制不生成已有的子环
    if type == 1:
        #该集合与补集有边相连
        for S in L_S:
            model.addCons(quicksum(A[i][j] for i in S for j in range(n) if j not in S) >= 1)
            model.addCons(quicksum(A[j][i] for i in S for j in range(n) if j not in S) >= 1)
    else:
        #该集合内部边不够
        for S in L_S:
            model.addCons(quicksum(A[i][j] for i in S for j in S if i != j) <= len(S)-1)

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)
    model.optimize()
    print("\ngap:", model.getGap())

    A1 = [[round(model.getVal(A[i][j])) for j in range(n)] for i in range(n)]
    return A1

def TSP_IP_row_generate(Dis, n, time_limit):

    L_S = []
    ring_sub = True
    while ring_sub:
        ring_sub = False
        A = sub_TSP_row_generate(Dis, n, L_S, time_limit)
        D = {i:j for i in range(n) for j in range(n) if A[i][j] == 1}
        S = {0}
        a = 0
        while len(S) < n:
            b = D[a]
            if b in S:
                L_S.append(S)
                ring_sub = True
                break
            else:
                S.add(b)
                a = b
        if not ring_sub:
            return A

1.3.2、freeTransform模式

  • def LL_A_generate(A):
    LL_A = [[i] for i in range(len(A))]
    D = {i: i for i in range(len(A))}

    for i in range(len(A)):
        for j in range(len(A[i])):
            if A[i][j] == 1 and D[i] != D[j]:
                index_min = min(D[i], D[j])
                index_max = max(D[i], D[j])
                LL_A[index_min] = LL_A[index_min] + LL_A[index_max]
                del LL_A[index_max]
                for k in D:
                    if D[k] > index_max:
                        D[k] -= 1
                for k in LL_A[index_min]:
                    D[k] = index_min
    return LL_A

def TSP_IP_exact(points, Dis, time_limit=1000, type=2):
    n = len(Dis)

    model = Model("TSP_IP_exact")
    model.hideOutput()
    A = [[model.addVar(ub=1, name="A[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]

    # 以总成本最小为目标
    model.setObjective(quicksum(Dis[i][j] * A[i][j] for i in range(n) for j in range(n) if i != j), "minimize")

    for i in range(n):
        for j in range(n):
            if i == j:
                model.addCons(A[i][j] == 0)
            else:
                model.addCons(A[i][j] <= 1)
                model.addCons(A[i][j] >= 0)

    for i in range(n):
        model.addCons(quicksum(A[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(A[j][i] for j in range(n) if i != j) == 1)

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)

    EPS = 1.e-6
    loop = 0
    isMIP = False
    while True:
        loop += 1
        print("精确求解第", loop, "次迭代")
        model.optimize()
        if not isMIP:
            A1 = [[1 if model.getVal(A[i][j]) > EPS else 0 for j in range(n)] for i in range(n)]
        else:
            A1 = [[round(model.getVal(A[i][j])) for j in range(n)] for i in range(n)]
        LL_A = LL_A_generate(A1)
        if loop % 10 == 0:
            A2 = [[A1[i][j] if i < j else 0 for j in range(n)] for i in range(n)]
            A_plot(points, A2, x_min, y_min, x_max, y_max)
        if len(LL_A) == 1:
            if not isMIP:
                print("转为MIP")
                model.freeTransform()
                for i in range(len(A)):
                    for j in range(len(A[i])):
                        model.chgVarType(A[i][j], "B")
                isMIP = True
                continue
            else:
                break
        model.freeTransform()
        # 已测试过的不能在一起的点，避免再次得到
        if type == 1:
            for S in LL_A:
                model.addCons(quicksum(A[i][j] for i in S for j in range(n) if j not in S) >= 1)
        else:
            for S in LL_A:
                model.addCons(quicksum(A[i][j] for i in S for j in S if i != j) <= len(S) - 1)
    return A1

1.3.3、freeTransform和networkx模式

  • def solve_tsp(V, c, type=1):
    def addcut(cut_edges):
        G = networkx.Graph()
        G.add_edges_from(cut_edges)
        Components = list(networkx.connected_components(G))
        if len(Components) == 1:
            return False
        model.freeTransform()

        if type == 1:
            # 该集合与补集有边相连
            for S in Components:
                model.addCons(quicksum(x[i, j] for i in S for j in V if j not in S) >= 1)
                print("cut: %s 与其补集相连" % (S))
        else:
            # 该集合内部边不够
            for S in Components:
                model.addCons(quicksum(x[i, j] for i in S for j in S if j != i) <= len(S) - 1)
                print("cut: len(%s) <= %s" % (S, len(S) - 1))
        return True

    def addcut2(cut_edges):
        G = networkx.Graph()
        G.add_edges_from(cut_edges)
        Components = list(networkx.connected_components(G))

        if len(Components) == 1:
            return False
        model.freeTransform()
        for S in Components:
            T = set(V) - set(S)
            print("S:", S)
            print("T:", T)
            model.addCons(quicksum(x[i, j] for i in S for j in T if j > i) +
                          quicksum(x[i, j] for i in T for j in S if j > i) >= 2)
            print("cut: %s >= 2" % "+".join([("x[%s,%s]" % (i, j)) for i in S for j in T if j > i]))
        return True

    model = Model("tsp")

    x = {}
    for i in V:
        for j in V:
            x[i, j] = model.addVar(ub=1, name="x(%s,%s)" % (i, j))

    for i in V:
        model.addCons(quicksum(x[i, j] for j in V if j != i) == 1, "OutDegree(%s)" % i)
        model.addCons(quicksum(x[j, i] for j in V if j != i) == 1, "InDegree(%s)" % i)

    model.setObjective(quicksum(c[i, j] * x[i, j] for i in V for j in V if j != i), "minimize")

    EPS = 1.e-6
    isMIP = False
    while True:
        model.optimize()
        edges = []
        for (i, j) in x:
            if model.getVal(x[i, j]) > EPS:
                edges.append((i, j))

        if addcut(edges) == False:
            if isMIP:  # integer variables, components connected: solution found
                break
            model.freeTransform()
            for (i, j) in x:  # all components connected, switch to integer model
                model.chgVarType(x[i, j], "B")
                isMIP = True

    return model.getObjVal(), edges

def TSP_IP_exact_official(points, Dis):
    nums = len(points)
    V = range(1, nums + 1)
    c = {(i, j): Dis[i - 1][j - 1] for i in range(1, nums + 1) for j in range(1, nums + 1)}
    obj, edges = solve_tsp(V, c)
    A = [[0 for j in range(nums)] for i in range(nums)]
    for edge in edges:
        A[edge[0] - 1][edge[1] - 1] = 1
    return A

1.3.4、最短的边破除该子环（启发式，效果一般）

  • def sub_TSP_row_generate_heuristic(Dis, n, pairs_must, time_limit):

    model = Model("sub_TSP_row_generate_heuristic")

    A = [[model.addVar(vtype="B", name="A[%s,%s]" % (i, j)) for j in range(n)] for i in range(n)]

    # 以总成本最小为目标
    model.setObjective(quicksum(Dis[i][j] * A[i][j] for i in range(n) for j in range(n)))

    # 一度约束
    for i in range(n):
        model.addCons(quicksum(A[i][j] for j in range(n) if i != j) == 1)
        model.addCons(quicksum(A[j][i] for j in range(n) if i != j) == 1)

    #把要连的边连上
    for pair in pairs_must:
        i, j = pair[0], pair[1]
        model.addCons(A[i][j]+A[j][i] == 1)

    # 设置求解时间
    model.setRealParam("limits/time", time_limit)
    model.optimize()
    print("\ngap:", model.getGap())

    A1 = [[round(model.getVal(A[i][j])) for j in range(n)] for i in range(n)]
    return A1

def TSP_IP_row_generate_heuristic(points, Dis, n, time_limit):

    pairs = pair_points_generate(Dis)
    pairs_must = set()
    ring_sub = True
    used = {i:0 for i in range(n)}
    while ring_sub:
        ring_sub = False
        A = sub_TSP_row_generate_heuristic(Dis, n, pairs_must, time_limit)
        D = {i:j for i in range(n) for j in range(n) if A[i][j] == 1}
        S = {0}
        a = 0
        while len(S) < n:
            b = D[a]
            #若生成子环，则将最短破圈边加入
            if b in S:
                ring_sub = True
                for pair in pairs:
                    i, j = pair[0], pair[1]
                    if ((i in S and j not in S) or (i not in S and j in S)) and used[i] <= 1 and used[j] <= 1:
                        pairs_must.add((i, j))
                        used[i] += 1
                        used[j] += 1
                        break
                break
            else:
                S.add(b)
                a = b
    A = deal_overlap(points, A)
    A = Undirected_to_directed(A)
    return A

2、近似算法

2.1、插入法

该方法很直观，从一个点开始，不断的把最近的邻居加进来

#近邻插入
def TSP_nearest(points, Dis):
    n = len(Dis)

    S = [0 for i in range(len(Dis))]
    T = [1 for i in range(len(Dis))]

    # 加入第一个点
    route = [0]
    S[0] = 1
    T[0] = 0

    # 开始加点
    while sum(T) > 0:
        u = route[-1]
        nexts = [i for i in range(n) if S[i] == 0]
        v = nexts[0]
        for j in range(1, len(nexts)):
            if Dis[u][v] > Dis[u][nexts[j]]:
                v = nexts[j]
        route.append(v)
        S[v] = 1
        T[v] = 0

    A = [[0 for j in range(n)] for i in range(n)]
    for i in range(len(route) - 1):
        A[route[i]][route[i + 1]] = 1
        A[route[i + 1]][route[i]] = 1
    A[route[0]][route[-1]] = 1
    A[route[-1]][route[0]] = 1

    A = deal_overlap(points, A)

    return A

2.2、凸包插入法

先把所有点的凸包算出来，然后把剩余点以损失最小的方式插入路径中

#先着凸包，再插入
def TSP_insert(points, Dis):
    # 每个坐标对应的索引
    D = {}
    for p in points:
        D[p[0]] = p[1:]

    ps = list(D.values())
    b = boundary_find(ps)

    route = []
    for p in b:
        idex = list(D.keys())[list(D.values()).index(p)]
        if idex not in route:
            route.append(idex)

    S = [i for i in range(len(points)) if i not in route]

    while len(S) > 0:
        costs = [[Dis[route[-1]][S[i]] + Dis[S[i]][route[0]] - Dis[route[-1]][route[0]]] + [
            Dis[route[j]][S[i]] + Dis[S[i]][route[j + 1]] - Dis[route[j]][route[j + 1]] for j in range(len(route) - 1)]
                 for i in range(len(S))]
        new, idex = 0, 0
        for i in range(len(S)):
            for j in range(len(route)):
                if costs[i][j] < costs[new][idex]:
                    new, idex = i, j
        route.insert(idex, S[new])
        del S[new]

    n = len(points)
    A = [[0 for j in range(n)] for i in range(n)]
    for i in range(len(route) - 1):
        A[route[i]][route[i + 1]] = 1
        A[route[i + 1]][route[i]] = 1
    A[route[0]][route[-1]] = 1
    A[route[-1]][route[0]] = 1

    A = deal_overlap(points, A)

    return A

2.3、2-opt

随机初始化，不断的交换两个点的位置，更短则更新

#2-opt
def TSP_2_opt(points, Dis):
    route = [i for i in range(len(points))]
    n = len(points)

    flag = 1

    while flag == 1:
        flag = 0
        for i in range(n - 1):
            for j in range(i + 1, n):
                route1 = copy.deepcopy(route)
                route1[i], route1[j] = route1[j], route1[i]
                if sub_k_opt(route, Dis) > sub_k_opt(route1, Dis):
                    route = route1
                    flag = 1
                    break
            if flag == 1:
                break

    A = [[0 for j in range(n)] for i in range(n)]
    for i in range(len(route) - 1):
        A[route[i]][route[i + 1]] = 1
        A[route[i + 1]][route[i]] = 1
    A[route[0]][route[-1]] = 1
    A[route[-1]][route[0]] = 1

    A = deal_overlap(points, A)

    return A

2.4、3-opt

在2-opt的基础上，多加入一个换的点

def TSP_3_opt(points, Dis):
    route = [i for i in range(len(points))]
    n = len(points)

    flag = 1

    while flag == 1:
        flag = 0
        for i in range(n - 2):
            for j in range(i + 1, n - 1):
                for k in range(j + 1, n):
                    route1, route2, route3, route4, route5 = copy.deepcopy(route), copy.deepcopy(route), copy.deepcopy(
                        route), copy.deepcopy(route), copy.deepcopy(route)
                    route1[i], route1[j], route1[k] = route1[i], route1[k], route1[j]
                    route2[i], route2[j], route2[k] = route2[j], route2[i], route2[k]
                    route3[i], route3[j], route3[k] = route3[j], route3[k], route3[i]
                    route4[i], route4[j], route4[k] = route4[k], route4[i], route4[j]
                    route5[i], route5[j], route5[k] = route5[k], route5[j], route5[i]
                    if sub_k_opt(route, Dis) > sub_k_opt(route1, Dis):
                        route = route1
                        flag = 1
                    if sub_k_opt(route, Dis) > sub_k_opt(route2, Dis):
                        route = route2
                        flag = 1
                    if sub_k_opt(route, Dis) > sub_k_opt(route3, Dis):
                        route = route3
                        flag = 1
                    if sub_k_opt(route, Dis) > sub_k_opt(route4, Dis):
                        route = route4
                        flag = 1
                    if sub_k_opt(route, Dis) > sub_k_opt(route5, Dis):
                        route = route5
                        flag = 1
                    if flag == 1:
                        break
                if flag == 1:
                    break
            if flag == 1:
                break

    A = [[0 for j in range(n)] for i in range(n)]
    for i in range(len(route) - 1):
        A[route[i]][route[i + 1]] = 1
        A[route[i + 1]][route[i]] = 1
    A[route[0]][route[-1]] = 1
    A[route[-1]][route[0]] = 1

    A = deal_overlap(points, A)

    return A

2.5、SA

引入模拟退火思想，一定程度接受质量不高的解

def TSP_SA(points, Dis):
    route = [i for i in range(len(points))]
    n = len(points)

    T = 1000 * sub_k_opt(route, Dis)
    T0 = 1
    alpha = 0.99
    flag = 0
    limit = n * math.log(n)
    loop = 0

    while flag < limit or T <= T0:
        loop += 1
        if loop % 10 == 0:
            print("模拟退火进行至:", loop)
        i = int(rd.random() * (n - 1))
        j = int(rd.random() * (n - i - 1)) + i + 1
        route1 = copy.deepcopy(route)
        route1[i], route1[j] = route1[j], route1[i]
        if sub_k_opt(route, Dis) > sub_k_opt(route1, Dis):
            route = route1
            T = T * alpha
            flag = 0
        else:
            dc = sub_k_opt(route1, Dis) - sub_k_opt(route, Dis)
            if math.exp(-dc / T) > rd.random():
                route = route1
                T = T * alpha
                flag = 0
            else:
                flag += 1

    A = [[0 for j in range(n)] for i in range(n)]
    for i in range(len(route) - 1):
        A[route[i]][route[i + 1]] = 1
        A[route[i + 1]][route[i]] = 1
    A[route[0]][route[-1]] = 1
    A[route[-1]][route[0]] = 1

    A = deal_overlap(points, A)

    return A

3、测试结果

3.1、各方法适用范围

方法

类型

适用规模

DFJ

精确解

0-15

MTZ

精确解

0-80

row_generate

精确解

0-20

row_generate_heuristic

近似解

0-100

exact

精确解

0-150

exact_official

精确解

0-150

nearest

近似解

0-

insert

近似解

0-

2-opt

近似解

0-

3-opt

近似解

0-

SA

近似解

0-

3.2、测试结果

这里采用公共数据集中有最优解的case测试，总体来说凸包插入法在求解效率(秒级别出结果)和求解精度(gap4.43%)上表现较好

测试集

最优解

近邻插入

gap

时间

凸包插入

gap

时间

avg8.44%3.344.43%3.29
gr9654490.0658973.968.23%0.3557667.755.83%0.26
rd1007910.409100.2615.04%0.278430.036.57%0.30
pcb44250783.5558982.0416.14%9.5456156.0110.58%10.91
lin10514383.0018027.8925.34%0.3714632.231.73%0.33
tsp2253859.004275.9310.80%2.024377.0713.42%1.94
gr666321086.46338140.025.31%53.76345173.007.50%50.96
ch1306110.866791.3111.14%0.566656.108.92%0.55
bays292020.002030.000.50%0.022044.001.19%0.03
berlin527544.378244.839.28%0.088069.846.97%0.09
eil51429.98455.946.04%0.06452.175.16%0.09
ulysses168182.208176.38-0.07%0.018179.44-0.03%0.01
kroD10021294.2923441.2310.08%0.4021676.431.79%0.25
gr20260350.2156023.71-7.17%1.3355704.01-7.70%1.51
ch1506532.287531.6315.30%0.766952.566.43%0.73
a2802586.772920.0512.88%2.892812.688.73%3.39
pr76108159.44115930.237.18%0.13113672.765.10%0.17
ulysses228354.998496.751.70%0.028306.20-0.58%0.02
kroC10020750.7623680.5114.12%0.2720871.380.58%0.28
eil76545.39578.426.06%0.13572.825.03%0.13
eil101642.31672.744.74%0.34671.684.57%0.28
att4810628.0011148.004.89%0.0610859.002.17%0.06
st70678.60734.538.24%0.13702.503.52%0.16
bayg291610.001708.006.09%0.031610.000.00%0.03

对比图

 

分支界定算法实践(三) 精确求解TSP
wangzhenyang2的博客
12-03 3174
TSP问题是非常经典的NP难问题，问题描述很简单，但是求解难度却很大。首先还是给出TSP的数学描述： 图G(V,E)G(V,E)G(V,E)是一个无向简单图，集合VVV包含了顶点1,2,...,n1,2,...,n1,2,...,n，集合EEE包含了所有边e(i,j),i,j∈Ve(i,j), i,j\in Ve(i,j),i,j∈V. 每条边e(i,j)e(i,j)e(i,j)都有对应的权重wij≥0w_{ij}\geq0wij​≥0. 需要找到一个边集合T⊂ET\subset ET⊂E，其包含的边构成
旅行商问题(TSP)的几种求解方法
11-20
模拟退火算法是一种启发式搜索算法，其设计灵感来源于物理过程中的退火理论。该算法允许在搜索过程中以一定的概率接受比当前解更差的解，以此跳出局部最优，增加找到全局最优解的概率。模拟退火算法的一个重要参数是...
四种经典启发式算法求解TSP问题
12-13
四种经典启发式算法求解TSP问题，包括模拟退火（Simulated annealing）、禁忌搜索（Tabu search）、遗传算法（Genetic algorithms）和蚁群算法（Ant colonies）
使用2-opt改进模拟退火算法找到TSP最优解
2402_87912470的博客
03-27 278
2-opt 是一种局部搜索算法，通过移除两条边并重新连接路径来生成候选解。这种操作可以快速消除路径中的交叉边或不必要的绕路，显著减少路径长度。相比于完全随机生成路径，2-opt 能够生成更高质量的候选解。
优化 | 浅谈旅行商（TSP）的七种整数规划模型
weixin_53463894的博客
12-08 5524
作者：彭澜 纽约州立大学水牛城分校工业工程系在读博士生，研究方向：车辆路径规划问题（VRP） 旅行商问题（TSP）是运筹学领域最知名的问题之一。本文将从整数规划模型建模的角度，介绍七种不同的建模方式，给大家提供对TSP的不同视角。 引言 本文将讨论“茴”字的六种写法，啊不对，旅行商问题的五类共七种建模模型。首先是两个最经典的模型，即DFJ模型和MTZ模型，这两个模型相信了解运筹学的朋友都有所接触，本文仅作少量拓展介绍。接下来的两类模型分别是基于货物流和最短路的模型，在国内现行的教材和中文材料中介绍较
给出一个求解TSP问题的精确解法代码
weixin_42605397的博客
01-22 171
求解 TSP 问题的一种精确解法是使用状态压缩动态规划。 以下是一个 Python 代码示例： import math def tsp(n, dist, dp):for mask in range(1, 1<<n): for i in range(n): if mask &amp; (1<<i) != 0: ...
TSP问题求解，简单易懂（动态规划法、分支限界法、回溯法）
空名的博客——云深知处
07-09 5234
文章目录1.动态规划法2.分支限界法3.回溯法 **TSP问题：**旅行家要旅行n个城市,每个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。 (∞  3  6  75  ∞  2  36  4  ∞  23  7  5  ∞)\begin{pmatrix}\
TSP问题-多种算法求解
热门推荐
weixin_45235676的博客
06-25 2万+
目录前言问题及思路1.问题概述2.设计思路源码及测试1.输入2.代码 前言 算法大作业，综合应用8种算法解决TSP问题，分别是： 蛮力法（顺序查找） 分治法（快速排序） 贪心法（求上界） 近似算法（贪心+寻找最优贪心值） 分支限界法（多城市） 动态规划法（少城市） 回溯法（中等规模城市数量） Sherwood概率算法改进版（随机第一个城市） 共8种算法（加粗的用于求解问题） 第一次发博客，如有错误，希望大佬们指正！ 问题及思路   1.问题概述 TSP问题是指旅行家要旅行n个城市，要求每个城市经历
运筹系列80: 使用Julia精确求解tsp问题
kittyzc的博客
03-08 475
使用flow约束构建基础模型。
（1）调用Gurobi加入MTZ破子圈约束求解TSP，（2）使用蚁群算法求解TSP商旅问题的最短访问-Gurobi-an
09-07
Gurobi结合MTZ（Miller-Tucker-Zemlin）约束是一种常用的线性规划方法，可以有效地对TSP问题进行建模并求解。MTZ约束通过对子圈（即路径中部分城市形成的小闭合循环）施加惩罚来排除它们，从而确保求解结果是一条...
旅行商问题（tsp） 三种解决算法
12-03
旅行商问题（tsp） 三种解决算法，使用c++编写，可自行测试使用 旅行商问题（tsp） 三种解决算法，使用c++编写，可自行测试使用
TSP旅行商问题各种解法 详细
12-23
TSP旅行商问题各种解法 详细 TSP旅行商问题各种解法 详细 TSP旅行商问题各种解法 详细
最远插值法求解TSP问题
11-20
最远插值法求解TSP问运行环境visual studio 2008.VC程序 题最远插值法求解TSP问题最远插值法求解TSP问题
TSP 基于参考点的相邻插入法和两阶段方法
01-15
通过分析已有的最近插入法, 提出了一种基于参考点的相邻插入法(RPBN I) 及其改进策略( I2RPBN I) , 用 于求解旅行商问题(TSP) , 时间性能分别为O (n2) 和O (n3) ; 进而提出了结合模拟退火算法和I2RPBN I 的两阶段方法. 通过典型算例的数值仿真, 验证了所提出算法的有效性、高效性和鲁棒性.
算法设计TSP问题的四种算法实现
06-01
算法设计中的TSP问题的蛮力法、动态规划法、贪心法及回溯法。
旅行商问题（TSP）详解与求解方法.txt
09-30
然而，TSP属于NP难问题，当城市数量增加时，其求解难度会以指数速度增长，因此对大规模TSP问题的求解通常需要依赖近似算法或启发式算法。 TSP根据城市间距离的特性分为几类，包括对称TSP、非对称TSP和欧几里得TSP。...
启发式搜索-TSP.zip
06-28
启发式搜索是一种优化技术，常用于解决复杂度高、难以找到最优解的组合优化问题，如旅行商问题（TSP）。TSP问题的核心是寻找一个城市的最短访问路径，使得每个城市只被访问一次，最后返回起点。在这个问题中，启发式...
基于Matlab实现的使用四种启发式算法求解TSP旅行商问题-包括模拟退火+遗传算法+禁忌搜索+蚁群算法.zip
05-11
旅行商问题 基于Matlab实现的使用四种启发式算法求解TSP旅行商问题_包括模拟退火+遗传算法+禁忌搜索+蚁群算法
(1)用贪婪算法求解29个城市的TSP问题，编程实现。 (2)用最邻近插入算法求解29个城市的TSP问题，编程实现。(3) 用2-Opt算法分别对贪婪算法和最邻近算法的结果改进。思考题: (1) TSP问题模型中，消除子回路的约束如何解释。 (2)使用神经网络或动态规划算法求解29个城市的问题，编程实现。其中29个城市坐标以“编号 横坐标 纵坐标”的形式存储在文本文档中，使用Python实现编程
最新发布
03-30
<think>好，我现在需要回答用户关于TSP问题的几个编程实现和思考题。首先，用户的问题分为三个主要部分：用贪婪算法、最邻近插入算法和2-Opt算法改进结果，还有两个思考题涉及消除子回路约束和使用神经网络或动态规划求解。 首先，关于第一个编程任务，用贪婪算法求解29城市的TSP。我需要回忆贪婪算法的步骤。贪婪算法通常是每次选择最近的未访问城市，直到所有城市都被访问，然后回到起点。但需要注意，这样可能会得到局部最优，而不是全局最优。实现的话，可能需要读取城市坐标，计算距离矩阵，然后逐步构建路径。Python中可以用列表来存储已访问和未访问的城市，每一步找当前城市最近的邻居。 然后是第二个任务，最邻近插入算法。这个算法和贪婪有所不同，它从一个初始环路（比如三个城市）开始，然后每次插入一个城市到环路中成本最小的位置。具体来说，对于每个未加入的城市，找到环路上哪两个相邻城市之间插入这个城市后，总距离增加最少，然后选择最优的插入位置。这需要动态维护环路的结构，可能用列表或者链表来实现插入操作。 第三个任务是用2-Opt算法对前两个算法的结果进行改进。2-Opt是一种局部搜索算法，通过不断交换边的顺序来减少总路径长度。具体来说，遍历所有可能的边对，如果交换这两条边后路径更短，则执行交换。重复这个过程直到无法进一步优化。实现时需要注意避免重复计算，可能需要两层循环遍历所有可能的i和j，并检查交换后的路径是否更优。 接下来是思考题部分。第一个思考题是关于TSP模型中消除子回路的约束。这通常在整数线性规划模型中出现，比如使用Miller-Tucker-Zemlin约束或者子回路消除约束。需要解释这些约束如何防止多个不连通的环路形成，确保整个路径是一个单一环路。 第二个思考题要求用神经网络或动态规划。动态规划对于29个城市可能可行，因为时间复杂度是O(n^2 2^n)，但n=29时2^29大约是5亿，乘以n&sup2;可能会很大，内存和计算时间可能很高。不过可以尝试用状态压缩和记忆化优化。神经网络的话，可能是指使用类似Hopfield网络或者最近流行的图神经网络，但具体实现可能比较复杂，需要进一步查阅方法。 编程实现方面，用户提到城市坐标存储在文本文件中，格式是“编号 横坐标 纵坐标”。Python中需要读取这个文件，解析坐标，计算距离矩阵。注意距离可能是欧几里得距离，取整数或者保留小数。对于动态规划，可能需要使用bitmask表示访问过的城市集合，但29位可能超过Python的整数位数，不过Python支持大整数，所以没问题，但空间可能不够，得用字典或者数组来存储状态。 现在，具体到每个算法实现的步骤： 对于贪婪算法： 1. 读取坐标，构建距离矩阵。 2. 初始化路径，比如从城市0开始。 3. 当前城市设为0，标记为已访问。 4. 循环直到所有城市被访问： a. 找到当前城市最近的未访问城市。 b. 添加到路径，设为当前城市。 5. 最后回到起点，计算总距离。 但可能会有问题，比如路径中途无法继续时，但TSP是完全图，所以总有路径。不过可能得到的路径交叉，效果不好。 最邻近插入算法： 1. 初始化一个子环路，比如选三个城市形成一个环。 2. 剩下的城市依次插入： a. 对于每个未插入的城市，计算插入到环路中所有可能位置的成本增量。 b. 找到最小增量的城市和位置，进行插入。 3. 重复直到所有城市加入。 需要注意初始环的选择可能影响结果，可能可以随机选择一个城市，然后找最近的两个形成初始环。 2-Opt算法： 1. 输入一个路径，比如从贪婪或最邻近得到的结果。 2. 创建路径的副本，比如列表形式。 3. 改进标志设为True。 4. 当改进发生时： a. 遍历所有i和j（i < j）。 b. 计算反转i到j之间的路径后的新距离。 c. 如果新距离更小，则执行反转，设置改进标志。 5. 直到没有改进为止。 需要注意，每次反转后立即应用，或者遍历所有可能后再选择最优的，这里可能需要不同的策略，比如第一个提升就交换，或者找最大的提升。通常采用前者，容易实现。 关于动态规划的实现，可以参考Held-Karp算法。状态表示为（当前城市，已访问的城市集合），存储的是到达该状态的最小距离。递归式是dp[city][mask] = min(dp[prev_city][mask - prev_city] + distance[prev_city][city])。对于29个城市，mask是2^29，大约是536,870,912种状态，每个状态有28个可能的prev_city，存储的话可能需要大量的内存，但可以用字典或者位掩码优化。不过Python处理这样的问题可能会很慢，可能需要使用记忆化和剪枝，或者换用其他更高效的语言。不过用户要求用Python，所以可能需要做一些优化，比如使用lru_cache，但29个城市可能超过递归深度或者缓存大小限制。可能需要用迭代的方式，或者分治策略。 神经网络方面，可能使用强化学习的方法，比如指针网络（Pointer Network），但实现起来比较复杂，需要深度学习框架如TensorFlow或PyTorch。或者用遗传算法等其他启发式方法，但用户指定了神经网络或动态规划，所以可能需要尝试简单的神经网络方法，比如自组织映射（SOM）或者Hopfield网络，不过效果可能有限。 现在，将这些思路转化为具体的代码结构，并注意处理文件读取、距离计算等细节。例如，读取文件可以使用Python的open函数，按行分割，提取编号和坐标，存储为字典或列表。计算距离时，注意使用欧氏距离，并可能取整或者保留小数。 可能的错误点包括：距离矩阵的计算是否正确，路径是否正确闭合，插入算法中的环路维护是否正确，2-Opt的路径反转是否正确处理，动态规划的状态转移是否正确等。此外，处理大mask时的内存问题。 在思考题部分，消除子回路的约束可能需要参考TSP的整数规划模型中的子回路消除约束。例如，DFJ（Dantzig-Fulkerson-Johnson）约束，即对于每个子集S，至少有一条边进入和离开S。或者使用MTZ约束，引入辅助变量u_i，使得对于每条边(i,j)，如果i在路径中出现在j之前，则u_i - u_j + n x_ij ≤ n-1，这样可以防止子回路。 综上，我需要将这些思路组织成结构化的步骤，给出Python代码示例，并解释关键点。同时回答思考题的问题，解释清楚约束条件和实现方法。</think>### 分步解答： --- ### **一、算法实现部分** #### **1. 贪婪算法实现** **步骤说明**： 1. **读取数据**：从文件加载29个城市的坐标。 2. **计算距离矩阵**：存储每两个城市间的欧氏距离。 3. **构建路径**：从起点开始，每次选择最近的未访问城市加入路径，直到所有城市被访问。 4. **闭合路径**：最后回到起点，计算总距离。 **Python代码**： ```python import math def read_coords(filename): coords = [] with open(filename, &#39;r&#39;) as f: for line in f: parts = line.strip().split() coords.append((float(parts[1]), float(parts[2]))) return coords def euclidean_distance(a, b): return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2) def greedy_tsp(coords): n = len(coords) distance = [[euclidean_distance(coords[i], coords[j]) for j in range(n)] for i in range(n)] path = [0] unvisited = set(range(1, n)) current = 0 while unvisited: nearest = min(unvisited, key=lambda x: distance[current][x]) path.append(nearest) unvisited.remove(nearest) current = nearest path.append(0) # 回到起点 total_dist = sum(distance[path[i]][path[i+1]] for i in range(n)) return path, total_dist # 使用示例 coords = read_coords(&#39;cities.txt&#39;) path, dist = greedy_tsp(coords) print("贪婪算法路径:", path) print("总距离:", dist) ``` --- #### **2. 最邻近插入算法** **步骤说明**： 1. **初始化子环路**：选择3个城市形成初始环路。 2. **插入剩余城市**：每次选择使环路长度增加最少的城市和位置插入。 **Python代码**： ```python def nearest_insertion(coords): n = len(coords) distance = [[euclidean_distance(coords[i], coords[j]) for j in range(n)] for i in range(n)] # 初始环路：城市0 -> 最近城市 -> 次近城市 -> 0 start = 0 nearest = min(range(1, n), key=lambda x: distance[start][x]) second_nearest = min([x for x in range(1, n) if x != nearest], key=lambda x: distance[nearest][x]) path = [start, nearest, second_nearest, start] unvisited = set(range(n)) - {start, nearest, second_nearest} while unvisited: min_increase = float(&#39;inf&#39;) best_city = None best_pos = -1 for city in unvisited: for i in range(len(path)-1): a, b = path[i], path[i+1] increase = distance[a][city] + distance[city][b] - distance[a][b] if increase < min_increase: min_increase = increase best_city = city best_pos = i + 1 # 插入在i和i+1之间 if best_city is not None: path.insert(best_pos, best_city) unvisited.remove(best_city) total_dist = sum(distance[path[i]][path[i+1]] for i in range(len(path)-1)) return path, total_dist # 使用示例 path_ni, dist_ni = nearest_insertion(coords) print("最邻近插入路径:", path_ni) print("总距离:", dist_ni) ``` --- #### **3. 2-Opt算法改进** **步骤说明**： 1. **输入初始路径**：接受贪婪或最邻近插入的结果。 2. **反转边优化**：遍历所有可能的边对，若反转后路径更短则更新。 **Python代码**： ```python def two_opt(path, distance): n = len(path) improved = True while improved: improved = False for i in range(1, n-2): for j in range(i+1, n-1): a, b, c, d = path[i-1], path[i], path[j], path[j+1] if distance[a][b] + distance[c][d] > distance[a][c] + distance[b][d]: # 反转i到j之间的路径 path[i:j+1] = reversed(path[i:j+1]) improved = True n = len(path) # 更新路径长度 total_dist = sum(distance[path[i]][path[i+1]] for i in range(len(path)-1)) return path, total_dist # 使用示例（假设已有初始路径） # 改进贪婪算法结果 distance_matrix = [[euclidean_distance(coords[i], coords[j]) for j in range(29)] for i in range(29)] improved_path, improved_dist = two_opt(path, distance_matrix) print("2-Opt改进后路径:", improved_path) print("改进后距离:", improved_dist) ``` --- ### **二、思考题解答** #### **(1) TSP消除子回路的约束解释** 在TSP的整数规划模型中，子回路消除约束的核心是防止路径分裂为多个不连通的环。常用方法包括： - **DFJ约束**：对任意非空真子集$S \subset V$，要求进入和离开$S$的边数至少为2： $$\sum_{i \in S, j \notin S} x_{ij} \geq 2$$ - **MTZ约束**：引入辅助变量$u_i$，若路径中$i$在$j$之前，则： $$u_i - u_j + n \cdot x_{ij} \leq n-1 \quad \forall i,j \neq 0$$ 确保路径顺序唯一。 --- #### **(2) 动态规划实现TSP** **Held-Karp算法**利用状态压缩，时间复杂度为$O(n^2 2^n)$，对$n=29$需优化存储。 **Python代码**： ```python from functools import lru_cache def held_karp(coords): n = len(coords) distance = [[euclidean_distance(coords[i], coords[j]) for j in range(n)] for i in range(n)] @lru_cache(maxsize=None) def dp(mask, pos): if mask == (1 << n) - 1: return distance[pos][0] # 返回起点 min_dist = float(&#39;inf&#39;) for city in range(n): if not (mask & (1 << city)): new_mask = mask | (1 << city) d = distance[pos][city] + dp(new_mask, city) if d < min_dist: min_dist = d return min_dist return dp(1, 0) # 从起点0出发，已访问城市0 # 使用示例（注：n=29时需极大内存和计算时间） # total_dist = held_karp(coords) ``` --- ### **三、总结** - **贪婪算法**和**最邻近插入**属于启发式算法，速度快但可能非最优。 - **2-Opt**可局部优化结果，显著减少路径长度。 - **动态规划**精确但受限于规模，$n=29$时需高性能计算资源。 - **消除子回路**的约束确保单一环路，是TSP建模的关键。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值