粒子群(PSO)解决TSP问题

粒子群算法也称粒子群优化算法，简称PSO(Partical Swarm Optimization)。
以下是求解TSP问题的源码：

#include <vector>
#include <time.h>
#include <stdlib.h>
#include <iostream>
#include <math.h>
#include <fstream>
using namespace std;
#define MAX_DIS 10000000
#define MAX_ARR 500
class PSO
{
public:
    PSO(int c, int pop,int g) :popsize(pop),cities(c),genMax(g) {}

    void InitialSwarm(int** a);
    void Move(int** a);
    void print();

    ~PSO();
private:
    typedef struct{
        int ei;
        int ej;
    }exchangeSeq;
    typedef struct{
        vector<int> sbest;
        int length;
    }seqlen;
    typedef struct{
        vector<int> idl;
        vector<exchangeSeq> velocity;
        seqlen pbest;
    }particle;
    int popsize;
    int cities;
    int genMax;
    seqlen gbest;
    vector<particle> particleSwarm;

    vector<int> BuildRandomSequence(int);
    int getPathLen(int** a,const vector<int>&);
    void computeNexPos(vector<int>&,vector<exchangeSeq>);
    void computeNewVelocity(particle&);
    vector<exchangeSeq> computeEquivalentSet(vector<exchangeSeq>, vector<exchangeSeq>);
    vector<exchangeSeq> BuildBasicExchangeSeq(vector<int>, vector<int>);
    void Movement(int** a);
};

PSO::~PSO()
{
}

//计算一条路径长度
int PSO::getPathLen(int** a,const vector<int>& seq)
{
    int path = 0;
    for (size_t pos = 1; pos < cities; pos++)
    {
        path += a[seq[pos - 1]][seq[pos]];
    }
    path += a[seq[0]][seq[cities - 1]];
    return path;
}


//生成等价集
vector<PSO::exchangeSeq> PSO::computeEquivalentSet(vector<PSO::exchangeSeq> sq1, vector<PSO::exchangeSeq> sq2)
{
    vector<int> seq1, seq2;
    for (size_t i = 0; i < cities; i++) seq1.push_back(i);
    seq2 = seq1;
    computeNexPos(seq1, sq1);
    computeNexPos(seq1, sq2);
    return BuildBasicExchangeSeq(seq2, seq1);
}


//生成基本交换序
vector<PSO::exchangeSeq> PSO::BuildBasicExchangeSeq(vector<int> seq1, vector<int> seq2)
{
    vector<exchangeSeq> Seq;
    vector<int> sq = seq2;
    int tp;
    exchangeSeq q;
    size_t i, j;
    for (i = 0; i < seq1.size()-1; i++)
    {
        for (j = i; j < seq1.size() && sq[j] != seq1[i]; j++);
        q.ei = i;
        q.ej = j;

        if (i == j) continue;
        tp = sq[i];
        sq[i] = sq[j];
        sq[j] = tp;
        Seq.push_back(q);
    }
    return Seq;
}

//根据当前解计算下一个解，也即下一个位置
void PSO::computeNexPos(vector<int>& idl, vector<exchangeSeq> v)
{
     int tp;
     for (size_t i = 0; i < v.size(); i++)
    {
        tp = idl[v[i].ei];
        idl[v[i].ei] = idl[v[i].ej];
        idl[v[i].ej] = tp;
    }
}

void PSO::computeNewVelocity(particle& pl)
{
    vector<exchangeSeq> Pid = BuildBasicExchangeSeq(pl.pbest.sbest, pl.idl);
    vector<exchangeSeq> Pgd = BuildBasicExchangeSeq(gbest.sbest, pl.idl);

    vector<exchangeSeq> tp = pl.velocity;
    tp = computeEquivalentSet(tp, Pid);
    pl.velocity = computeEquivalentSet(tp, Pgd);
}

//产生随机序列
vector<int> PSO::BuildRandomSequence(int len)
{
    vector<int> vc;
    int i;
    for (i = 0; i < len; i++)  vc.push_back(i);
    int x = 0, tmp = 0;
    for (i = len - 1; i > 0; i--) {
        x = rand() % (i + 1);
        tmp = vc[i];
        vc[i] = vc[x];
        vc[x] = tmp;
    }
    return vc;
}


//初始化粒子群
void PSO::InitialSwarm(int** a)
{
    int i, j,tp=0;
    particle pt;
    exchangeSeq exSeq;
    int shortlen = MAX_DIS;
    srand((unsigned)time(NULL));
    for (i = 0; i < popsize; i++)
    {
        pt.idl = BuildRandomSequence(cities);
        pt.pbest.sbest = pt.idl;
        pt.pbest.length = getPathLen(a, pt.pbest.sbest);

        for (j = 0; j<cities; j++)
        {
            exSeq.ei = rand() % cities;
            exSeq.ej = rand() % cities;
            pt.velocity.push_back(exSeq);
        }

        particleSwarm.push_back(pt);
        if (shortlen>pt.pbest.length)
        {
            shortlen = pt.pbest.length;
            tp = i;
        }
    }
    gbest = particleSwarm[tp].pbest;
}

void PSO::Movement(int** a)
{
    int tp=0;
    for (size_t i = 0; i < particleSwarm.size(); i++)
    {
        computeNexPos(particleSwarm[i].idl, particleSwarm[i].velocity);
        computeNewVelocity(particleSwarm[i]);
        if (particleSwarm[i].pbest.length > getPathLen(a, particleSwarm[i].idl))
        {
            particleSwarm[i].pbest.length = getPathLen(a, particleSwarm[i].idl);
            particleSwarm[i].pbest.sbest = particleSwarm[i].idl;
        }
        if (particleSwarm[i].pbest.length < gbest.length)
        {
            gbest.length = particleSwarm[i].pbest.length;
                tp = i;
        }
    }
    gbest.sbest = particleSwarm[tp].idl;
}

void PSO::Move(int** a)
{
    for (int i = 0; i < genMax; i++) Movement(a);
}
//打印结果，即最短距离和路径
void PSO::print()
{
    cout << "最短距离： " << gbest.length << endl;
    cout << "最短路径：";
    for (size_t i = 0; i < gbest.sbest.size(); i++) cout << gbest.sbest[i] << " ";
    cout << gbest.sbest[0]<<endl;
}
//created by chithon

以上给出了用粒子群优化算法解决TSP问题的基本代码，难点主要是粒子的速度如何表示，其变化过程怎样体现，这是难点，在此代码中涉及的处理方法主要参考：
黄 岚.粒子群优化算法求解旅行商问题.吉林大学学报.2003