問題描述

給定一個n頂點網路（有向或無向），找出一個包含n個頂點且具有最小耗費的換路。任何一個包含網路所有頂點的換路稱為一個旅行。旅行商問題（Traveling Salesman Problem，TSP）是要尋找一條耗費最少的旅行。

               

                              圖1 四頂點網路

如圖1是一個四頂點無向網路。這個網路的一些旅行：1,2,4,3,1；1,3,2,4,1和1,4,3,2,1。旅行1,2,4,3,1的耗費為66,；旅行1,3,2,4,1的耗費為25；旅行1,4,3,2,1的耗費為55.故1,3,2,4,1是網路中耗費最少的旅行。

演算法設計

和回溯法解決TSP問題一樣，首先確定問題的解空間是一個排列樹，從頂點1出發最後回到頂點1，所以排列可以表示為[1,x2,…,xn,1]。和子集樹一樣，使用一個優先順序佇列求解。要求旅行的耗費最小，故使用小根堆儲存活動節點，堆中每個活動節點的子樹耗費所能取得的下界lowerCost 是優先順序佇列的優先順序，即當前節點確定的途徑下繼續完成排列能取得最低耗費（並不一定保證能最終達到這個值）。

每個活動節點是小根堆的一個元素，元素結構包括：

lowerCost;      //當前節點往後排列，整個迴路所能取得的總耗費的下限 

currentCost;     //從根到當前節點的當前排列的耗費 

restMinCost;     //從當前節點到最後一個節點，每個節點的最小出邊的耗費之和 

s;               //從根節點到當前節點的路徑為[0:s] 

currentTour[];   //從根節點到當前節點的路徑(排列)

如何獲得lowerCost：
對於每個活動節點，可知當前耗費currentCost，對於剩餘的頂點，計算每個頂點的最小出邊之和restMinCost即為剩餘路徑的最小耗費的下界，lowerCost=currentCost + restMinCost。

演算法步驟

1、準備工作：建立小根堆，用於儲存活動節點。計算每個頂點的最小出邊，若存在某個頂點沒有出邊，則演算法終止。初始化樹根（頂點1）為第一個活動節點。 

2、判斷節點是否是葉結點的父節點：是的話，則檢查是否一定有最低耗費，若是加入小根堆； 

3、不是葉結點的父節點，則生成子節點，並判斷子節點是否有可能取得最低耗費，若可能則加入小根堆； 

4、取出下一個節點作為活動節點，若該節點已經是葉結點，返回當前最低耗費值，即為最優旅行。若不是葉結點則迴圈2、3步。

 

                              圖2  四頂點網路的解空間樹 

小根堆中的元素變化：{}——>{C,D,E}——>{C,D,K,J}——>{C,K,J,H,I}——>{C,K,J,I,N}——>{C,K,I,N}——>{C,K,I}

最後取出活動節點N，但是N已經是葉結點，故返回最優值25，和最佳途徑1->3->2->4->1,並終止演算法。

事實上，檢查節點J的子節點P時執行的是步驟2，也能得到最優值25，但是由於N已經加入小根堆，並且當前最優值已經是25，所以P沒有加入小根堆，途徑1->4->2->3->1也就被排除了。

需要注意的是，對於以下的C++程式，需要手動釋放掉每個活動節點的資料成員currentTour陣列的內寸，包括最後小根堆中剩餘的節點。

C++實現

小根堆minHeap元素結構

#pragma once
struct heapNode
{
    int lowerCost;      //當前節點往後排列，整個迴路所能取得的總耗費的下限
    int currentCost;    //從根到當前節點的當前排列的耗費
    int restMinCost;    //從當前節點到最後一個節點，每個節點的最小出邊的耗費之和
    int s;              //從根節點到當前節點的路徑為[0:s]
    int *currentTour;   //從根節點到當前節點的路徑(排列)

    //算術運算時的型別轉換
    operator int() { return lowerCost; }

    //過載大於號運算子，用於小根堆比較
    bool operator>(const heapNode &right)
    {
        return lowerCost > right.lowerCost;
    }
};

小根堆minHeap 部分原始碼

#pragma once
#include<iostream>
#include <algorithm>

using namespace std;

template<class T>
void changeLength1D(T*& a, int oldLength, int newLength)
{
    if (newLength < 0)
    {
        cout << "new length must be >= 0" << endl;
        exit(1);
    }

    T* temp = new T[newLength];              // new array
    int number = min(oldLength, newLength);  // number to copy
    copy(a, a + number, temp);
    delete[] a;                             // deallocate old memory
    a = temp;
}

template<class T>
class minHeap 
{
public:
    minHeap(int initialCapacity = 10);
    ~minHeap() { delete[] heap; }
    bool empty() const { return heapSize == 0; }
    int size() const
    {
        return heapSize;
    }
    const T& top()
    {// return min element
        if (heapSize == 0)
            exit(1);
        return heap[1];
    }
    void pop();
    void push(const T&);
    void initialize(T *, int);
    void deactivateArray()
    {
        heap = NULL; arrayLength = heapSize = 0;
    }
    void output(ostream& out) const;
private:
    int heapSize;       // number of elements in queue
    int arrayLength;    // queue capacity + 1
    T *heap;            // element array
};

template<class T>
minHeap<T>::minHeap(int initialCapacity)
{// Constructor.
    if (initialCapacity < 1)
    {
        cout << "Initial capacity = " << initialCapacity << " Must be > 0";
        exit(1);
    }
    arrayLength = initialCapacity + 1;
    heap = new T[arrayLength];
    heapSize = 0;
}

template<class T>
void minHeap<T>::push(const T& theElement)
{// Add theElement to heap.

 // increase array length if necessary
    if (heapSize == arrayLength - 1)
    {// double array length
        changeLength1D(heap, arrayLength, 2 * arrayLength);
        arrayLength *= 2;
    }

    // find place for theElement
    // currentNode starts at new leaf and moves up tree
    int currentNode = ++heapSize;
    while (currentNode != 1 && heap[currentNode / 2] > theElement)
    {
        // cannot put theElement in heap[currentNode]
        heap[currentNode] = heap[currentNode / 2]; // move element down
        currentNode /= 2;                          // move to parent
    }

    heap[currentNode] = theElement;
}

template<class T>
void minHeap<T>::pop()
{// Remove max element.
 // if heap is empty return null
    if (heapSize == 0)   // heap empty
    {
        cout << "heap is empty!" << endl;
        exit(1);
    }

    // Delete min element
    heap[1].~T();

    // Remove last element and reheapify
    T lastElement = heap[heapSize--];

    // find place for lastElement starting at root
    int currentNode = 1,
        child = 2;     // child of currentNode
    while (child <= heapSize)
    {
        // heap[child] should be smaller child of currentNode
        if (child < heapSize && heap[child] > heap[child + 1])
            child++;

        // can we put lastElement in heap[currentNode]?
        if (lastElement <= heap[child])
            break;   // yes

                     // no
        heap[currentNode] = heap[child]; // move child up
        currentNode = child;             // move down a level
        child *= 2;
    }
    heap[currentNode] = lastElement;
}

TSP演算法程式

#include<iterator>
#include"heapNode.h"
#include"minHeap.h"
#define N 5

//全域性變數
int n = N - 1;
int cost[N][N];  //cost[1:n][1:n] 表示城市之間的旅行耗費，不存在路徑則耗費等於-1
int bestTour[N];

int TSP(int *bestTour)
{//最小費用分支定界程式碼，尋找最短旅行
 //bestTour[1:n]儲存最短旅行路徑

    minHeap<heapNode> liveNodeMinHeap;

    //costOfMinOutEdge[i]表示頂點i的最小出邊
    int *minCostOutEdge = new int[n + 1];
    int sumOfMinCostOutEdges = 0;
    for (int i = 1; i <= n; ++i)
    {
        int minCost = -1;
        for (int j = 1; j <= n; ++j)
            if (cost[i][j] != -1 && (minCost == -1 || minCost > cost[i][j]))
                minCost = cost[i][j];
        if (minCost == -1)
            return -1;
        minCostOutEdge[i] = minCost;
        sumOfMinCostOutEdges += minCost;
    }

    //初始E-節點的根
    heapNode eNode;
    eNode.lowerCost = sumOfMinCostOutEdges;
    eNode.currentCost = 0;
    eNode.restMinCost = sumOfMinCostOutEdges;
    eNode.s = 0;
    eNode.currentTour = new int[n];
    //初始化排列為[1,2,3,...,n,1]
    for (int i = 0; i < n; ++i)
        eNode.currentTour[i] = i + 1;

    int bestCostSoFar = -1;  //當前最佳旅行耗費
    int *currentTour = eNode.currentTour;

    //搜尋排列樹
    while (eNode.s < n - 1)
    {
        currentTour = eNode.currentTour;
        if (eNode.s == n - 2)
        {//葉結點的父節點
         //檢查是否為當前最優旅行
            if (cost[currentTour[n - 2]][currentTour[n - 1]] != -1 &&
                cost[currentTour[n - 1]][1] != -1 &&
                (bestCostSoFar == -1 || eNode.currentCost +
                    cost[currentTour[n - 2]][currentTour[n - 1]] +
                    cost[currentTour[n - 1]][1] < bestCostSoFar))
            {//發現最優旅行，加入小根堆
                bestCostSoFar = eNode.currentCost +
                    cost[currentTour[n - 2]][currentTour[n - 1]] +
                    cost[currentTour[n - 1]][1];
                eNode.currentCost = bestCostSoFar;
                eNode.lowerCost = bestCostSoFar;
                eNode.s++;
                liveNodeMinHeap.push(eNode);
            }
            else
            {
                delete[] eNode.currentTour;  //捨棄非最優的葉結點的父節點，釋放記憶體
                eNode.currentTour = nullptr;
            }
        }

        else
        {//生成子節點
            for(int i = eNode.s + 1; i < n; ++i)
                if (cost[currentTour[eNode.s]][currentTour[i]] != -1)
                {//子節點可行
                    int currentCost = eNode.currentCost +
                        cost[currentTour[eNode.s]][currentTour[i]];
                    int restMinCost = eNode.restMinCost -
                        minCostOutEdge[currentTour[eNode.s]];
                    int leastCostPossible = currentCost + restMinCost;

                    if (bestCostSoFar == -1 ||
                        leastCostPossible < bestCostSoFar)
                    {//子樹可能有更優的葉結點，把當前子樹的根放入小根堆
                        heapNode hNode;
                        hNode.lowerCost = leastCostPossible;
                        hNode.currentCost = currentCost;
                        hNode.restMinCost = restMinCost;
                        hNode.s = eNode.s + 1;
                        hNode.currentTour = new int[n];
                        copy(currentTour, currentTour + n, hNode.currentTour);

                        swap(hNode.currentTour[hNode.s], hNode.currentTour[i]);
                        liveNodeMinHeap.push(hNode);
                    }
                }

            //完成節點擴充套件，釋放記憶體
            delete[] eNode.currentTour;
            eNode.currentTour = nullptr;
        }

        if (liveNodeMinHeap.empty())
            break;

        //取下一個E-節點
        eNode = liveNodeMinHeap.top();
        liveNodeMinHeap.pop();
    }

    if (bestCostSoFar == -1)
        return -1;

    //複製到bestTour
    copy(eNode.currentTour, eNode.currentTour + n, bestTour + 1);

    //釋放小根堆中剩餘元素的currentTour陣列記憶體***雖然小根堆析構，
    //但是currentTour是new的記憶體，依然存在，故必須手動釋放
    while (true)
    {
        delete[] eNode.currentTour;
        if (liveNodeMinHeap.empty())
            break;
        //取下一個E-節點
        eNode = liveNodeMinHeap.top();
        liveNodeMinHeap.pop();
    }

    return bestCostSoFar;
}

void init()
{
    cost[1][1] = -1;
    cost[1][2] = 30;
    cost[1][3] = 6;
    cost[1][4] = 4;

    cost[2][1] = 30;
    cost[2][2] = -1;
    cost[2][3] = 5;
    cost[2][4] = 10;

    cost[3][1] = 6;
    cost[3][2] = 5;
    cost[3][3] = -1;
    cost[3][4] = 20;

    cost[4][1] = 4;
    cost[4][2] = 10;
    cost[4][3] = 20;
    cost[4][4] = -1;
}
void main()
{
    init();

    int bestCost = TSP(bestTour);  //起點定為1，從第二層開始  

    cout << "最少的運費為:" << bestCost << endl;
    cout << "最佳路徑為: ";

    copy(bestTour + 1, bestTour + n + 1, ostream_iterator<int>(cout, "->"));
    cout << bestTour[1] << endl;
}

測試結果

最少的運費為:25
最佳路徑為: 1->3->2->4->1
請按任意鍵繼續. . .