人工智能:用爬山法、模拟退火算法实现八皇后和八数码问题

最新推荐文章于 2021-09-01 16:18:28 发布
最新推荐文章于 2021-09-01 16:18:28 发布
阅读量4.6k 收藏 29
点赞数 7
分类专栏： 人工智能 文章标签： 人工智能

这里简单介绍下局部搜索算法。

局部搜索算法是对一个或多个状态进行评价和修改，而不是系统地从初始状态开始的路径。这些算法适用于关注那些关注解状态而不是路径代价的问题。

局部搜索算法从单个当前节点出发，通常只移动到它的临近状态，一般保存搜索路径。

局部搜素不是系统化的，但有两个关键的优点。
1. 只用很少的内存——通常是常数
2. 经常能在系统化算法不适用的很大或无限的状态空间中找到合理的解。

爬山法（最陡上升版本）搜索，简单的循环过程，不断向值增加的方向持续移动。算法在到达一个“峰顶”时终止，邻接状态中没有比它值更高的。

爬山法伪代码如下所示：

这里写图片描述

以八皇后问题为例说明爬山法。局部搜索算法一般使用完整状态形式化，即每个状态都包括在棋盘上放置8个皇后，每行各一个。后继函数指移动某个皇后到这行的另一个可能方格中，因此有7*8=56个后继。启发式评估函数h是形成互相攻击的皇后对的数量，不管是直接还是间接。在每一步移动之前，先计算棋盘上所有后继状态的启发式评估函数值h。然后选择h最小的那个后继状态，这里也就是选出移动后棋盘上皇后对冲突总个数最少的一个后继状态。

爬山法有时被称为贪婪局部搜索，因为它只是选择邻居中状态最好的一个，而不考虑下一步该如何走。尽管贪婪是七宗罪之一，贪婪算法却很有效。爬山法很快朝着解的方向进展，因为它可以很容易地改善一个坏的状态。不幸的是，爬山法经常会陷入困境。

在每种情况下，爬山法都会到达无法再取得进展的地点。从随机生成的八皇后问题开始，最陡上升的爬山法86%的情况下会被卡住，只有14%的问题实例能求得解。算法求解的速度快，成功找到解的平均步数是4步，被卡住的平均步数是3步。（这是理论值，幸运的是，后面的运行结果可以发现与理论结果一致）

爬山法有很多变形。

随机爬山法在上山移动中随机地选择下一步，被选中的概率随着上山移动的陡峭程度不同而不同。这种算法通常比最陡上升算法的收敛速度慢不少。

首选爬山法实现了随机爬山法，随机地生成后继节点直到生成一个优于当前节点的后继。这个算法在后继节点很多的时候是个好策略。

随机重启爬山法通过随机生成初始状态来导引爬山法搜索，直到找到目标。这个算法完备的概率接近于1，因为它最终会生成一个目标状态作为初始状态。

现在再来讲下模拟退火搜索算法。

模拟退火算法的内层循环与爬山法类似，只是它没有选择最佳移动，而是随机移动。如果该移动使情况改善，该移动则被接收。否则，算法以某个小于1的概率接收该移动。如果移动导致状态“变坏”，概率则成指数级下降——评估值△E变坏。这个概率也随“温度”T降低而下降：开始T高的时候可能允许“坏的”移动，T越低则越不可能发生。如果调度让T下降得足够慢，算法找到最优解的概率逼近于1。

伪代码如下所示：

这里写图片描述

对于八数码问题，可以选择很多因素作为评估函数。这里我选取的是曼哈顿距离，每次移动都是往曼哈顿距离减少得最少的方向移动。

八数码代码实现如下：

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;

int direction[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};  // 右下左上
int current[3][3];  // 当前状态
int row_0, col_0;  // 记录0的坐标
int totalTrial;    // 统计移动步数

int Manhattan() {  // 计算曼哈顿距离
    int sum = 0;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (current[i][j] == 0) continue;
            int row = current[i][j]/3;
            int col = current[i][j]%3;
            int distance = abs(row - i) + abs(col - j);
            sum += distance;
        }
    }
    return sum;
}

void print() {
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
            cout << current[i][j] << " ";
        cout << endl;
    }
    cout << endl;
}

void initial() {
    for (int i = 0; i < 3; ++i) {  // 初始状态为目标状态
        for (int j = 0; j < 3; ++j) {
            current[i][j] = i*3+j;
        }
    }
    row_0 = 0, col_0 = 0;
    int last = -1;   // 上一次移动方向
    for (int i = 0; i < 20; i++) {  // 随机打乱
        bool upset = false;
        while (!upset) {  // 打乱成功才跳出循环
            int dir = rand() % 4;  // 随机选取一个方向
            if (last != -1 && last != dir && abs(last-dir) == 2)  continue;  // 避免反向走
            int x = row_0 + direction[dir][0];
            int y = col_0 + direction[dir][1];
            if (x >= 0 && x < 3 && y >= 0 && y < 3) {  // 方向可行
                swap(current[row_0][col_0], current[x][y]);  // 交换0和相邻数字的位置
                row_0 = x, col_0 = y;     // 更新0的坐标
                last = dir;               // 更新此次移动方向
                upset = true;             // 标记打乱成功
            }
        }
    }
}

// 判定是否有解
bool check() {
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j)
            if (current[i][j] != i*3+j)
                return false;
    }
    return true;
}

// 爬山法
bool hillClimbing() {
    for (int trial = 0; trial < 200; trial++) {
        int curManha = Manhattan();  // 当前状态
        int minMan = 99999, minX = 0, minY = 0;
        for (int i = 0; i < 4; i++) {  // 在后继状态中找最小值
            int x = row_0 + direction[i][0];
            int y = col_0 + direction[i][1];
            if (x >= 0 && x < 3 && y >= 0 && y < 3) {  // 方向可行
                swap(current[row_0][col_0], current[x][y]);  // 交换0和相邻位置
                int nextManha = Manhattan();
                if (nextManha < minMan) {  // 获取下一状态的最小值
                    minMan = nextManha;
                    minX = x, minY = y;
                }
                swap(current[x][y], current[row_0][col_0]);  // 复原0和相邻位置
            }
        }
        if (curManha > minMan) {  // 最小值优于当前状态
            swap(current[row_0][col_0], current[minX][minY]);
            row_0 = minX, col_0 = minY;
        }
        if (check()) {   // 成功找到解
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 首选爬山法
bool firstchose() {
    for (int trial = 0; trial < 500; trial++) {
        // 随机选取第一个优于当前状态的下一步
        bool next = false;
        int times = 0;
        while (!next) {
            int dir = rand() % 4;
            int curManha = Manhattan();
            int x = row_0 + direction[dir][0];
            int y = col_0 + direction[dir][1];
            if (x >= 0 && x < 3 && y >= 0 && y < 3) {  // 方向可行
                swap(current[row_0][col_0], current[x][y]);
                int nextManha = Manhattan();
                if (nextManha < curManha) {
                    row_0 = x, col_0 = y;
                    next = true;
                } else {
                    swap(current[x][y], current[row_0][col_0]);
                }
            }
            if (++times > 20) break;
        }
        if (check()) {   // 成功找到解
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 模拟退火算法
bool simulated() {
    double temperature = 5;  // 初始温度
    int trial = 0;
    while (temperature > 0.00001) {
        vector<int> v;    // 选出可行的方向
        for (int i = 0; i < 4; i++) {
            int x = row_0 + direction[i][0];
            int y = col_0 + direction[i][1];
            if (x >= 0 && x < 3 && y >= 0 && y < 3) {  // 方向可行
                v.push_back(i);
            }
        }
        int curManha = Manhattan();      // 当前状态的曼哈顿距离之和
        int dir = v[rand() % v.size()];  // 随机选取一个可行方向
        int x = row_0 + direction[dir][0];
        int y = col_0 + direction[dir][1];  
        swap(current[row_0][col_0], current[x][y]);  // 交换0和相邻节点的位置
        int nextManha = Manhattan();    // 交换之后的曼哈顿距离之和
        int E = nextManha - curManha;   
        if (E < 0) {                    // 下一状态优于当前状态
            row_0 = x, col_0 = y;       // 更新0的位置
            trial++;
        } else if (exp((-1)*E/temperature) > ((double)(rand() % 1000) / 1000)) { // 以一定的概率选取
            row_0 = x, col_0 = y;
            trial++;
        } else {  // 不成功的话，复原0和相邻节点的位置
            swap(current[x][y], current[row_0][col_0]);
        }
        temperature *= 0.999;        // 温度下降
        if (check()) {   // 成功找到解
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 最陡上升爬山法
int steepestAscent() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (hillClimbing())
            count++;
    }
    return count;
}

// 首选爬山法
int firstChose() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (firstchose())
            count++;
    }
    return count;
}

// 随机重新开始爬山法
int randomRestart() {
    bool find = false;
    while (!find) {
        initial();
        find = hillClimbing();
    }
    return find;
}

// 模拟退火搜索
int simulatedAnnealing() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (simulated())
            count++;
    }
    return count;
}

int main(int argc, char const *argv[]) {
    srand((int)time(0));

    totalTrial = 0;
    cout << "steepest-Ascent searching..." << endl;
    int count = steepestAscent();
    cout << "steepest-Ascent[success/total]: " << count << "/1000" << endl;
    cout << "average steps: " << totalTrial/count << endl;

    totalTrial = 0;
    cout << "random-Restart searching..." << endl;
    int count2 = randomRestart();
    cout << "random-Restart: " << count2 << endl;
    cout << "average steps: " << totalTrial/count2 << endl;

    totalTrial = 0;
    cout << "first-Chose searching..." << endl;
    int count3 = firstChose();
    cout << "first-Chose[success/total]: " << count3 << "/1000" << endl;
    cout << "average steps: " << totalTrial/count3 << endl;

    totalTrial = 0;
    cout << "simulated-Annealing searching..." << endl;
    int count4 = simulatedAnnealing();
    cout << "simulated-Annealing[success/total]: " << count4 << "/1000" << endl;
    cout << "average steps: " << totalTrial/count4 << endl;

    return 0;
}


   
   
  • 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
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244

八皇后代码实现如下：

#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
// #include <windows.h>
#include <cmath>
using namespace std;

int queens[8][8];  // 8*8棋盘
int temp[8][8];
int totalTrial;   // 统计移动步数

// 随机生成初始状态
void initial() {
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++) {
            queens[i][j] = 0;
        }
    }
    for (int i = 0; i < 8; i++) {
        int num = rand() % 8;
        queens[i][num] = 1;
    }
}

void print() {
    for (int i = 0; i < 8; ++i) {
        for (int j = 0; j < 8; j++)
            cout << queens[i][j] << " ";
        cout << endl;
    }
}

// 统计在该位置下所有皇后的冲突个数
int findCollision(int row, int col) {
    int count = 0;
    // 该位置为1
    temp[row][col] = 1;
    for (int k = 0; k < 64; k++) {
        if (temp[k/8][k%8] == 1) {
            for (int i = 0; i < 8; i++)                             // 同一列
                if (i != k/8 && temp[i][k%8] == 1)
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j < 8; i++, j++)    // 右下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j >= 0; i--, j--)  // 左上方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i < 8 && j >= 0; i++, j--)   // 左下方
                if (i != k/8 && temp[i][j] == 1) 
                    count++;
            for (int i = k/8, j = k%8; i >= 0 && j < 8; i--, j++)   // 右上方
                if (i != k/8 && temp[i][j] == 1)
                    count++;
        }
    }
    temp[row][col] = 0;  // 复原位置
    return count/2;
}

bool check(int h[8][8]) {
    for (int i = 0; i < 8; i++) {
        bool flag = false;
        for (int j = 0; j < 8; j++) {
            if (queens[i][j] == 1 && h[i][j] == 0) { //皇后所在位置没有冲突
                flag = true;
                break;
            }
        }
        if (!flag) { // 皇后所在位置仍有冲突，还需要继续查找
            return false;
        }
    }
    return true;
}

int ct = 0;

// 爬山法
bool hillClimbing() {
    // 尝试次数大于100则判定为无解
    for (int trial = 0; trial <= 100; trial++) {
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8];
        int minH = 9999, minX = 0, minY = 0, curState;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                // 在计算h(i, j)之前，对i行所有位置赋值为0
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
                }
                // 先找出冲突个数最小的位置
                if (h[i][j] < minH) {
                    minH = h[i][j];
                    minX = i;
                    minY = j;
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }

        // 将皇后放在该行冲突最少的位置处
        if (curState > minH) {
            for (int i = 0; i < 8; i++)
                queens[minX][i] = 0;
            queens[minX][minY] = 1;
        }

        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 首选爬山法
bool firstchose() {
    // 尝试次数大于100则判定为无解
    for (int trial = 0; trial <= 100; trial++) {
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8], curState;

        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                // 在计算h(i, j)之前，对i行所有位置赋值为0
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }

        // 随机选取第一个优于当前状态的下一状态
        bool better = false;
        int next, nextState, times = 0;
        while (!better) {
            next = rand() % 64;
            nextState = h[next/8][next%8];
            if (nextState < curState) {
                better = true;
            }
            if (++times > 100) break;
        }

        if (better) {
            for (int i = 0; i < 8; i++)
                queens[next/8][i] = 0;
            queens[next/8][next%8] = 1;  // 放置皇后
        }

        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }
    }
    return false;
}

// 模拟退火搜索 
bool simulated() {
    double temperature = 5;
    int trial = 0;
    while (temperature > 0.00001) {
        // 拷贝原始棋盘数据到temp
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                temp[i][j] = queens[i][j];
            }
        }
        int h[8][8], curState;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                // 在计算h(i, j)之前，对i行所有位置赋值为0
                for (int k = 0; k < 8; k++)
                    temp[i][k] = 0;
                // 查找h(i, j)
                h[i][j] = findCollision(i, j);
                // 当前状态的h值
                if (queens[i][j] == 1) {
                    curState = h[i][j];
                }
                // 计算h(i,j)之后要复原数据，避免计算错误
                for (int k = 0; k < 8; k++)
                    temp[i][k] = queens[i][k];
            }
        }

        // 随机选取一个下一状态
        bool better = false;
        int next, nextState, times = 0;

        next = rand() % 64;
        nextState = h[next/8][next%8];
        int E = nextState - curState;
        if (E < 0) {
            better = true;
        } else if (exp((-1)*E/temperature) > ((double)(rand() % 1000) / 1000)) {
            better = true;
        }

        if (better) {
            for (int i = 0; i < 8; i++)
                queens[next/8][i] = 0;
            queens[next/8][next%8] = 1;  // 放置皇后
            trial++;
        }


        // 判断是否找到解, 有解则返回值为真
        if (check(h)) {
            totalTrial += trial;
            return true;
        }

        temperature *= 0.99;
    }
    return false;
}

// 最陡上升爬山法
int steepestAscent() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (hillClimbing())
            count++;
    }
    return count;
}

// 首选爬山法
int firstChose() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (firstchose())
            count++;
    }
    return count;
}

// 随机重新开始爬山法
int randomRestart() {
    bool find = false;
    while (!find) {
        initial();
        find = hillClimbing();
    }
    return find;
}

// 模拟退火搜索
int simulatedAnnealing() {
    int count = 0;
    for (int i = 0; i < 1000; i++) {
        initial();
        if (simulated())
            count++;
    }
    return count;
}

int main(int argc, char const *argv[]) {
    srand((int)time(0));

    totalTrial = 0;
    cout << "steepest-Ascent searching..." << endl;
    int count = steepestAscent();
    cout << "steepest-Ascent[success/total]: " << count << "/1000" << endl;
    cout << "average steps: " << totalTrial/count << endl;

    totalTrial = 0;
    cout << "random-Restart searching..." << endl;
    int count2 = randomRestart();
    cout << "random-Restart: " << count2 << endl;
    cout << "average steps: " << totalTrial/count2 << endl;

    totalTrial = 0;
    cout << "first-Chose searching..." << endl;
    int count3 = firstChose();
    cout << "first-Chose[success/total]: " << count3 << "/1000" << endl;
    cout << "average steps: " << totalTrial/count3 << endl;

    totalTrial = 0;
    cout << "simulated-Annealing searching..." << endl;
    int count4 = simulatedAnnealing();
    cout << "simulated-Annealing[success/total]: " << count4 << "/1000" << endl;
    cout << "average steps: " << totalTrial/count4 << endl;

    return 0;
}

   
   
  • 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
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320

八皇后运行结果如下：
这八皇后运行结果

这里写图片描述

八数码运行结果如下：

八数码运行结果

这里写图片描述

从实验运行结果看出，求解八数码和八皇后问题，用最陡上升爬山法和首选爬山法的查找成功率差不多大，八皇后的成功率为14~15%左右，八数码的成功率则为3~4%左右。

随机重启爬山法是遇到无解情况则重新开始初始状态直至找到有解，所以查找成功率几乎接近于1（理论上存在失败情况）。

而模拟退火搜索算法因为在选取下一状态的时候做了改进，所以无论是八皇后还是八数码，它的查找成功率是很高的。这里我的实现是八皇后77%，八数码30%。

在搜索代价方面， 这里仅显示了成功求解问题所需的平均移动步数。很明显，最陡上升爬山法、随机重启爬山法和首选爬山法的移动步数很少，几步之内就能很快求出解；模拟退火搜索算法虽然成功率高，但是移动步数却非常多，查找时间也比较长，代价也因此大了很多。

south_l
关注
专栏目录
爬山法实现 八皇后问题 （Python 实现）
感悟编程
04-24 9851
本文主要简单阐述爬山法的基本算法思想，并给出用此算法实现八皇后问题详细过程 最基本的爬上搜索算法表示：(节选自《人工智能》第二版)： function HILL-CLIMBING(problem) return a state thate is a locak maximum     inputs: problem     local variables: current,
C语言局部搜索算法（爬山法，模拟退火法，遗传算法）求解八皇后问题
qq_44310495的博客
10-17 3845
C语言局部算法求解八皇后问题写在前面八皇后问题及局部搜索算法爬山法（hill-climbing searching)算法介绍代码实现退火法（simulated annealing)算法介绍代码实现遗传算法算法介绍代码实现 写在前面 该篇博客盖改自https://blog.csdn.net/chenxz_/article/details/83014641，习惯用python可以去参考他的代码。 八皇后问题及局部搜索算法 八皇后问题（英文：Eight queens），是由国际西洋棋棋手马克斯·贝瑟尔于1848年
4.1 八皇后问题 - 传统dfs，爬山法，首选爬山法，模拟退火 --- 实现代码附详细注释
Spike的秃头之路
04-13 784
传统解法 - 广度优先搜索（DFS): #include <iostream> #include <cstdio> using namespace std; #define ll long long const int maxn = 200005; const int INF = 0x3f3f3f; int n,a[50],ans = 0; bool vis[3][50]; int cnt = 0; void dfs(int i) { ++cnt; if(i ==
人工智能-爬山法解决八皇后问题-python源码
qq_20793791的博客
05-31 1816
问题简述： 八皇后问题，一个古老而著名的问题，是回溯算法的典型案例。该问题由国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 算法的逻辑流程图如下所示： 源代码为： import copy import numpy as np import random import time # 爬山法解决八皇后问题 # 八皇后初始化函数 def init(): c
八皇后问题和八数码问题的最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法的分析和实现
LoHiauFung的博客
11-01 5747
源起人工智能的第二次作业课后的某题要求对八皇后问题和八数码问题分别用最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法来实现，并且分析他们的性能。分析我们发现要求实现的各个算法是有共同点的，比如，八皇后问题相关算法拥有相同的状态空间，每个算法都有从当前状态获取下一状态的需求，各个算法细节不同，共同点是，它们都是算法。 基于这样的想法，我们可以将代码划分为3层： 运行示例代码比较长，附在最后
人工智能：爬山法、随机重启爬山法、模拟退火算法、遗传算法、启发式搜索
最新发布
09-11
人工智能：爬山法、随机重启爬山法、模拟退火算法、遗传算法、启发式搜索方法解决八数码和八皇后问题_Eight-Numbers_and_Eight-Queens
人工智能算法——随机重启爬山法，模拟退火算法，遗传算法求解N皇后问题
湫一
10-07 8548
一、爬山法 爬山法就是完全的贪心算法，每一步都选最优位置，可能只能得到局部最优解。本实验对普通爬山法进行了简单的优化，采用了传统爬山法的变种——随机重启爬山法，当爬山步数超过一定值时，会重新打乱棋盘，重新“爬山”。 适应度函数：冲突皇后的总对数 “爬山”：每一步就是将棋盘的某一行的皇后移动到最优的位置，即该位置让冲突的皇后对数最少，即适应度函数值最小。 “不断地爬山”： 循环对棋盘的每一行...
人工智能-模拟退火算法解决八数码问题-python源码
qq_20793791的博客
05-31 1200
问题描述： 在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。该问题称八数码难题或者重排九宫问题。 算法解决流程图为： 源代码为： import numpy as np import random import time import math import copy # 模拟退火算法解决八皇.
局部搜索算法（求解八皇后问题）
chenxz_的博客
10-11 9318
局部搜索算法是一种简单的贪心搜索算法，是解决最优化问题的一种启发式算法，该算法每次从当前解的临近解空间中根据启发函数选择一个最优解（也不一定是最优解）作为当前解，直到达到一个局部最优解。本文以求解八皇后问题来描述爬山法，模拟退火法以及遗传算法。   目录   一、 爬山法 1. 算法描述 2. 算法实现 （1）获得某一状态的h（相互攻击的皇后对的数目）  （2）获取最优邻居 （3...
模拟退火算法完整c++源代码_VS2013
12-04
模拟退火算法的完整c++实现，除VS2013外不依赖任何库，可直接修改后使用。包含测试样例及经典的Travelling Salesman Problem问题的求解代码。
八数码问题（8皇后问题）的A*算法求解（Python实现）
06-03
主要实现了A*算法解决8数码问题，另有深度优先，广度优先及有序搜索的实现
NO.79——BFS,DFS,Astar,爬山法,最抖爬山法,模拟退火法解决八数码问题Python实现
ghl1390490928的博客
02-09 1831
问题描述 无非就是将无序数列变成有序数列。 之间写过关于这个问题的解决办法，但是当时对各种算法理解的不是很透彻，比如广度优先算法和深度优先算法，同样都是维护一个open表，怎么用列表实现队列和栈的操作，那时候理解的不是很深，终于现在有些理解了。 Astar算法同样是维护一个open表，不过这个open表示一个优先级队列，每次取出的是代价最低的元素，然后再拓展它的邻居，然后再更新这个op...
人工智能：爬山法、随机重启爬山法、模拟退火算法、遗传算法、启发式搜索方法解决八数码和八皇后问题
sinat_28178805的博客
07-01 1494
摘要 本文主要分为两个部分，分别采用实验对比对不同的方法进行分析。第一，以八数码问题和八皇后问题为例，对比爬山法，随机重启爬山法，模拟退火算法，遗传算法的搜索性能。第二，以八数码问题为例，分别采用曼哈顿距离和错位棋子数为启发式函数，设计实验，分析启发式搜索方法。 关键词：局部搜索方法，启发式搜索 1. 局部搜索方法对比与分析 局部搜索方法是对一个或多个状态进行评价和修改，而不是系统地从初始状态开始的路径，这些算法适用于关注那些关注解状态而不是路径代价的问题[1]。本节我们以八数码问题和八皇后问
Python：爬山法/随机重启爬山法/允许侧移的爬山法解决八皇后问题
我是一只小嵩鼠
12-20 5032
文章目录1 八皇后问题2 程序代码2.1 程序12.2 程序22.3 程序32.3.1 爬山法2.3.2 随机重启爬山法3 评价 1 八皇后问题 有一个8乘8的棋盘，现在要将八个皇后放到棋盘上，满足：对于每一个皇后，在自己所在的行、列、两个对角线都没有其他皇后。 不了解爬山法、随机重启爬山法的话，请看这里。 规定棋盘的同列只能出现一个皇后。每一个棋盘，对应于一个长度为8的序列，每一个数的范围是[1, 8]，第k个数字所代表的含义是第k列中皇后所在的行数，如[3,2,5,4,3,2,1,3]代表棋盘上从第
python解决八数码问题_人工智能-爬山法解决八数码问题-python源码
weixin_39777404的博客
12-20 1307
问题描述：在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。该问题称八数码难题或者重排九宫问题。 八数码问题的解决流程如下图所示： 算法源代码为：import copyimport numpy as npimpor...
爬山法、随机重启爬山法、模拟退火算法对八皇后问题和八数码问题的性能测试...
denghuang8508的博客
11-09 1190
代码地址：https://github.com/laiy/AI/tree/master/awesome-search 一些前提： 1. 首先要明确这些算法并不是用于解决传统的搜索问题的（环境是可观察的，确定的，已知的，问题解是一个行动序列），这些算法适用于哪些关注解状态而不是路径代价的问题，我们讨论的搜索算法往往和现实世界的一些问题更加的契合。 2. 为了便于测试我们选择了八...
人工智能-8-puzzle爬山法（最陡上升，首项选择），随即重新启动法
半世烟雨_
11-10 1692
#include #include #include #include #include using namespace std; int mubiao[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } }; int current[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } }; int dir[
python 新的随机爬山算法，一起交流~
m0_37968030的博客
09-01 584
前言 最近在做聚焦算法，需要找到无参考图像中图像质量最好的，其中用到了随机爬山算法， 最开始采用三轮爬山，三轮步长不同，寻找最优解，但是发现精度不够，有的时候因为步长原因会跳过最佳点 后采用新的随机爬山算法 原理介绍 本算法第一轮采用大步长爬山算法确定范围值，如果找到局部峰值后，再向前继续找一步，如果同为下降趋势则停止 后几轮采用小步长迭代方法寻找最优解，最优解结果范围：±最后一轮步长，如果对迭代次数没有要求，最后1步长迭代会更精确 流程图如下所示 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值