模拟退火算法解决旅行商问题_SA_TSP

关于模拟退火算法，这篇博文写的通俗易懂，戳http://www.cnblogs.com/heaad/archive/2010/12/20/1911614.html

自己也是看了这篇才看懂这个SimulatedAnnealing.

然后自己参考着别人的代码也实现了一番，数据仍然是前面遗传算法里的city.txt.

代码如下：

#ifndef SA_TSP_H_
#define SA_TSP_H_ 
#include <iostream>
#include <vector>
#include <string>
#define CITIES 99
#define INITAL_TEMP 1000
#define MIN_TEMP 10

struct city{
    int id;
    int x;
    int y;
};

struct unit{
    double length;
    std::vector<int> path;
    bool operator<(const struct unit &other) const
    {
        return length < other.length;
    }
};

class SA_TSP
{
    public:
        SA_TSP();
        void initMatrix(const std::string &filename);
        void initBestUnit();
        double lenOfUnit(unit &);
        void genNewUnit(unit &u);
        void simulateAnnealing();
        bool isAccept(unit &, unit &);
        void printBestUnit();
        ~SA_TSP() {}
    private:
        unit bestUnit_;
        double speed_;
        int markov_;
        double currentTemp_;
};

#endif  /*SA_TSP_H_*/

#include "SA_TSP.h"
#include <iostream>
#include <string>
#include <vector>
#include <time.h>
#include <math.h>
#include <algorithm>
#include <fstream>
using namespace std;

city cities[CITIES];
double cityMatrix[CITIES][CITIES];

SA_TSP::SA_TSP()
    :markov_(10000), speed_(0.98), currentTemp_(INITAL_TEMP)
{
}

void SA_TSP::initBestUnit()
{
    for(int i = 1; i < CITIES + 1; ++i)
    {
        bestUnit_.path.push_back(i);
    }
    random_shuffle(bestUnit_.path.begin(), bestUnit_.path.end());
    /* 虽然调用了random_shuffle，
     * 但是每次程序开始时第一次shuffle出来的序列都是一样的
     */

    /* for(auto &item: bestUnit_.path){
            cout << item << " ";
    }
    cout << endl;

    bestUnit_.length = lenOfUnit(bestUnit_);
    cout << bestUnit_.length << endl;
    */
}


void SA_TSP::initMatrix(const string &filename)
{
    int i, j;
    ifstream in(filename);
    for(i = 0; i < CITIES; ++i)
    {
        in >> cities[i].id >> cities[i].x >> cities[j].y;
    }
    for(i = 0; i < CITIES; ++i)
    {
        cityMatrix[i][i] = 0;
        for(j = i + 1; j < CITIES; ++j)
        {
            cityMatrix[i][j] = sqrt((cities[i].x - cities[j].x) * (cities[i].x - cities[j].x) + (cities[i].y - cities[j].y) * (cities[i].y - cities[j].y));
            cityMatrix[j][i] = cityMatrix[i][j];
        }
    }
}


double SA_TSP::lenOfUnit(unit &u)
{
    u.length = 0;
    for(int j = 0; j < CITIES-1; ++j)
    {
        u.length += cityMatrix[u.path[j]][u.path[j+1]];
    }
    u.length += cityMatrix[u.path[CITIES-1]][u.path[0]];

    return u.length;
}


bool SA_TSP::isAccept(unit &best_unit, unit &tmp_unit)
{
    if(best_unit.length > tmp_unit.length)
        return true;
    else
    {
        /*产生0-1之间的随机数用 double(RAND_MAX) */
        double temper = exp((best_unit.length - tmp_unit.length) / (double)currentTemp_);
        double randtemper = rand()/double(RAND_MAX);
        if(temper > randtemper)//必须是'>', 因为temper会越来越小,导致条件越来越不满足，从而趋于稳定
            return true;
    }
    return false;
}

void SA_TSP::genNewUnit(unit &u)
{
/* srand(time(NULL)); 在调用genNewUnit()的外部使用，
 * 否则每次调用都会初始化一次，这样每次都相同了，包括下面的choice也是一样
 * 这与前面的shuffle同理
 */
    int pos1 = rand() % CITIES;
    int pos2 = rand() % CITIES;

    auto ptr = u.path.begin();
    //ensure pos1 != pos2
    while(pos1 == pos2)
        pos2 = rand() % CITIES;
    if(pos1 > pos2)
            swap(pos1, pos2);

    int choice = rand() % 3;
    if(choice == 0) //swap
    {
        //ensure pos1 < pos2
        swap(u.path[pos1], u.path[pos2]);
    }else if(choice == 1) //reverse
    {
        reverse(ptr + pos1, ptr + pos2);
    }else{//rightrotate
        rotate(ptr + pos1, ptr + pos2, ptr + pos2 + 1);
    }

    u.length = lenOfUnit(u);
}

void copy(unit &u1, unit &u2)
{
    u1.path = u2.path;
    u1.length = u2.length;
}

void SA_TSP::simulateAnnealing()
{
    unit tmp_unit;
    copy(tmp_unit, bestUnit_);
    srand(time(NULL)); 
    while(currentTemp_ > MIN_TEMP)
    {
        for(int i = 0; i < markov_; ++i)
        {
            genNewUnit(tmp_unit);
            if(isAccept(bestUnit_, tmp_unit))
            {
                copy(bestUnit_, tmp_unit);
            }
        }
        currentTemp_ *= speed_;
    }
}

void SA_TSP::printBestUnit()
{
    cout << "best path: ";
    for(vector<int>::iterator it = bestUnit_.path.begin(); it != bestUnit_.path.end(); ++it){
        cout << *it << " ";    
    }
    cout << endl << "best_length: " << bestUnit_.length << endl;;
}

#include "SA_TSP.h"
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(int argc, const char *argv[])
{
    SA_TSP saTsp;
    saTsp.initMatrix("city.txt");
    saTsp.initBestUnit();
    saTsp.simulateAnnealing();
    saTsp.printBestUnit();
    return 0;
}

之前说了这组数据最小的代价是1100+，而我实现的代码怎么搞，最小代价都是2200+。这些应该跟参数的设定和产生新路径的方法有关。

Tips:

虽然我在程序初始化时候用了random_shuffle()来打乱顺序，可是我每次开始执行的时候，path都会被shuffle成同样的序列，只有在程序中再次调用的时候shuffle才会随机改变path。

同理，还有srand(),rand()，第一次调用时候的值都是一样的，只有在程序中多次rand()才会不停的产生随机数。还有时间种子srand()只要调用一次就好，或者你下次给定的种子与之前不同也行。但是不要放在循环体，或者一个会被多次调用的函数里，否则每次调用都被初始化为相同的值了，那么接下来的rand()又会重复上一次的老路了！

这代码肯定还有待优化的地方！