python實現回溯法與分支限界

一、開發環境

開發工具：jupyter notebook 並使用vscode，cmd命令列工具協助程式設計測試演算法,並使用codeblocks輔助編寫C++程式
程式語言：python3.6

二、實驗目標

1． 請用回溯法求對稱的旅行商問題（TSP問題）

2． 請用分支限界法求對稱的旅行商問題（TSP問題）

三、實驗內容

旅行商問題的簡單說明：

旅行商問題（TSP問題）是一個經典的組合優化問題。經典TSP問題可以描述為：一個商品推銷員要去若干個城市推銷商品，該推銷員從一個城市出發，需要經過所有城市後，回到出發地。應如何選擇行進路線，以使總的行程最短

從圖論角度看：

該問題實質是在一個帶權完全無向圖中，找一個權值最小的Hamilton迴路。由於該問題的可行解是所有頂點的全排列，隨著頂點數的增加，會產生組合爆炸，它是一個NP完全問題。

TSP的數學模型為：

使用的測試資料：

使用字典的形式表示：

# 定義圖的字典形式
G = {
    '1': {'2': 30, '3': 6, '4': 4},
    '2': {'1': 30, '3': 5, '4': 10},
    '3': {'1': 6, '2': 5, '4': 20},
    '4': {'1': 4, '2': 10, '3': 20}
}

使用資料的形式表示：

# 定義圖的陣列形式
graph = [
    [0, 30, 6, 4],
    [30, 0, 5, 10],
    [6, 5, 0 , 20],
    [4, 10, 20, 0]
]

（一）使用回溯法求解旅行商（TSP）問題

回溯法的概念：

回溯演算法實際上一個類似列舉的搜尋嘗試過程，主要是在搜尋嘗試過程中尋找問題的解，當發現已不滿足求解條件時，就“回溯”返回，嘗試別的路徑。

回溯法是一種選優搜尋法，按選優條件向前搜尋，以達到目標。但當探索到某一步時，發現原先選擇並不優或達不到目標，就退回一步重新選擇，這種走不通就退回再走的技術為回溯法，而滿足回溯條件的某個狀態的點稱為“回溯點”。

許多複雜的，規模較大的問題都可以使用回溯法，有“通用解題方法”的美稱。

在我看來，回溯法有點像圖遍歷中的深度優先演算法，不過多了剪枝這一過程，當發現現有的解的值大於最優解的時候，就不再深入遍歷下去，演算法的效能取決於剪枝的多少。

下面給出回溯法的程式碼：

# 回溯法求解旅行商問題
import math
n = 4
x = [0, 1, 2, 3]
# 定義圖的字典形式
G = {
    '1': {'2': 30, '3': 6, '4': 4},
    '2': {'1': 30, '3': 5, '4': 10},
    '3': {'1': 6, '2': 5, '4': 20},
    '4': {'1': 4, '2': 10, '3': 20}
}
# 定義圖的陣列形式
graph = [
    [0, 30, 6, 4],
    [30, 0, 5, 10],
    [6, 5, 0 , 20],
    [4, 10, 20, 0]
]
bestway = ''
# bestcost = 1<<32 # 這裡只要是一個很大數就行了 無窮其實也可以
bestcost = math.inf # 好吧 乾脆就無窮好了
nowcost = 0    # 全域性變數，現在的花費

def TSP(graph, n, s):
    global nowcost, bestcost
    if(s == n):
        if (graph[x[n-1]][x[0]] != 0 and (nowcost +graph[x[n-1]][x[0]]<bestcost)):
            print('best way:', x)
            bestcost = nowcost + graph[x[n-1]][x[0]]
            print('bestcost', bestcost)
            
    else:
        for i in range(s, n):
            
            # 如果下一節點不是自身 而且 求得的值小於目前的最佳值
            if (graph[x[i-1]][x[i]] != 0 and nowcost+graph[x[i-1]][i] < bestcost):
                x[i], x[s] = x[s], x[i]    # 交換一下

                nowcost += graph[x[s - 1]][x[s]]    # 將花費加入
                TSP(graph, n, s+1)
                nowcost -= graph[x[s - 1]][x[s]]    # 回溯上去還需要減去
                
                x[i], x[s] = x[s], x[i]    # 別忘記交換回來
    
TSP(graph, n, 1)

執行的結果為：

一共輸出了兩個結果，說明完整路徑搜尋了兩次，其餘情況下，均在搜尋到中途的時候進行了剪枝操作。

（二）使用分支限界法求解旅行商（TSP）問題

分支限界法概念：

回溯法的求解目標是找出T中滿足約束條件的所有解，而分支限界法的求解目標則是找出滿足約束條件的一個解，或是在滿足約束條件的解中找出使某一目標函式值達到極大或極小的解，即在某種意義下的最優解。

我覺得分支限界法像圖的廣度遍歷，從上往下進行層級的遍歷，一步一步直到最終找到解，不過，不同的地方在於，分支限界法採用了優先佇列的方式進行了優化，首先找尋可能滿足目標函式的解，再利用剪枝進行了優化處理

寫演算法的時候，利用上面這張圖，進行了自定義節點類的構造和編寫，並利用優先佇列儲存各個節點，程式碼量大大減少，不同過存在的問題是，如果不是一個完全圖進行輸入，結果會報錯，沒有做到很好的容差性與健壯性，同時新生成的物件太多了，會佔用很大的空間，不過及時的刪除節點將會解決這一問題。

分支限界法的程式碼如下：

# 分支限界法求解旅行商問題
import math
from heapq import *

n=4
x = [1, 2, 3, 4]
# 定義圖的字典形式
G = {
    '1': {'2': 30, '3': 6, '4': 4},
    '2': {'1': 30, '3': 5, '4': 10},
    '3': {'1': 6, '2': 5, '4': 20},
    '4': {'1': 4, '2': 10, '3': 20}
}
# 定義圖的陣列形式
graph = [
    [0, 30, 6, 4],
    [30, 0, 5, 10],
    [6, 5, 0 , 20],
    [4, 10, 20, 0]
]
bestway = ''
# bestcost = 1<<32 # 這裡只要是一個很大數就行了 無窮其實也可以
bestcost = math.inf # 好吧 乾脆就無窮好了
nowcost = 0    # 全域性變數，現在的花費

# 設定節點類
class Node:
    # 建構函式，現在的花費，到目前的路徑
    def __init__(self, w=math.inf, route=[], cost=0):
        self.weight = w
        self.route = route
        self.cost = cost
        
    # 過載比較，用於堆的排序
    def __lt__(self,other):
        return int(self.weight) < int(other.weight)
    
    # 列印
    def __str__(self):
        return "節點的權重為"+str(self.weight)+" 節點的路徑為"+str(self.route)+" 花費為"+str(self.cost)
        

def BBTSP(graph, n, s):
    global bestcost, bestroute
    heap = []
    
    start = Node(route=[str(s)])
    
    heap.append(start)
    
    # 當堆中有數的時候，迴圈繼續
    while heap:
        nownode = heappop(heap)    # 取出權重最大的那個數
        # 生成權重最大的那個數的下結點，並且把下結點加入堆中
        for e in [r for r in graph if r not in nownode.route]:
            node = Node(w=graph[nownode.route[-1]][e], route=nownode.route+[e], cost=nownode.cost+graph[nownode.route[-1]][e])
            # 如果現在的值大於最優值，剪枝操作
            if node.cost >= bestcost:
                continue
            # 如果到了最後一個點，加上回去的路，並計算最小值
            if len(node.route)==4:
                wholecost = graph[node.route[-1]][s]+node.cost
                if wholecost < bestcost:
                    bestcost = wholecost
                    bestroute = node.route
                    print("最佳花費為:"+str(bestcost))
                    print("最佳路徑為:"+str(bestroute))
                    
            heap.append(node)

        
    return bestcost
        
    
BBTSP(G, n, '1')

實驗結果的如下所示：

結果只是恰好與上面一樣，但是其實裡面內部的機制是完全不一樣的，為什麼使用優先佇列進行優化還是會出現這樣的結果呢？我自己分析了一下，發現優先佇列使用的步驟只是找到三個節點，而從最後一個節點到第一個節點是沒有考慮在內的，所以會出現前面最優而總體結果並不是最優的情況。