对经典算法的问题的回顾与感想
对八皇后问题和八数码问题分别用最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法来实现，并且分析他们的性能。
分析
要求实现的各个算法是有共同点的，比如，八皇后问题相关算法拥有相同的状态空间，每个算法都有从当前状态获取下一状态的需求，各个算法细节不同，共同点是，它们都是算法。
基于这样的想法，我们可以将代码划分为3层：
运行示例
代码比较长，附在最后面，读者基于上述的思路是不难看懂的。
我们默认读者已经知道这几个算法的思路，代码直接给出实现。如果不懂，请翻阅人工智能课本，里面有讲。
图1，八数码问题的交互界面
图2，八皇后问题的交互界面
图3 输出界面示例
结果分析
为了便于研究，我们首先定义三个指标，分别是：
①因变1：算法找到解的成功率；
②因变2：算法找到的解的平均路径长度
③因变3：算法找到解的平均耗散，用搜索的结点数衡量
对八皇后的结果分析
观察表1，我们可以发现如下对八皇后问题的有趣结论：
（1）在八皇后问题中，当随机测例数增加，最陡上升爬山法和首选爬山法的成功率都收敛到0.142左右，与书本结论吻合。
（2）最陡上升爬山法的解的平均路径长度收敛到0.58左右，而首选爬山是0.83左右。这说明最陡爬山法的平均走了更短的路径到达全局最优解。
（3）虽然最陡上山法的平均路径长度更短，但是搜索耗散却比首选爬山法多，原因是，为了得到最陡的子结点，需要探查所有的相邻子节点。反应在数据上是，最陡上山法的解的平均耗散率收敛到32左右，而首选爬山法仅为19左右。
（4）随机重启爬山法比最陡上升法和首选爬山法的成功率兜大大提高，重启次数为5，随机测例10000时，成功率高达0.6，约为前二者算法的4倍。但是也付出了更大的代价，平均解长度是最陡上升法的18.4倍，是首选爬山法的12.7倍；解的平均耗散度是最陡爬山法的17倍，是首选爬山法的28.4倍。
（5）随机重启爬山法的成功率随初始温度的增加而上升。当重启次数为0时，退化为首选爬山法，成功率、解长度、解耗散度都和首选爬山法接近。随着重启次数增加，成功率也大大上升，当重启次数为7时，成功率为0.7092，是重启次数为0的4.96倍，相应地，解长度和解耗散也大大增加。
（6）模拟退火算法随起始温度上升，成功率也上升。理论上分析，当起始温度足够高，退火过程足够长的时候，成功率可以接近1。但是其开销也会变得极大，0.43成功率的退火算法的解长度是0.46成功率退火算法的3706倍，而解耗散是146.5倍。
对八数码问题的结果分析
观察表2，我们可以发现如下对八数码问题的有趣结论：
（1）与八皇后问题类似，最陡上升和首选爬山法收敛到了接近的成功率，此处是0.4左右。但是解长度和解耗散并没有八皇后问题大，可能的原因是，八数码问题的相邻子结点空间远比八皇后问题大。
（2）这里没有使用随机重启算法，因为八数码问题关心解路径，如果使用了随机重启算法，则违反了规则。
（3）初始状态是通过目标随机打乱得来的，先随机取上限次数一下的打乱数x，然后随机方向移动白块x次。我们发现，打乱步数上限的多少，对成功率的影响并不大，无论最陡爬山算法，首选爬山算法，模拟退火算法都如此。可能的原因是，在打乱次数上限很小的时候，成功率就已经收敛了。
（4）模拟退火算法在八数码问题和八皇后问题的表现类似。都随着初始温度的上升而上升，同时解长度和解耗散急剧增大。理论上，当初始温度足够高，成功率会逼近1。
代码
由于实在太多，我就不逐行解释。读者把握分析时的思路，应该不难读懂。
//*****************************************************
// eightQueue.hpp
// 包括八皇后问题的eightQueueNode类和eightQueueNodeFactory的实现
//*****************************************************
#include <iostream>
#include <stdlib.h>
#include <time.h>
class eightQueueNode {
public:
int arr[8];
eightQueueNode(int a,int b, int c, int d, int e, int f, int g, int h){
arr[0] = a;
arr[1] = b;
arr[2] = c;
arr[3] = d;
arr[4] = e;
arr[5] = f;
arr[6] = g;
arr[7] = h;
}
eightQueueNode(const eightQueueNode& node) {
arr[0] = node.arr[0];
arr[1] = node.arr[1];
arr[2] = node.arr[2];
arr[3] = node.arr[3];
arr[4] = node.arr[4];
arr[5] = node.arr[5];
arr[6] = node.arr[6];
arr[7] = node.arr[7];
}
~eightQueueNode(){}
bool operator==(const eightQueueNode& node) {
return (this->arr[0] == node.arr[0]) && (this->arr[1] == node.arr[1]) && (this->arr[2] == node.arr[2])
&& (this->arr[3] == node.arr[3]) && (this->arr[4] == node.arr[4]) && (this->arr[5] == node.arr[5])
&& (this->arr[6] == node.arr[6]) && (this->arr[7] == node.arr[7]);
}
};
class eightQueueNodeFactory{
private:
int ranNum(){
return rand() % 8;
}
bool isTheArrayAllTrue(bool isAllCheck[64]) {
for(int i = 0; i < 64; i++) {
if(isAllCheck[i] == false) {
return false;
}
}
return true;
}
public:
eightQueueNodeFactory(){
srand((unsigned)time(NULL));
}
eightQueueNode getARandomNode() {
return eightQueueNode(ranNum(),ranNum(),ranNum(),ranNum(),ranNum(),ranNum(),ranNum(),ranNum());
}
int evaluate(const eightQueueNode& node) {
int numOfAttack = 0;
for(int i = 0; i < 7; i++) {
for(int j = i + 1; j < 8; j++) {
if (node.arr[i] == node.arr[j] || (node.arr[i]-node.arr[j]) == (i-j) || (node.arr[i]-node.arr[j]) == (j-i)) {
numOfAttack++;
}
}
}
return numOfAttack;
}
int getBestNextNode(eightQueueNode& node) {
eightQueueNode ans = node;
eightQueueNode tmp = node;
int costOfSearch = 0;
for(int i = 0; i < 64; i++) {
tmp = node;
tmp.arr[i/8] = i % 8;
if(evaluate(tmp) < evaluate(ans)) {
ans = tmp;
} else if(evaluate(tmp) == evaluate(ans)) {
if(rand() / double(RAND_MAX) > 0.5) {
ans = tmp;
}
}
}
node = ans;
return 56;
}
// the input node is confirmed to be not the best
int getNextBetterNode(eightQueueNode& node) {
bool isAllCheck[64];
for(int i = 0; i < 64; i++) isAllCheck[i] = false;
eightQueueNode tmp = node;
int costOfSearch = 1;
while(evaluate(tmp) >= evaluate(node)) {
// 子节点全部搜索过，都比当前差
if(isTheArrayAllTrue(isAllCheck)) return costOfSearch;
// 初始化，找下一邻居
tmp = node;
int a = rand() % 64;
isAllCheck[a] = true;
tmp.arr[a/8] = a % 8;
costOfSearch++;
if(tmp == node) {
continue;
}
}
node = tmp;
return costOfSearch;
}
int getARandomNeighbour(eightQueueNode& node) {
eightQueueNode tmp = node;
int cost = 0;
while(node == tmp) {
cost++;
int a = rand() % 64;
tmp.arr[a/8] = a % 8;
}
node = tmp;
return cost;
}
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
//***************************************
// eightQueueRunner.cpp
// 包括八皇后问题的各个算法和简单交互界面实现
//***************************************
#include "eightQueue.hpp"
#include <iostream>
最低0.47元/天 解锁文章
1679
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
