算法学习--排序、图、回溯（最小冲突、遗传）、动态规划基础算法复习
算法学习
算法入门内容
排序、动态规划、回溯、图等可以说是必须掌握的基础算法知识了，但发现自己掌握的还很差，知识不成体系，记忆不牢固，理解不深入，所以再来一次梳理，按排序、图、回溯（最小冲突、遗传）、动态规划的顺序依次学习并实现。
主要参考《算法导论》(Introduction of Algorithm[Third Edition])和维基百科。
目录
文章目录
- 算法学习
- 算法入门内容
- 目录
- 排序
- 图
- 回溯
- 动态规划
- 小结
其中排序是10000~100000个随机数的排序，图算法大多以Romania Problem为例，回溯法用来解决了一个著名八皇后问题，这里当作CSP问题来处理就同时使用了Min-Conflicts和Genetic Algorithm(GA)，动态规划解决TSP旅行商问题。
排序
排序算法有无数种，这里实现九种经典排序。
首先是三个最简单的冒泡、插入、选择，然后是归并、快排，之后是计数排序、基数排序、希尔排序，最后是堆排序。另外，这里写的排序算法全部都是Bottom-up迭代的，之后写单独的Top-down递归算法，用以学习递归策略。
#include 图
图算法也有无数种，这里实现经典的十种。
首先是三种经典遍历算法，分别是DFS，BFS和A*搜索，然后是最短路径算法Dijkstra，Bellman-Ford，Floyd-Warshall，之后是最小生成树算法Kruskal，Prim，最后是之前用过的强连通分量Tarjan算法和Hungarian解决最大二分匹配问题。Tarjan和Hungarian之后补充。
求SSSP(单源最短路)时，松弛Relax想象为现在你的手攥着u,v两个点，手中有一长一短两根绳子，假设原先你只知道从左手u到右手v只能通过较长的一根到达，扯紧之后发现，较长的那根松掉了，现在发现了从u到v更短的一根，将这种操作就描述为松弛。
基于邻接矩阵实现的算法：
#include 基于邻接表实现的算法：
#include 回溯
N皇后问题，这里会用到回溯法、局部搜索的遗传算法、约束满足问题的最小冲突算法（Min-conflicts Algorithm）来尝试解决这些问题。
代码结构：
Solutions:
#pragma warning(disable:4996)
#include 回溯法Backtracking.h:
#pragma once//include防范
#include 回溯法Backtracking.cpp:
#include "Backtracking.h"
bool Backtracking::isOk(int row) {
for (int i = 0; i < row; i++)//Top-down
if (queens[row] - queens[i] == row - i || queens[row] - queens[i] == i - row || queens[row] == queens[i])//两个对角线
return false;
return true;
}
void Backtracking::backtracking(int row) {
if (row >= n) {
total++;
//print();//if you wanna print all solutions
//exit(0);//if you wanna find just 1 solution
}
else
for (int col = 0; col < n; col++) {
queens[row] = col;
if (isOk(row))
backtracking(row + 1);
}
}
void Backtracking::print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < queens[i]; j++)
std::cout << " .";
std::cout << " Q";
for (int j = queens[i] + 1; j < n; j++)
std::cout << " .";
std::cout << std::endl;
}
std::cout << std::endl;
}
int Backtracking::nSolutions() {
return total;
}
最小冲突Minconflicts.h:
#pragma once
#include 最小冲突Minconflicts.cpp
#include "Minconflicts.h"
int Minconflicts::getMainDia(int row, int col) {//找一个一条对角线的不变量，就是row - col = constant, 最小是1 - n, 所以加上n - 1，0 ~ 2n - 2共(2n - 1)个。
return row - col + n - 1;
}
int Minconflicts::getAntiDia(int row, int col) {
return row + col;
}
void Minconflicts::initialize() {
for (int i = 0; i < n; i++) {//every row has only one queen
queens[i] = rand() % n;//这里我直接随机分配了，也可以在初始化时就同时保持每行1个每列1个皇后。
calculate(i, -1, queens[i]);
}
std::cout << "初始皇后序列：" << std::endl;
print();
}
void Minconflicts::calculate(int row, int srccol, int destcol) {//这里按行计算，所以行确定，移动列就行。
col[destcol]++;
mdiag[getMainDia(row, destcol)]++;
adiag[getAntiDia(row, destcol)]++;
if (srccol == -1)
return;
col[srccol]--;
mdiag[getMainDia(row, srccol)]--;
adiag[getAntiDia(row, srccol)]--;
}
bool Minconflicts::checkitout(int row) {//给一行找一个最优列
int currentCol = queens[row];
int optimalCol = queens[row];
int minConflicts = col[optimalCol] + mdiag[getMainDia(row, optimalCol)] + adiag[getAntiDia(row, optimalCol)] - 3;//同列或对角线一共这么多个皇后，作者这里写得不对
/*std::cout << col[optimalCol] << " " << mdiag[getMainDia(row, optimalCol)] << " " << adiag[getAntiDia(row, optimalCol)] << std::endl;
std::cout << getMainDia(1, 1) << " " << mdiag[3] << " " << col[0] << std::endl;*/
for (int i = 0; i < n; i++) {//检查第row行的每一列i
if (i == currentCol)
continue;
int conflicts = col[i] + mdiag[getMainDia(row, i)] + adiag[getAntiDia(row, i)];//这里要加上假设移过来的那个皇后，也就是要+2，在上面-2比在下面+2开销小
/*std::cout << "main diagonal " << getMainDia(row, i) << " anti diagonal " << getAntiDia(row, i) << std::endl;
std::cout << "conflicts " << minConflicts << std::endl;*/
if (conflicts < minConflicts) {
optimalCol = i;
minConflicts = conflicts;
}
else if (conflicts == minConflicts && rand() % 2)//关键之一！为避免轻易进入局部最优的情况，比较简单的办法是让每一行的皇后随机改变，这里选择的是两列最小冲突值相等50%移动
optimalCol = i;
}
/*std::cout << "col " << optimalCol << std::endl;
std::cout << "conflicts " << minConflicts << std::endl;
std::system("pause");*/
if (currentCol != optimalCol) {//找到了且不是原来那一列，就把皇后移动过去
queens[row] = optimalCol;
calculate(row, currentCol, optimalCol);
if (col[currentCol] <= 1 && col[optimalCol] <= 1 && mdiag[getMainDia(row, optimalCol)] <= 1 && adiag[getAntiDia(row, optimalCol)] <= 1) {//加个条件略作优化
for (int i = 0; i < n; i++)//每一行检查现在是不是符合要求了
if (col[queens[i]] > 1 || mdiag[getMainDia(i, queens[i])] > 1 || adiag[getAntiDia(i, queens[i])] > 1)//这里原作者不对，可能为0
return false;
return true;
}
}
//print();
return false;//如果没改变，那肯定不对，不然检查上一行的时候就已经可以了
}
void Minconflicts::compute() {//Main
srand(GetCurrentProcessId());
//srand(2333);
initialize();
bool flag = false;
while (!flag) {//一轮找不到，毕竟只扫描了一次，不成功就不退出
for (int i = 0; i < n; i++) {//每一行i
if (checkitout(i)) {
flag = true;//一次没法break出两层循环，所以设置一个flag
break;
}
}
}
std::cout << "最终皇后序列：" << std::endl;
print();
}
void Minconflicts::print() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < queens[i]; j++)
std::cout << " .";
std::cout << " Q";
for (int j = queens[i] + 1; j < n; j++)
std::cout << " .";
std::cout << std::endl;
}
}
遗传算法Genetic.h
#pragma once
#include 遗传算法Genetic.cpp
#include "Genetic.h"
void Genetic::initializePopulation() {
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
population.individuals[i].genes[j] = rand() % n;
}
calculateFitness(population.individuals[i]);
}
}
void Genetic::calculateFitness(Individual &individual) {
int conflicts = 0;
int *queens = individual.genes;
int fitness;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (queens[i] == queens[j] || abs(queens[i] - queens[j]) == j - i) {
conflicts++;
}
}
}
if (conflicts == 0) {
population.fittest = individual;
flag = false;
return;
}
individual.fitness = 1.0 / conflicts;//据一篇文章所说，用倒数而不是像书上用冲突数效果提高很多
}
void Genetic::selection() {//这里参考了sicolex的文章
double sum_fitness = 0.0;
for (int i = 0; i < k; i++)
sum_fitness += population.individuals[i].fitness;
for (int i = 0; i < n; i++) {//按轮盘赌选出的，顺序组成新种群，就相当于每次挑两个杂交了
int magnify_fitness = sum_fitness * 10000;
int random_fitness = rand() % magnify_fitness;
double select = (double)random_fitness / (double)10000;
int random_postion = std::lower_bound(population.individuals[i].genes, population.individuals[i].genes + n, select) - population.individuals[i].genes;//个人认为是upper，待会和lower做对比，可能还有更好的办法
std::swap(population.individuals[i], population.individuals[random_postion]);//是一个基因，一个int数组
}
}
void Genetic::crossover() {
int cross_over_point;//这里只是为了熟悉算法，就选择了随机选一个点交换右边的基因片段
for (int i = 0; i < k; i+=2) {
cross_over_point = rand() % n;
for (int j = cross_over_point; j < n; j++) {
std::swap(population.individuals[i].genes[j], population.individuals[i + 1].genes[j]);
}
}
}
void Genetic::mutation() {
for (int i = 0; i < k; i++) {
if (rand() % 2 == 0) {//这个基因组有50%几率突变，改变了就更新适应值
population.individuals[i].genes[rand() % n] = rand() % n;//gene有1/n/2的几率突变
calculateFitness(population.individuals[i]);
}
}
}
void Genetic::compute() {
initializePopulation();
while (flag) {
selection();
crossover();
mutation();
}
print(population.fittest.genes);
}
void Genetic::print(int *queens) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < queens[i]; j++)
std::cout << " .";
std::cout << " Q";
for (int j = queens[i] + 1; j < n; j++)
std::cout << " .";
std::cout << std::endl;
}
}
动态规划
用旅行商问题Travelling Salesman Problem来学习。
TSP要求从一个点出发，遍历每个点只一次并返回原点的最小代价路径。以来自维基的上图为例求解，动态规划问题一般分为四个步骤，首先刻画问题特征，然后找到一个递归解，最后递推地求最优解。
#pragma warning(disable: 4996)
#include 小结
还是太菜，任重而道远。
回顾这二十年，似乎做错了每一个人生结点的决定，狭窄的眼界限制了我太多太多。
之后会补充算法的对比和说明，暂时搁下去准备比赛、项目和期末的一堆任务了。
这个算法入门拖了足足半个月才写完。
希望中途打断的亚太杯建模能有个好结果。
哦另外，博客很快就要搬家到blog.v2beach.cn，到时别忘了给我启蒙的www.haomwei.com，www.byvoid.com和www.ruanyifeng.com/blog友情(跪膜)链接。