sicily 1152 简单的马周游问题

如果看懂题目了就知道是一个深度优先搜索，但是可以发现搜索的范围是比较大的，很容易就超时了。

所以要在搜索时做一些约束，比如说优先搜索下一步可能节点中能够走的下一步位置数最小的.

好像说起来比较拗口，可以举个例子，从15开始，它能走的是2、4、7、11、19、23、26和28，那么2能走的地方只有13跟10，而23能走的是27、10和12，那么在2和23之间，会优先选择2作为走完15后的下一步，然后以此类推。

我超时了n次，一开始是自己写的排序，然后发现竟然效率那么差！后来又在网上搜了一下，还是用了库的排序算法。

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

const int row = 5;
const int col = 6;
const int size = 30;

int direct[ 8 ][ 2 ] = { -2, 1, -1, 2,
    1, 2, 2, 1,
    2, -1, 1, -2, 
    -1, -2, -2, -1 };

struct node
{
    int position;
    int canmove;
};

vector< node > nextWill[ size ];
bool visit[ size ];
int path[ size ];
bool flag;

// 计算马的下一个位置
int calNext( int begin, int dir )
{
    int x = begin / col;
    int y = begin % col;
    x += direct[ dir ][ 0 ];
    y += direct[ dir ][ 1 ];

    // 如果出界就返回-1
    if( x < 0 || x >= row )
        return -1;
    if( y < 0 || y >= col )
        return -1;
    return y + x * col;
}

// 计算能移动的方向个数
int calNum( int pos )
{
    int size = 0;
    for( int i = 0; i < 8; i++ )
        if( calNext( pos, i ) != -1 )
            size++;
    return size;
}

bool cmp( node a, node b )
{
    return a.canmove < b.canmove;
}

// 计算路径
void calPath( int level )
{
    // 到达结束标志: 搜到了最后一层
    if( level >= size - 1 )
    {
        flag = true;
        return;
    }

    // 当前层里可能走的下一个位置
    nextWill[ level ].clear();
    for( int i = 0; i < 8; i++ )
    {
        // 可能的下一个位置
        int next = calNext( path[ level ], i );
        if( next == -1 || visit[ next ] )
            continue;
        // 下一个位置可以继续走的方向个数
        int num = calNum( next );

        if( num > 0 )
        {
            node temp;
            temp.position = next;
            temp.canmove = num;
            nextWill[ level ].push_back( temp );
        }
    }

    sort( nextWill[ level ].begin(), nextWill[ level ].end(), cmp );

    int leng = nextWill[ level ].size();
    if( leng <= 0 )
        return;

    // 标记当前节点是被访问的
    visit[ path[ level ] ] = true;
    for( int i = 0; i < leng; i++ )
    {
        if( flag )
            return;
        // 先把下一个可能的位置添加到path中
        path[ level + 1 ] = nextWill[ level ][ i ].position;
        calPath( level + 1 );
    }
    visit[ path[ level ] ] = false;
}

int main()
{
    int begin;
    while( cin >> begin && begin != -1 )
    {
        memset( visit, false, size * sizeof( bool ) );
        memset( path, size, size * sizeof( int ) );

        path[ 0 ] = begin - 1;
        flag = false;
        calPath( 0 );
        for( int i = 0; i < size - 1; i++ )
            cout << path[ i ] + 1 << " ";
        cout << path[ size - 1 ] + 1 << endl;
    }
    return 0;
}