骑士周游问题

问题：

给定一个n*n的棋盘，一个马从任意位置出发，按照马移动的规则，在不重复走任意一个点的前提下走完所有点，即跳n*n步以后需要遍历了整个棋盘。

思路：

首先就是暴力搜索，DFS+回溯。

#include <iostream>
#include <iomanip>
#include <ctime>
using namespace std;

const int N = 8;//棋盘的边长

int chess[N][N];//标记
int move[8][2] = { {1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2} };
int backNum = 0;//回溯次数
int resultNum,resultCount=0;//想要的解的个数，当前解的个数

void showTrail();//输出棋盘，显示路径

int main()
{
    void dfs(int x, int y, int cnt );

    int x,y;
    //初始化标记数组
    for( int i=0; i<N; ++i )
        for( int j=0; j<N; ++j )
            chess[i][j] = 0;

    cout << "please input location: x y \n";
    cin >> x >> y;
    cout <<"input result number you want:\n";
    cin >> resultNum;
    chess[x][y] = 1;

    clock_t start_time=clock();
    dfs(x,y,1);
    clock_t end_time=clock();

    cout << "back number is "<<backNum<<endl;
    cout<< "Running time is: "<<(double)(end_time-start_time)/CLOCKS_PER_SEC*1000<<"ms"<<endl;

    return 0;
}

void dfs(int x, int y, int cnt ){

    if( cnt==N*N ){
        ++resultCount;
        cout << "Answer "<<resultCount<<":\n";
        showTrail();
        return;
    }
    //如果解的个数达到了，立刻返回，不再寻找
    if( resultCount==resultNum )
        return;

    for( int i=0; i<8; ++i ){

        int x1 = x+move[i][0];
        int y1 = y+move[i][1];
        if( 0==chess[x1][y1] && x1>=0&&x1<N&&y1>=0&&y1<N ){

            chess[x1][y1] = cnt+1;

            dfs( x1, y1, cnt+1 );
            ++backNum;

            chess[x1][y1] = 0;
        }
    }
    return;
}

void showTrail(){

    for( int i=0; i<N; ++i ){
        for( int j=0; j<N; ++j )
            cout <<setw(5)<< chess[i][j];
        cout << endl;
    }
}

运行结果：

发现耗费时间太长了，迭代次数非常大（这是在N=7的情况下运行的）。

这个问题可以贪心地进行选择，从而增大成功找到路径的概率，其基本思想为：当马从点（x，y）移动时，假如可以跳到k个可行的位置，那么先跳到最难达到的那个点。

先把难到达的点走了，剩下的点都是比较容易到达的点，那么后面能走完的几率就大一些。反之，如果先把容易到达的点给走了，最后面发现那些难到达的点不能满足（并且这个几率比较大），那么前面就会浪费非常多的步骤。

#include <iostream>
#include <vector>
#include <iomanip>
#include <ctime>
#include <algorithm>
using namespace std;

const int N = 8;//棋盘的边长
const int INIFITE = 999999;//无穷大

int chess[N][N];//标记并记录路径
int move[8][2] = { {1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2} };//移动方式
int backNum = 0;//记录回溯次数
int resultNum,resultCount=0;//想要的解的个数，当前解的个数

struct next{
    int road_num;//可走的路的条数
    int dir_index;//方向索引，即move数组的第1个索引下标
};
bool cmp( next a, next b ){ return a.road_num<b.road_num; }

void showTrail();
int road_count(int x, int y);

int main()
{
    void dfs(int x, int y, int cnt );

    int x,y;
    //初始化标记数组
    for( int i=0; i<N; ++i )
        for( int j=0; j<N; ++j )
            chess[i][j] = 0;

    cout << "please input location: x y \n";
    cin >> x >> y;
    cout <<"input result number you want:\n";
    cin >> resultNum;
    chess[x][y] = 1;

    clock_t start_time=clock();
    dfs(x,y,1);
    clock_t end_time=clock();

    cout << "back number is "<<backNum<<endl;
    cout<< "Running time is: "<<(double)(end_time-start_time)/CLOCKS_PER_SEC*1000<<"ms"<<endl;

    return 0;
}

void dfs(int x, int y, int cnt ){

    if( cnt==N*N ){
        ++resultCount;
        cout << "Answer "<<resultCount<<":\n";
        showTrail();
        return;
    }
    //如果解的个数达到要求，就停止。
    if( resultCount==resultNum ){
        return;
    }

    vector<next> v;
    for( int i=0; i<8; ++i ){
        int num;
        int x1 = x+move[i][0];
        int y1 = y+move[i][1];
        num = road_count(x1,y1); //计算（x1,y1）的下一步可以走的点有多少。
        v.push_back( (next){num,i} );
    }
    sort( v.begin(), v.end(), cmp );


    for( int i=0; i<v.size(); ++i ){

        int x1 = x + move[v[i].dir_index][0];
        int y1 = y + move[v[i].dir_index][1];
        //cout <<a[i]<<": "<< x1<<','<<y1<<endl;
        if( 0==chess[x1][y1] && x1>=0&&x1<N&&y1>=0&&y1<N ){
            //cout <<a[i]<<": "<< x1<<','<<y1<<endl;
            chess[x1][y1] = cnt+1;

            dfs( x1, y1, cnt+1 );
            ++backNum;  //回溯次数加1
            chess[x1][y1] = 0;
        }
    }
    return;
}

void showTrail(){

    for( int i=0; i<N; ++i ){
        for( int j=0; j<N; ++j )
            cout <<setw(5)<< chess[i][j];
        cout << endl;
    }
}

int road_count(int x, int y){

    int cnt = 0;
    //如果这个点不在棋盘内，直接返一个无穷大表示此路不通
    if( 0!=chess[x][y]||x<0||x>=N||y<0||y>=N )
        return INIFITE;
    for( int i=0; i<8; ++i ){
        int x1 = x+move[i][0];
        int y1 = y+move[i][1];
        if( 0==chess[x1][y1]&&x1>=0&&x1<N&&y1>=0&&y1<N )
            ++cnt;
    }
    return cnt;
}

运行结果：

相同条件下，回溯次数明显减少了几个数量级。