前言

斷斷續續學遺傳到現在快一個禮拜了，之前一直在看思想，死想活想，始終不敢去自己程式碼實現。
今天硬著頭皮開始寫，寫不下去就找博文看，總算是初步的實現了，邁出了智慧演算法學習的第一小步，心情不可謂不激動。
好吧，說正經的。

tsp&旅行商問題

旅行商問題，即TSP問題（Traveling Salesman Problem）是數學領域中著名問題之一。
假設有一個旅行商人要拜訪N個城市，他必須選擇所要走的路徑，路徑的限制是每個城市只能拜訪一次，而且最後要回到原來出發的城市。
路徑的選擇目標是要求得的路徑路程為所有路徑之中的最小值。

遺傳演算法

演算法思想

從遺傳兩個字，不難想到，這個演算法是由生物進化的機理所抽象出來的一種思想。
對於一個問題，有許多可能的解。
就拿上述的tsp問題來說吧，每一種遍歷順序都是一個解。所有城市順序的全排列合在一起就是這個問題的解集。
我們將每個解都看做一個個體。那麼多個個體放在一起就可以構成一個種群。
大自然每個種群都要經過漫長的自然選擇，也就是優勝劣汰，以及繁殖和變異。
而解所構成的種群也不例外。
顯然，我們可以很明確的對每個個體的優劣性進行評價。本體的條件是總路程最短，根據解得到總路程的大小是很容易的。
評價過後，對於每個個體的優劣我們都已掌握。
那麼殘酷的地方來了，我們要殺死(淘汰)

一部分個體。
當然也不能光殺，溫馨的部分也是有的，那就是兩兩個體交叉繁殖，產生後代。
除此之外，還要有一點幸運度，那就是變異了，隨機的對某些個體進行一些改變。
上述操作進行完之後，我們已經相當於更新了整個群體。
然後重複的進行此過程，直到得到滿意的(個體)結果。

上述內容總結一下，就是下圖。

交叉方式與變異方式

交叉方式有很多種，對於不同的問題，交叉方式的不同對於求解會有一定的影響。
變異同理。
這裡只介紹我所用的方式。其實也是最普通最常用的方式。

交叉方式

父個體：1 2 3 4 9 8 7 6 5 0
母個體：7 8 9 0 1 6 5 4 3 2
那麼隨機取兩個值，比如：4和6
將父個體劃分：1 2 3 [4 9] 8 7 6 5 0
則，將劃分區間內的基因賦給子個體
子個體：x x x 4 9 x x x x x
再按照母個體的基因順序賦值給子個體
子個體：7 8 0 4 9 1 6 5 3 2
 

變異方式

個體：  1 2 3 4 9 8 7 6 5 0
還是隨機選取兩個值，比如：4和6
那麼，交換位置4和位置6的基因。
新個體：1 2 3 8 9 4 7 6 5 0 

程式效果

可以看到，20次求解有14次得到了最優解，在犧牲了一定最優性的情況下，換取了程式快速得解的能力。

不足

因為是第一次寫，交叉和變異都用了最常用也是最簡單的方式。
對於同一個問題，使用不同的交叉方式和變異方式，效果會有很大不同。還有種群個體數量以及進化迭代次數，變異概率等等引數的不同取值，都會有影響。
而這些只有不停的實踐，才可以真正掌握一定經驗。長路漫漫，吾往矣！

程式碼

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

using namespace std;

const int city_num = 10;//城市數量
const int unit_num = 100;//群體規模
int ps = 10;//變異概率
const int genmax = 500;//最大迭代數

//城市間距離對映 最優解權值=10
int length_table[10][10] = {

    {0,1,1272,2567,1653,2097,1425,1177,3947,1},

    {1,0,1,2511,1633,2077,1369,1157,3961,1518},

    {1272,1,0,1,380,1490,821,856,3660,385},

    {2567,2511,1,0,1,2335,1562,2165,3995,933},

    {1653,1633,380,1,0,1,1041,1135,3870,456},

    {2097,2077,1490,2335,1,0,1,920,2170,1920},

    {1425,1369,821,1562,1041,1,0,1,4290,626},

    {1177,1157,856,2165,1135,920,1,0,1,1290},

    {3947,3961,3660,3995,3870,2170,4290,1,0,1},

    {1,1518,385,993,456,1920,626,1290,1,0}
};

class Unit
{
public:
    int path[city_num];//個體的路徑資訊
    int length;//個體價值
};

class Group
{
public:
    Unit group[unit_num];
    Unit best;
    int best_gen;

    Group()
    {
        best.length = 0x3f3f3f3f;
        best_gen = 0;
        for(int i = 0; i < unit_num; i++)
        {
            bool flag[city_num] = {};

            for(int j = 0; j < city_num; j++)
            {
                int t_city = rand()%city_num;
                while(flag[t_city])
                    t_city = rand()%city_num;
                flag[t_city] = true;
                group[i].path[j] = t_city;
            }
        }
    }

    //對每個個體進行評估
    void assess()
    {
        for(int k = 0; k < unit_num; k++)
        {
            int rel = 0;
            for(int i = 1; i < city_num; i++)
                rel += length_table[group[k].path[i-1]][group[k].path[i]];
            rel += length_table[group[k].path[city_num-1]][group[k].path[0]];
            group[k].length = rel;
        }
    }

    //根據評估結果對個體進行排序
    void unit_sort()
    {
        for(int i = 0; i < unit_num; i++)
        {
            for(int j = i+1; j < unit_num; j++)
            {
                if(group[i].length > group[j].length)
                {
                    Unit temp;
                    memcpy(&temp, &group[i], sizeof(Unit));
                    memcpy(&group[i], &group[j], sizeof(Unit));
                    memcpy(&group[j], &temp, sizeof(Unit));
                }
            }
        }
    }

    //交叉
    Unit cross(Unit &father, Unit &mother)
    {
        int l = rand()%city_num;
        int r = rand()%city_num;
        if(l > r)
            swap(l, r);

        bool flag[city_num] = {};
        for(int i = l; i <= r; i++)
            flag[father.path[i]] = true;

        Unit son;
        int pos = 0;

        for(int i = 0; i < l; i++)
        {
            while(flag[mother.path[pos]])
                pos++;
            son.path[i] = mother.path[pos++];
        }
        for(int i = l; i <= r; i++)
            son.path[i] = father.path[i];
        for(int i = r+1; i < city_num; i++)
        {
            while(flag[mother.path[pos]])
                pos++;
            son.path[i] = mother.path[pos++];
        }

        return son;
    }

    //突變
    void mutation(Unit &t)
    {
        int proport = rand() % 100;

        if(proport > ps)
            return;
        int one = rand()%city_num;
        int two = rand()%city_num;
        while(two != one)
            two = rand()%city_num;
        swap(t.path[one], t.path[two]);
    }

    //輸出資訊
    void print()
    {
        for(int i = 0; i < unit_num; i++)
        {
            printf("第%d個個體，路徑資訊：", i);
            for(int j = 0; j < city_num; j++)
                printf("%d ", group[i].path[j]);

            printf(";總權值：%d;\n", group[i].length);
        }
        printf("最優個體，路徑資訊：");
        for(int j = 0; j < city_num; j++)
            printf("%d ", group[0].path[j]);

        printf(";總權值：%d;\n", group[0].length);
    }

    //種群進化
    void work()
    {
        for(int i = 0; i < genmax; i++)
        {
            //如果進化層數大於20，加大變異的概率
            if(i > 20)
                ps *= 3;

            assess();//評估

            unit_sort();//根據評估結果排序

            if(best.length > group[0].length)
            {
                memcpy(&best, &group[0], sizeof(group[0]));
                best_gen = i;
            }

            for(int j = 0; j+2 < unit_num; j+=3)
                group[j+2] = cross(group[j], group[j+1]);

            for(int j = 0; j < city_num; j++)//變異(從1開始，保留最優)
                mutation(group[j]);
        }
    }

};

Unit group[unit_num];//種群變數
Unit bestone;//記錄最短路徑
int generation_num;//記錄當前達到了第幾代



int main()
{
    srand((int)time(0));

    for(int i = 0; i < 20; i++)
    {
        Group g;
        g.work();
        printf("第%d次求解。路徑：", i+1);
        for(int j = 0; j < city_num; j++)
            printf("%d ", g.best.path[j]);

        printf(";總權值：%d; 第%d代;\n", g.best.length, g.best_gen);
    }
    return 0;
}