八皇后问题和八数码问题的最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法的分析和实现

源起

人工智能的第二次作业课后的某题要求对八皇后问题和八数码问题分别用最陡上升爬山法、首选爬山法、随机重启爬山法、模拟退火算法来实现，并且分析他们的性能。

---

分析

我们发现要求实现的各个算法是有共同点的，比如，八皇后问题相关算法拥有相同的状态空间，每个算法都有从当前状态获取下一状态的需求，各个算法细节不同，共同点是，它们都是算法。
基于这样的想法，我们可以将代码划分为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;
    }
};

//***************************************
// eightQueueRunner.cpp
// 包括八皇后问题的各个算法和简单交互界面实现
//***************************************
#include "eightQueue.hpp"
#include <iostream>
#include <math.h>

using namespace std;
eightQueueNodeFactory factory;

#define NUM_OF_LOOP 10000
#define NUM_OF_REBOOT 0
#define BEGIN_TEMP 10000
#define STOP_TEMP 1

void mostSteepClimbing();
void firstSeclectionClimbing();
void randomRebootClimbing();
void simulatedAnnealing();

int main() {

    int choice = 0;
    do{
        cout << endl;
        cout << "The Eight Queue Problem:" << endl;
        cout << "   0 -- most steep climbing" << endl;
        cout << "   1 -- first selection climbing" << endl;
        cout << "   2 -- random reboot climbing" << endl;
        cout << "   3 -- stimulated annealing" << endl;
        cout << "please input your choice: ";
        cin >> choice;
        if (choice == -1) break;
        switch(choice) {
            case 0:
                mostSteepClimbing();
                break;
            case 1:
                firstSeclectionClimbing();
                break;
            case 2:
                randomRebootClimbing();
                break;
            case 3:
                simulatedAnnealing();
                break;
            default:
                break;
        }
    }while(true);
    return 0;
}

void mostSteepClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        eightQueueNode curState = factory.getARandomNode();
        eightQueueNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getBestNextNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                break;
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}

void firstSeclectionClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        eightQueueNode curState = factory.getARandomNode();
        eightQueueNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getNextBetterNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                break;
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}

void randomRebootClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0, numOfReboot = NUM_OF_REBOOT;
        eightQueueNode curState = factory.getARandomNode();
        eightQueueNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getNextBetterNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                if(numOfReboot > 0) {
                    numOfReboot--;
                    curState = factory.getARandomNode();
                    tmp = curState;
                } else {
                    break;
                }
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }
        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}

void simulatedAnnealing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        double curTemp = BEGIN_TEMP;
        eightQueueNode curState = factory.getARandomNode();
        eightQueueNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            } else if(curTemp < STOP_TEMP){
                // 温度过低，则停止
                break;
            }

            // 走一步，则温度下降
            lenOfRoute++;
            curTemp -= 1;
            cost += factory.getARandomNeighbour(tmp);
            int deltaOfEvalutaion = factory.evaluate(tmp) - factory.evaluate(curState);
            if(deltaOfEvalutaion >= 0) {
                // 根据温度差来决定是否接受
                double probility = exp(curTemp/(deltaOfEvalutaion));
                if(rand() / double(RAND_MAX) < deltaOfEvalutaion) {
                    curState = tmp;
                }
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}

//***************************************************************
// eightDigit.hpp
// 包括八数码问题的eightDigitNode类和eightDigitFactory类的实现
// **************************************************************
#include <iostream>
#include <stdlib.h> 
#include <time.h> 
#include <math.h>

#define LOOP_OF_SHUFFLE 50

class eightDigitNode {
public:
    int arr[9];
    int blank_x = 2, blank_y = 2;
    eightDigitNode(){
        for(int i = 0; i < 8; i++) {arr[i] = i+1;}
    arr[8] = 0;
    }
    ~eightDigitNode(){}
    eightDigitNode(const eightDigitNode& 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];
        arr[8] = node.arr[8];
        blank_x = node.blank_x;
        blank_y = node.blank_y;
    }
    bool operator==(const eightDigitNode& node) {
        for(int i = 0; i < 8; i++) {
            if(arr[i] != node.arr[i]) return false;
        }
        return true;
    }

    bool goLeft() {
        if(blank_y == 0) {
            return false;
        } else {
            arr[blank_x*3+blank_y] = arr[blank_x*3+blank_y-1];
            arr[blank_x*3+blank_y-1] = 0;
            blank_y--;
            return true;
        }
    }

    bool goRight() {
        if(blank_y == 2) {
            return false;
        } else {
            arr[blank_x*3+blank_y] = arr[blank_x*3+blank_y+1];
            arr[blank_x*3+blank_y+1] = 0;
            blank_y++;
            return true;
        }
    }

    bool goUp() {
        if(blank_x == 0) {
            return false;
        } else {
            arr[blank_x*3+blank_y] = arr[(blank_x-1)*3+blank_y];
            arr[(blank_x-1)*3+blank_y] = 0;
            blank_x--;
            return true;
        }
    }

    bool goDown() {
        if(blank_x == 2) {
            return false;
        } else {
            arr[blank_x*3+blank_y] = arr[(blank_x+1)*3+blank_y];
            arr[(blank_x+1)*3+blank_y] = 0;
            blank_x++;  
            return true;
        }
    }
};

class eightDigitNodeFactory{
private:
    int getManhattanDistian(const int& src, const int& target) {
        return abs(src%3 - target%3) + abs(src/3 - target/3); 
    }
    int getNumOfWrongNumber(const eightDigitNode& node) {
        int res = 0;
        for(int i = 0; i < 8; i++) {
            if (node.arr[i] != i+1) res++;
        }
        if(node.arr[8] != 0) res++;
        return res; 
    }
    bool getANeighbourNode(int direction, eightDigitNode& node) {
        switch(direction) {
                case 0: return node.goLeft();
                case 1: return node.goUp();
                case 2: return node.goRight();
                default:
                        return node.goDown();
            }
    }

    bool isTheArrayAllTrue(bool isAllCheck[4]) {
            for(int i = 0; i < 4; i++) {
                if(isAllCheck[i] == false) {
                    return false;
                }
            }
            return true;
        }

public:
    eightDigitNodeFactory() {
        srand((unsigned)time(NULL));
    }

    eightDigitNode getARandomNode() {
        eightDigitNode output;
        int timesOfShuffle = rand() % LOOP_OF_SHUFFLE;
        while(timesOfShuffle--) {
            while(!getANeighbourNode(rand()%4, output));
        }
        return output;
    }

    int evaluate(const eightDigitNode& node) {
        eightDigitNode tmp;
        int distanceToTargetState = 0;
        for(int i = 0; i < 9; i++) {
            int j = 0;
            while(tmp.arr[j] != node.arr[i]) {j++;}
            distanceToTargetState += getManhattanDistian(i, j);
        }
        return distanceToTargetState + 3*getNumOfWrongNumber(node);
    }

    int getBestNextNode(eightDigitNode& node) {
        eightDigitNode tmp = node, ans = node;
        for(int i = 0; i < 4; i++) {
            tmp = node;
            if(getANeighbourNode(i, tmp) && evaluate(tmp) < evaluate(ans)) {
                ans = tmp;
            } else if(evaluate(tmp) == evaluate(ans)) {
                if(rand() / double(RAND_MAX) > 0.5) {
                    ans = tmp;
                }
            }
        }
        node = ans;
        return 4;
    }

    int getNextBetterNode(eightDigitNode& node) {
        bool isAllCheck[4];
        for(int i = 0; i < 4; i++) {isAllCheck[i] = false;}

        eightDigitNode tmp = node;
        int costOfSearch = 1;
        while(evaluate(tmp) >= evaluate(node)) {
            // 子节点全部搜索过，都比当前差
            if(isTheArrayAllTrue(isAllCheck)) return costOfSearch;
            // 初始化，找下一邻居
            tmp = node;
            int a = rand() % 4;
            isAllCheck[a] = true;
            getANeighbourNode(a, tmp);
            costOfSearch++;
            if(tmp == node) {
                continue;
            }
        }
        node = tmp;
        return costOfSearch;
    }

    int getARandomNeighbour(eightDigitNode& node) {
        int costOfSearch = 0;
        eightDigitNode tmp = node;
        while(!getANeighbourNode(rand()%4, tmp)) {
            costOfSearch++;
            tmp = node;
        }
        node = tmp;
        return costOfSearch;
    }
};

//*********************************************
// eightDigitRunner.cpp
// 包括八数码问题各算法的和简单交互界面实现
//********************************************
#include "eightDigit.hpp"
#include <iostream>
#include <math.h>

using namespace std;
eightDigitNodeFactory factory;

#define NUM_OF_LOOP 10000
#define NUM_OF_REBOOT 7
#define BEGIN_TEMP 100000
#define STOP_TEMP 1

void mostSteepClimbing();
void firstSeclectionClimbing();
void randomRebootClimbing();
void simulatedAnnealing();

int main() {
    int choice = 0;
    do{
        cout << endl;
        cout << "The Eight Digit Problem:" << endl;
        cout << "   0 -- most steep climbing" << endl;
        cout << "   1 -- first selection climbing" << endl;
        cout << "   2 -- random reboot climbing" << endl;
        cout << "   3 -- stimulated annealing" << endl;
        cout << "please input your choice: ";
        cin >> choice;
        if (choice == -1) break;
        switch(choice) {
            case 0:
                mostSteepClimbing();
                break;
            case 1:
                firstSeclectionClimbing();
                break;
            case 2:
                randomRebootClimbing();
                break;
            case 3:
                simulatedAnnealing();
                break;
            default:
                break;
        }
    }while(true);
    return 0;
}

void mostSteepClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        eightDigitNode curState = factory.getARandomNode();
        eightDigitNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getBestNextNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                break;
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}

void firstSeclectionClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        eightDigitNode curState = factory.getARandomNode();
        eightDigitNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getNextBetterNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                break;
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}
void randomRebootClimbing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        eightDigitNode curState = factory.getARandomNode();
        eightDigitNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            }

            lenOfRoute++;
            cost += factory.getNextBetterNode(tmp);
            if(factory.evaluate(tmp) >= factory.evaluate(curState)) {
                break;
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;
}
void simulatedAnnealing() {
    int sumOfsuccess = 0, sumOfFailure = 0;
    double theSumOfCostOfSearchOfSuccess = 0, theSumLengthOfSolutionOfSuccess = 0;
    for(int i = 0; i < NUM_OF_LOOP; i++) {
        bool success = false;
        int cost = 0, lenOfRoute = 0;
        double curTemp = BEGIN_TEMP;
        eightDigitNode curState = factory.getARandomNode();
        eightDigitNode tmp = curState;
        while(true) {
            // if satisfied, then break
            if (factory.evaluate(curState) == 0) {
                success = true;
                break;
            } else if(curTemp < STOP_TEMP){
                // 温度过低，则停止
                break;
            }

            // 走一步，则温度下降
            lenOfRoute++;
            curTemp -= 1;
            cost += factory.getARandomNeighbour(tmp);
            int deltaOfEvalutaion = factory.evaluate(tmp) - factory.evaluate(curState);
            if(deltaOfEvalutaion >= 0) {
                // 根据温度差来决定是否接受
                double probility = exp(curTemp/(deltaOfEvalutaion));
                if(rand() / double(RAND_MAX) < deltaOfEvalutaion) {
                    curState = tmp;
                }
            } else {
                curState = tmp;
            }
        }

        if(success) {
            sumOfsuccess++;
            theSumOfCostOfSearchOfSuccess += cost;
            theSumLengthOfSolutionOfSuccess += lenOfRoute;
        } else {
            sumOfFailure++;
        }

        // output
        cout << "case " << i << "  cost: " << cost << " " << "lengthOfSolution: " << lenOfRoute << " ";
        if(success){
            cout << "success ";
        } else {
            cout << "failure ";
        }
        cout << endl;
    }
    cout << "Sum of success: " << sumOfsuccess << endl;
    cout << "Sum of failure " << sumOfFailure << endl;
    cout << "Rate of success " << sumOfsuccess/((double)(sumOfFailure + sumOfsuccess)) << endl;  
    cout << "The average solution length of success:" << theSumLengthOfSolutionOfSuccess/NUM_OF_LOOP << endl;
    cout << "The average cost of search of success:" << theSumOfCostOfSearchOfSuccess/NUM_OF_LOOP << endl;  
    return;