爬山法、随机重启爬山法、模拟退火算法对八皇后问题和八数码问题的性能测试

代码地址：https://github.com/laiy/AI/tree/master/awesome-search

一些前提：

1. 首先要明确这些算法并不是用于解决传统的搜索问题的（环境是可观察的，确定的，已知的，问题解是一个行动序列），这些算法适用于哪些关注解状态而不是路径代价的问题，我们讨论的搜索算法往往和现实世界的一些问题更加的契合。

2. 为了便于测试我们选择了八皇后和八数码问题，不考虑它的一些特殊性质来作为一个搜索问题。（因为这两个问题本身就可以用经典搜索策略来解决，这里只是忽略掉问题的一些性质来模拟一个不可用经典搜索解决的问题）

 

首先对八皇后问题和八数码问题做个简单的介绍：

八皇后问题：

The eight queens puzzle is the problem of placing eight chess queens on an 8×8 chessboard so that no two queens threaten each other. Thus, a solution requires that no two queens share the same row, column, or diagonal.

八数码问题：

对给的任意一个初始状态，找到回到目标状态的步骤。

这两个问题都是经典的搜索问题，用DFS或BFS都可以找到解，这里我们探讨的是爬山法，随机重启爬山法和模拟退火算法对这两个问题的求解性能和能力。

 

首先，编写测例生成器，我选择生成100k个初始状态的测例，生成思想：

八皇后：生成八个1-8的随机数作为一个八皇后的初始状态，数字表示在每一列皇后的位置，例如4 6 8 2 7 1 3 5对应如下状态

八数码：终点位置开始随机移动10k步达到一个有解初始状态

测例生成器代码如下：

/*
 * this program is used for generate the majority of 8 digits problems and 8 queens problems
 */

#include <cstdio>
#include <cstdlib>

#define TESRCASE 100000
#define STEP 10000
#define UP 0
#define DOWN 1
#define LEFT 2
#define RIGHT 3

inline void swap(int *a, int *b) {
    *a ^= *b ^= *a ^= *b;
}

void generate_8_digits_problem() {
    FILE *fp = fopen("testcase_8_digits_problem", "w");
    int testcase = TESRCASE, direction, position, steps;
    while (testcase--) {
        int state[9] = {1, 2, 3, 4, 5, 6, 7, 8, 0};
        steps = STEP;
        position = 9;
        while (steps--) {
            direction = rand() % 4;
            switch (direction) {
                case UP:
                    if (position <= 3)
                        break;
                    else {
                        swap(&state[position - 1], &state[position - 4]), position -= 3;
                        break;
                    }
                case DOWN:
                    if (position >= 7)
                        break;
                    else {
                        swap(&state[position - 1], &state[position + 2]), position += 3;
                        break;
                    }
                case LEFT:
                    if (position % 3 == 1)
                        break;
                    else {
                        swap(&state[position - 1], &state[position - 2]), position--;
                        break;
                    }
                case RIGHT:
                    if (position % 3 == 0)
                        break;
                    else {
                        swap(&state[position - 1], &state[position]), position++;
                        break;
                    }
            }
        }
        fprintf(fp, "%d %d %d %d %d %d %d %d %d
", state[0], state[1], state[2], state[3], state[4], state[5], state[6], state[7], state[8]);
    }
    fclose(fp);
}

void generate_8_queens_problem() {
    FILE *fp = fopen("testcase_8_queens_problem", "w");
    int testcase = TESRCASE, state[8], position, i;
    while (testcase--) {
        for (i = 0; i < 8; i++)
            position = rand() % 8 + 1, state[i] = position;
        fprintf(fp, "%d %d %d %d %d %d %d %d
", state[0], state[1], state[2], state[3], state[4], state[5], state[6], state[7]);
    }
    fclose(fp);
}

int main() {
    generate_8_digits_problem();
    generate_8_queens_problem();
    return 0;
}

好，现在我们就得到了八皇后问题和八数码问题各100k个初始状态的测例了，分别保存在testcase_8_digits_problem和testcase_8_queens_problem中，每个测例占用1行。

首先测试爬山法，我们约定用成功的测例的平均时间作为性能指标，用测例的解决率作为能力指标。

爬山法的思想：对每一个状态，永远像最理想的状态前进（贪心）。

对八皇后问题来说，我们用相互碰撞的皇后对作为状态的权重（weight），那么爬山法的做法就是对每一个后继状态计算weight，记录下最小weight的状态，前进。

对八数码问题来说，我们用移动后曼哈顿距离作为状态权重（weight），最小weight的下一状态作为前进状态。

如果周围的所有状态都不能达到“爬山”的效果，则算法达到一个山脊（极大值），如果未找到解则认为算法失败。

爬山法测试代码如下：

# ifndef CLK_TCK
# define CLK_TCK CLOCKS_PER_SEC
# endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>

#define TESRCASE 100000
#define UP 0
#define DOWN 1
#define LEFT 2
#define RIGHT 3

struct State {
    int direction, diff_manhattan;
    State(int i, int dis) {
        this->direction = i;
        this->diff_manhattan = dis;
    }
    bool operator<(const State &s) const {
        return diff_manhattan > s.diff_manhattan;
    }
};

double eight_digits_problem_time;
double eight_queens_problem_time;
int eight_digits_problem_failed_times;
int eight_queens_problem_failed_times;
int diff_manhattan_distance;

inline void swap(int *a, int *b) {
    *a ^= *b ^= *a ^= *b;
}

inline bool solved(int *state) {
    for (int i = 0; i < 8; i++)
        if (state[i] != i + 1)
            return false;
    return true;
}

inline int manhattan_distance(int num, int position) {
    int dest_x = ceil(num / 3), dest_y = (num - 1) % 3 + 1, position_x = ceil(position / 3), position_y = (position - 1) % 3 + 1;
    return abs(dest_x - position_x) + abs(dest_y - position_y);
}

bool eight_digits_better(int *state, int position, int direction) {
    switch (direction) {
        case UP:
            if (position <= 3)
                return false;
            else {
                diff_manhattan_distance =  manhattan_distance(state[position - 4], position - 3) - manhattan_distance(state[position - 4], position);
                return manhattan_distance(state[position - 4], position - 3) > manhattan_distance(state[position - 4], position);
            }
        case DOWN:
            if (position >= 7)
                return false;
            else {
                diff_manhattan_distance = manhattan_distance(state[position + 2], position + 3) - manhattan_distance(state[position + 2], position);
                return manhattan_distance(state[position + 2], position + 3) > manhattan_distance(state[position + 2], position);
            }
        case LEFT:
            if (position % 3 == 1)
                return false;
            else {
                diff_manhattan_distance = manhattan_distance(state[position - 2], position - 1) - manhattan_distance(state[position - 2], position);
                return manhattan_distance(state[position - 2], position - 1) > manhattan_distance(state[position - 2], position);
            }
        case RIGHT:
            if (position % 3 == 0)
                return false;
            else {
                diff_manhattan_distance =  manhattan_distance(state[position], position + 1) - manhattan_distance(state[position], position);
                return manhattan_distance(state[position], position + 1) > manhattan_distance(state[position], position);
            }
    }
    return false;
}

void solve_one_case_of_8_digits_problem(int *state) {
    clock_t start_time = clock();
    int position, i;
    bool found;
    for (i = 0; i < 9; i++)
        if (state[i] == 0) {
            position = i + 1;
            break;
        }
    while (!solved(state)) {
        found = false;
        std::vector<State> v;
        for (i = 0; i < 4; i++) {
            if (eight_digits_better(state, position, i)) {
                found = true;
                v.push_back(State(i, diff_manhattan_distance));
            }
            if (i == 3 && found) {
                std::sort(v.begin(), v.end());
                switch (v[0].direction) {
                    case UP:
                        swap(&state[position - 1], &state[position - 4]), position -= 3;
                        break;
                    case DOWN:
                        swap(&state[position - 1], &state[position + 2]), position += 3;
                        break;
                    case LEFT:
                        swap(&state[position - 1], &state[position - 2]), position--;
                        break;
                    case RIGHT:
                        swap(&state[position - 1], &state[position]), position++;
                        break;
                }
            }
        }
        if (!found) {
            eight_digits_problem_failed_times++;
            return;
        }
    }
    eight_digits_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_digits_problem() {
    FILE *fp = fopen("testcase_8_digits_problem", "r");
    int original_state[9];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7, original_state + 8) != EOF)
        solve_one_case_of_8_digits_problem(original_state);
    fclose(fp);
}

int peers_of_attacking_queens(int *state) {
    int peers = 0, i, j, k;
    for (i = 0; i < 7; i++) {
        for (j = i + 1; j < 8; j++)
            if (state[j] == state[i])
                peers++;
        for (j = i + 1, k = state[i] + 1; j < 8 && k <= 8; j++, k++)
            if (state[j] == k)
                peers++;
        for (j = i + 1, k = state[i] - 1; j < 8 && k >= 1; j++, k--)
            if (state[j] == k)
                peers++;
    }
    return peers;
}

void solve_one_case_of_8_queens_problem(int *state) {
    clock_t start_time = clock();
    int h = peers_of_attacking_queens(state), i, j, best_i, best_j, temp, record;
    while (h != 0) {
        best_i = -1;
        for (i = 1; i <= 8; i++) {
            record = state[i - 1];
            for (j = 1; j <= 8; j++) {
                if (j != record) {
                    state[i - 1] = j;
                    temp = peers_of_attacking_queens(state);
                    if (temp < h)
                        h = temp, best_i = i, best_j = j;
                }
            }
            state[i - 1] = record;
        }
        if (best_i == -1) {
            eight_queens_problem_failed_times++;
            return;
        }
        state[best_i - 1] = best_j;
    }
    eight_queens_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_queens_problem() {
    FILE *fp = fopen("testcase_8_queens_problem", "r");
    int original_state[8];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7) != EOF)
        solve_one_case_of_8_queens_problem(original_state);
    fclose(fp);
}

void print_result() {
    printf("eight digits problem average solved times: %lf
", eight_digits_problem_time / (double)(TESRCASE - eight_digits_problem_failed_times));
    printf("eight digits problem solved rate: %lf
", 1 - double(eight_digits_problem_failed_times) / TESRCASE);
    printf("eight queens problem average solved times: %lf
", eight_queens_problem_time / (double)(TESRCASE - eight_queens_problem_failed_times));
    printf("eight queens problem solved rate: %lf
", 1 - double(eight_queens_problem_failed_times) / TESRCASE);
}

int main() {
    eight_digits_problem_time = 0;
    eight_queens_problem_time = 0;
    eight_digits_problem_failed_times = 0;
    eight_queens_problem_failed_times = 0;
    solve_8_digits_problem();
    solve_8_queens_problem();
    print_result();
    return 0;
}

测试结果如下：

我们可以看到，用爬山法来解决八数码问题解决率是非常非常低的，99.9%+的测例用爬山法是无法得到解的。

而对于八皇后问题，爬山法解决率也不是很理想，14.6%的测例是可以找到解的。

优点是平均解决时间短，因为贪心并不需要回溯，找到底就结束了，可以理解为不回溯的启发式DFS。

 

然后是随机重启爬山法

随机重启爬山法的思想是，对于给定的初始状态如果不能找到解，自己随机生成一个初始状态重启求解直到找到最终的解为止。

这个作为对于八皇后问题来说是合情合理的作为，对于八数码问题可能有人会认为是不妥当的，因为八数码问题的目标就是给定初始状态，找到到达最终状态的路线，初始状态是不能随意改变的。

而八皇后问题不一样，八皇后问题目标就是找到最终状态，所有初始状态随机改变是可以允许的。

提出这个问题的读者可以回到本文最开始理解一些我描述的前提。

代码如下：

# ifndef CLK_TCK
# define CLK_TCK CLOCKS_PER_SEC
# endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>

#define TESRCASE 100000
#define STEP 100
#define UP 0
#define DOWN 1
#define LEFT 2
#define RIGHT 3

struct State {
    int direction, diff_manhattan;
    State(int i, int dis) {
        this->direction = i;
        this->diff_manhattan = dis;
    }
    bool operator<(const State &s) const {
        return diff_manhattan > s.diff_manhattan;
    }
};

double eight_digits_problem_time;
double eight_queens_problem_time;
int eight_digits_problem_failed_times;
int eight_queens_problem_failed_times;
int diff_manhattan_distance;

inline void swap(int *a, int *b) {
    *a ^= *b ^= *a ^= *b;
}

inline bool solved(int *state) {
    for (int i = 0; i < 8; i++)
        if (state[i] != i + 1)
            return false;
    return true;
}

inline int manhattan_distance(int num, int position) {
    int dest_x = ceil(num / 3), dest_y = (num - 1) % 3 + 1, position_x = ceil(position / 3), position_y = (position - 1) % 3 + 1;
    return abs(dest_x - position_x) + abs(dest_y - position_y);
}

bool eight_digits_better(int *state, int position, int direction) {
    switch (direction) {
        case UP:
            if (position <= 3)
                return false;
            else {
                diff_manhattan_distance =  manhattan_distance(state[position - 4], position - 3) - manhattan_distance(state[position - 4], position);
                return manhattan_distance(state[position - 4], position - 3) > manhattan_distance(state[position - 4], position);
            }
        case DOWN:
            if (position >= 7)
                return false;
            else {
                diff_manhattan_distance = manhattan_distance(state[position + 2], position + 3) - manhattan_distance(state[position + 2], position);
                return manhattan_distance(state[position + 2], position + 3) > manhattan_distance(state[position + 2], position);
            }
        case LEFT:
            if (position % 3 == 1)
                return false;
            else {
                diff_manhattan_distance = manhattan_distance(state[position - 2], position - 1) - manhattan_distance(state[position - 2], position);
                return manhattan_distance(state[position - 2], position - 1) > manhattan_distance(state[position - 2], position);
            }
        case RIGHT:
            if (position % 3 == 0)
                return false;
            else {
                diff_manhattan_distance =  manhattan_distance(state[position], position + 1) - manhattan_distance(state[position], position);
                return manhattan_distance(state[position], position + 1) > manhattan_distance(state[position], position);
            }
    }
    return false;
}

void eight_digits_random_state(int *s) {
    int state[9] = {1, 2, 3, 4, 5, 6, 7, 8, 0}, steps, position, direction;
    steps = STEP;
    position = 9;
    while (steps--) {
        direction = rand() % 4;
        switch (direction) {
            case UP:
                if (position <= 3)
                    break;
                else {
                    swap(&state[position - 1], &state[position - 4]), position -= 3;
                    break;
                }
            case DOWN:
                if (position >= 7)
                    break;
                else {
                    swap(&state[position - 1], &state[position + 2]), position += 3;
                    break;
                }
            case LEFT:
                if (position % 3 == 1)
                    break;
                else {
                    swap(&state[position - 1], &state[position - 2]), position--;
                    break;
                }
            case RIGHT:
                if (position % 3 == 0)
                    break;
                else {
                    swap(&state[position - 1], &state[position]), position++;
                    break;
                }
        }
    }
    for (int i = 0; i < 9; i++)
        s[i] = state[i];
}

void solve_one_case_of_8_digits_problem(int *state) {
    clock_t start_time = clock();
    int position, i;
    bool found;
    for (i = 0; i < 9; i++)
        if (state[i] == 0) {
            position = i + 1;
            break;
        }
    while (!solved(state)) {
        found = false;
        std::vector<State> v;
        for (i = 0; i < 4; i++) {
            if (eight_digits_better(state, position, i)) {
                found = true;
                v.push_back(State(i, diff_manhattan_distance));
            }
            if (i == 3 && found) {
                std::sort(v.begin(), v.end());
                switch (v[0].direction) {
                    case UP:
                        swap(&state[position - 1], &state[position - 4]), position -= 3;
                        break;
                    case DOWN:
                        swap(&state[position - 1], &state[position + 2]), position += 3;
                        break;
                    case LEFT:
                        swap(&state[position - 1], &state[position - 2]), position--;
                        break;
                    case RIGHT:
                        swap(&state[position - 1], &state[position]), position++;
                        break;
                }
            }
        }
        if (!found)
            eight_digits_random_state(state);
    }
    eight_digits_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_digits_problem() {
    FILE *fp = fopen("testcase_8_digits_problem", "r");
    int original_state[9];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7, original_state + 8) != EOF)
        solve_one_case_of_8_digits_problem(original_state);
    fclose(fp);
}

int peers_of_attacking_queens(int *state) {
    int peers = 0, i, j, k;
    for (i = 0; i < 7; i++) {
        for (j = i + 1; j < 8; j++)
            if (state[j] == state[i])
                peers++;
        for (j = i + 1, k = state[i] + 1; j < 8 && k <= 8; j++, k++)
            if (state[j] == k)
                peers++;
        for (j = i + 1, k = state[i] - 1; j < 8 && k >= 1; j++, k--)
            if (state[j] == k)
                peers++;
    }
    return peers;
}

inline void eight_queens_random_state(int *state) {
    for (int i = 0; i < 8; i++)
        state[i] = rand() % 8 + 1;
}

void solve_one_case_of_8_queens_problem(int *state) {
    clock_t start_time = clock();
    int h = peers_of_attacking_queens(state), i, j, best_i, best_j, temp, record;
    while (h != 0) {
        best_i = -1;
        for (i = 1; i <= 8; i++) {
            record = state[i - 1];
            for (j = 1; j <= 8; j++) {
                if (j != record) {
                    state[i - 1] = j;
                    temp = peers_of_attacking_queens(state);
                    if (temp < h)
                        h = temp, best_i = i, best_j = j;
                }
            }
            state[i - 1] = record;
        }
        if (best_i == -1)
            eight_queens_random_state(state), h = peers_of_attacking_queens(state);
        else
            state[best_i - 1] = best_j;
    }
    eight_queens_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_queens_problem() {
    FILE *fp = fopen("testcase_8_queens_problem", "r");
    int original_state[8];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7) != EOF)
        solve_one_case_of_8_queens_problem(original_state);
    fclose(fp);
}

void print_result() {
    printf("eight digits problem average solved times: %lf
", eight_digits_problem_time / (double)(TESRCASE - eight_digits_problem_failed_times));
    printf("eight digits problem solved rate: %lf
", 1 - double(eight_digits_problem_failed_times) / TESRCASE);
    printf("eight queens problem average solved times: %lf
", eight_queens_problem_time / (double)(TESRCASE - eight_queens_problem_failed_times));
    printf("eight queens problem solved rate: %lf
", 1 - double(eight_queens_problem_failed_times) / TESRCASE);
}

int main() {
    eight_digits_problem_time = 0;
    eight_queens_problem_time = 0;
    eight_digits_problem_failed_times = 0;
    eight_queens_problem_failed_times = 0;
    solve_8_digits_problem();
    solve_8_queens_problem();
    print_result();
    return 0;
}

测试结果如下：

我们可以看到随机重启爬山法的解决率是接近1的（不能说是1，因为确实存在无论怎么重启都找不到解的可能性）

但是在每个测例解决的时间消耗上面就大打折扣了，对八数码问题，是爬山法单个测例解决时间的600倍，对八皇后问题单个测例平均解决时间大概是7倍。

这个时间效率和爬山法的问题解决率有关系，解决率越大时间差距越小。

 

现在测试最后一个算法：模拟退火算法

模拟退火算法的思想：模拟炼金退火的步骤，温度随时间下降，在温度高的时候，分子是活跃的，有较大可能性随机运动。

对应到具体问题上就是：对每一个后继状态，如果找到的状态不能使weight更好，也有exp(weight/temperature)的可能性去走这个状态，然后随着温度下降，这个概率越来越小，达到模拟退火的效果。

我选择温度下降为比例下降，系数为0.8，每一个温度最多可以持续300次迭代，终止温度为0.000000001，八数码问题起始温度为10，八皇后问题起始温度为50。

代码如下：

# ifndef CLK_TCK
# define CLK_TCK CLOCKS_PER_SEC
# endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <algorithm>

#define TESRCASE 100000
#define UP 0
#define DOWN 1
#define LEFT 2
#define RIGHT 3
#define EIGHT_DIGITS_ORIGINAL_TEMPERATURE 10
#define EIGHT_QUEENS_ORIGINAL_TEMPERATURE 50
#define MAX_TRIES_IN_ONE_TEMPERATURE 300
#define STOP_TEMPERATURE 0.000000001
#define COLD_DOWN_RATE 0.8

double eight_digits_problem_time;
double eight_queens_problem_time;
int eight_digits_problem_failed_times;
int eight_queens_problem_failed_times;
double temperature;

inline void swap(int *a, int *b) {
    *a ^= *b ^= *a ^= *b;
}

inline bool solved(int *state) {
    for (int i = 0; i < 8; i++)
        if (state[i] != i + 1)
            return false;
    return true;
}

inline int manhattan_distance(int num, int position) {
    int dest_x = ceil(num / 3), dest_y = (num - 1) % 3 + 1, position_x = ceil(position / 3), position_y = (position - 1) % 3 + 1;
    return abs(dest_x - position_x) + abs(dest_y - position_y);
}

bool eight_digits_better(int *state, int position, int direction) {
    int dis;
    switch (direction) {
        case UP:
            if (position <= 3)
                return false;
            else {
                dis = manhattan_distance(state[position - 4], position - 3) - manhattan_distance(state[position - 4], position);
                return (dis > 0) ? true : ((double)(rand() % 1000) / 1000) < exp(dis / temperature);
            }
        case DOWN:
            if (position >= 7)
                return false;
            else {
                dis = manhattan_distance(state[position + 2], position + 3) - manhattan_distance(state[position + 2], position);
                return (dis > 0) ? true : ((double)(rand() % 1000) / 1000) < exp(dis / temperature);
            }
        case LEFT:
            if (position % 3 == 1)
                return false;
            else {
                dis = manhattan_distance(state[position - 2], position - 1) - manhattan_distance(state[position - 2], position);
                return (dis > 0) ? true : ((double)(rand() % 1000) / 1000) < exp(dis / temperature);
            }
        case RIGHT:
            if (position % 3 == 0)
                return false;
            else {
                dis = manhattan_distance(state[position], position + 1) - manhattan_distance(state[position], position);
                return (dis > 0) ? true : ((double)(rand() % 1000) / 1000) < exp(dis / temperature);
            }
    }
    return false;
}

void solve_one_case_of_8_digits_problem(int *state) {
    clock_t start_time = clock();
    int position, i, tries_count;
    bool found;
    for (i = 0; i < 9; i++)
        if (state[i] == 0) {
            position = i + 1;
            break;
        }
    temperature = EIGHT_DIGITS_ORIGINAL_TEMPERATURE;
    tries_count = MAX_TRIES_IN_ONE_TEMPERATURE;
    while (!solved(state)) {
        found = false;
        for (i = 0; i < 4; i++)
            if (eight_digits_better(state, position, i)) {
                found = true;
                switch (i) {
                    case UP:
                        swap(&state[position - 1], &state[position - 4]), position -= 3;
                        break;
                    case DOWN:
                        swap(&state[position - 1], &state[position + 2]), position += 3;
                        break;
                    case LEFT:
                        swap(&state[position - 1], &state[position - 2]), position--;
                        break;
                    case RIGHT:
                        swap(&state[position - 1], &state[position]), position++;
                        break;
                }
                break;
            }
        if (--tries_count == 0)
            tries_count = MAX_TRIES_IN_ONE_TEMPERATURE, temperature *= COLD_DOWN_RATE;
        if (!found || temperature < STOP_TEMPERATURE) {
            eight_digits_problem_failed_times++;
            return;
        }
    }
    eight_digits_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_digits_problem() {
    FILE *fp = fopen("testcase_8_digits_problem", "r");
    int original_state[9];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7, original_state + 8) != EOF)
        solve_one_case_of_8_digits_problem(original_state);
    fclose(fp);
}

int peers_of_attacking_queens(int *state) {
    int peers = 0, i, j, k;
    for (i = 0; i < 7; i++) {
        for (j = i + 1; j < 8; j++)
            if (state[j] == state[i])
                peers++;
        for (j = i + 1, k = state[i] + 1; j < 8 && k <= 8; j++, k++)
            if (state[j] == k)
                peers++;
        for (j = i + 1, k = state[i] - 1; j < 8 && k >= 1; j++, k--)
            if (state[j] == k)
                peers++;
    }
    return peers;
}

void solve_one_case_of_8_queens_problem(int *state) {
    clock_t start_time = clock();
    int h = peers_of_attacking_queens(state), i, j, best_i, best_j, temp, record, tries_count, temp_h;
    temperature = EIGHT_QUEENS_ORIGINAL_TEMPERATURE;
    tries_count = MAX_TRIES_IN_ONE_TEMPERATURE;
    while (h != 0) {
        temp_h = 28;
        for (i = 1; i <= 8; i++) {
            record = state[i - 1];
            for (j = 1; j <= 8; j++) {
                if (j != record) {
                    state[i - 1] = j;
                    temp = peers_of_attacking_queens(state);
                    if (temp < temp_h)
                        temp_h = temp, best_i = i, best_j = j;
                }
            }
            state[i - 1] = record;
        }
        if (--tries_count == 0)
            tries_count = MAX_TRIES_IN_ONE_TEMPERATURE, temperature *= COLD_DOWN_RATE;
        if (!(temperature < STOP_TEMPERATURE) && (temp_h < h || ((double)(rand() % 1000) / 1000) < exp(temp_h / temperature)))
            state[best_i - 1] = best_j, h = temp_h;
        else {
            eight_queens_problem_failed_times++;
            return;
        }
    }
    eight_queens_problem_time += (double)(clock() - start_time) / CLK_TCK;
}

void solve_8_queens_problem() {
    FILE *fp = fopen("testcase_8_queens_problem", "r");
    int original_state[8];
    while (fscanf(fp, "%d %d %d %d %d %d %d %d", original_state, original_state + 1, original_state + 2, original_state + 3, original_state + 4, original_state + 5, original_state + 6, original_state + 7) != EOF)
        solve_one_case_of_8_queens_problem(original_state);
    fclose(fp);
}

void print_result() {
    printf("eight digits problem average solved times: %lf
", eight_digits_problem_time / (double)(TESRCASE - eight_digits_problem_failed_times));
    printf("eight digits problem solved rate: %lf
", 1 - double(eight_digits_problem_failed_times) / TESRCASE);
    printf("eight queens problem average solved times: %lf
", eight_queens_problem_time / (double)(TESRCASE - eight_queens_problem_failed_times));
    printf("eight queens problem solved rate: %lf
", 1 - double(eight_queens_problem_failed_times) / TESRCASE);
}

int main() {
    eight_digits_problem_time = 0;
    eight_queens_problem_time = 0;
    eight_digits_problem_failed_times = 0;
    eight_queens_problem_failed_times = 0;
    solve_8_digits_problem();
    solve_8_queens_problem();
    print_result();
    return 0;
}

这个测试时间比较久，题主跑了6个小时才跑出来，测试结果如下：

可以看到，模拟退火算法的性能是比较优秀的，和爬山法的解决效率只相差0-1个数量级。

而且解决率相比爬山法也大幅度提升，对于八数码问题问题解决率提升了10倍左右，对于八皇后问题解决率也提升了2倍多。

结论：

1. 解决NP问题用模拟退火算法在性能上和解决率上都有出色的表现。

2. 随机重启爬山法来达到很高的解决率，但是时间效率非常低下。

3. 爬山法有最高性能，但是问题解决率不堪入目。