遗传算法解决排序问题

遗传算法最重要的几个步骤

　1.编码。

　　一般可采用二进制编码。本题使用和tsp相同的符号编码（可使用一个数组保存）

　2.选择。根据个体的评分进行选择，涉及到累计概率。

　3.交叉。通过互换基因，从而产生新的个体。

　4.变异。产生新的个体。

#include <stdio.h>
#include <vector>
#include <time.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;

vector<vector<int>> population;
vector<int> best_body;
int min_pair = INT_MAX;//最小的逆序对

int scale;//种群规模
int arrNum;//基因个数

int MAX_ROUND;//循环次数
int mutation_times;

float crossover_p;//交叉概率
float mutation_p;//变异概率


//初始化
void init() {
    for (int i = 0; i < arrNum; ++i) {
        best_body.push_back(0);
    }
    srand(time(NULL));
    for (int i = 0; i < scale; ++i) {
        vector<int> temp;
        for (int j = 0; j < arrNum;) {
            int p = int(((double) rand() / RAND_MAX) * arrNum);
            if (find(temp.begin(), temp.end(), p) == temp.end()) {//不存在
                temp.push_back(p);
                ++j;
            }
        }
        population.push_back(temp);
    }

}


//逆序对
int reverse_order_pair(vector<int> &vec) {
    int sz = vec.size();
    int sm = 0;
    for (int i = 0; i < sz; ++i) {
        for (int j = i + 1; j < sz; ++j) {
            if (vec[i] > vec[j]) {
                ++sm;
            }
        }
    }
    return sm;
}


void copy(vector<int> &v1, vector<int> &v2) {
    for (int i = 0; i < arrNum; ++i) {
        v1[i] = v2[i];
    }
}

//计算评分 基于逆序对
vector<int> score(vector<vector<int>> &vec) {
    vector<int> res;
    int temp = INT_MAX;
    int index = 0;
    for (int i = 0; i < scale; ++i) {
        int pairs = reverse_order_pair(vec[i]);
        if (pairs < temp) {
            temp = pairs;
            index = i;
        }
        res.push_back(pairs);
    }

    if (temp < min_pair) {
        min_pair = temp;
        copy(best_body, vec[index]);
    }
    return res;
}

//计算积累概率
vector<double> cumulatePro(vector<int> &score) {
    vector<double> res(scale);
    double sm = 0;
    for (double p:score) {
        sm += 1 / (double) p;
    }
    res[0] = 1 / (double) score[0] / sm;

    for (int i = 1; i < scale; ++i) {
        res[i] = 1 / (double) score[i] / sm + res[i - 1];
    }
    return res;
}

//选择
vector<vector<int>> choose(vector<double> &cumPro) {
    vector<vector<int>> res;
    for (int i = 0; i < scale; ++i) {
        res.push_back(vector<int>(arrNum));
    }
    for (int i = 0; i < scale - 1; ++i) {
        double temp = (double) rand() / RAND_MAX;

        if (cumPro[0] >= temp) {
            copy(res[i], population[0]);
        } else {
            for (int j = 1; j < scale; ++j) {
                if (cumPro[j - 1] < temp && temp <= cumPro[j]) {
                    copy(res[i], population[j]);
                    break;
                }
            }
        }
    }
    copy(res[scale - 1], best_body);
    return res;
}


//交叉
//交替位置交叉法
void crossover(vector<int> &v1, vector<int> &v2) {
    vector<int> t1;
    vector<int> t2;
    int i = 0, j = 0;
    while (i < v1.size() || j < v2.size()) {
        if (find(t1.begin(), t1.end(), v1[i]) == t1.end()) {
            t1.push_back(v1[i]);
            ++i;
        } else if (i < v1.size()) {
            t2.push_back(v1[i]);
            ++i;
        }

        if (find(t1.begin(), t1.end(), v2[j]) == t1.end()) {
            t1.push_back(v2[j]);
            ++j;
        } else if (j < v2.size()) {
            t2.push_back(v2[j]);
            ++j;
        }
    }
    copy(v1, t1);
    copy(v2, t2);
}

//变异
void mutation(vector<int> &body) {
    srand(time(NULL));
    for (int i = 0; i < mutation_times; ++i) {
        int r1 = (int) ((double) rand() / RAND_MAX * arrNum);
        int r2 = (int) ((double) rand() / RAND_MAX * arrNum);
        while (r1 == r2) {
            r2 = (int) ((double) rand() / RAND_MAX * arrNum);
        }
        swap(body[r1], body[r2]);
    }
}


void crossAndMutation(vector<vector<int>> &newPop) {
    srand(time(NULL));
    for (int i = 0; i < scale - 1; i += 2) {
        float p1 = (float) rand() / RAND_MAX;
        if (p1 > crossover_p) {//交叉
            crossover(newPop[i], newPop[i + 1]);
        }
    }
    //变异
    for (int i = 0; i < scale; ++i) {
        float p1 = (float) rand() / RAND_MAX;
        if (p1 > mutation_p) {
            mutation(newPop[i]);
        }
    }
}

//修正 将上一代最优的替换新一代最差的
void fixUp(vector<vector<int>> &newPop) {
    int index = 0;
    int pairs = 0;
    for (int i = 0; i < scale; ++i) {
        if (reverse_order_pair(newPop[i]) > pairs) {
            pairs = reverse_order_pair(newPop[i]);
            index = i;
        }
    }
    copy(newPop[index], best_body);
}


int main() {
    scale = 50;//种群规模
    arrNum = 7;//基因个数
    MAX_ROUND = 100;//循环次数
    mutation_times = 4;//变异次数
    crossover_p = 0.6;//交叉概率
    mutation_p = 0.4;//变异概率
    init();
    for (int i = 0; i < MAX_ROUND; ++i) {
        vector<int> scoreVec = score(population);//评分
        vector<double> pArr = cumulatePro(scoreVec);//积累概率
        vector<vector<int>> newPop = choose(pArr);//选择
        crossAndMutation(newPop);//交叉和变异
        fixUp(newPop);//修正
        population = newPop;
    }
    for (int temp:best_body) {
        printf("%d ", temp);
    }
    return 0;
}

最开始没有精英策略，算法很不稳定，加入精英策略之后，算法变得比较稳定。

实例代码执行结果：

0 1 2 3 4 5 6