HDOJ 1043 Eight(A* 搜索)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1043

思路分析：

<1> 搜索算法： A*算法， Heuristic函数：曼哈顿距离

<2> 剪枝技巧： 如果8数码问题中的初始状态的逆序数为奇数(除了’x’)，则不存在解；否则，存在解；

代码如下：

#include <queue>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int MAX_N =  + ;
int map[];
bool close[MAX_N];
char dir[MAX_N], direction[] = "udlr";
int open[MAX_N], pa[MAX_N], f[MAX_N];
const int FACT[] = {, , , , , , , , };
const int MOVE[][] = {{, -}, {, }, {-, }, {, }};

struct Node
{
    int id;
    int f, g, h;
    int flags;   // 表示该状态被松弛次数
    Node() {}
    Node(int a_id, int a_g, int a_h, int a_flags)
    {
        id = a_id, g = a_g, h = a_h, flags = a_flags;
        f = g + h;
    }
    friend bool operator<(const Node &lhs, const Node &rhs);
};
bool operator<(const Node &lhs, const Node &rhs)  { return lhs.f > rhs.f; }
priority_queue<Node> find_min;

int StateToCanto()
{
    int state_num = ;
    for (int i = ; i < ; ++i)
    {
        int temp = map[i] - ;

        for (int j = ; j < i; ++j)
            temp -= (map[j] < map[i]);
        state_num += temp * FACT[ - i];
    }
    return state_num;
}

int StateToId()
{
    int ans = ;

    for (int i = ; i < ; ++i)
        ans = ans *  + map[i];
    return ans;
}

void IdToState(int num)
{
    int i = ;
    while (num)
    {
        map[i--] = num % ;
        num /= ;
    }
}

int Heuristic()
{
    int sum = ;
    for (int i = ; i < ; i++)
    for (int j = ; j < ; j++)
    {
        int k = i *  + j;
        if (map[k] == ) continue;
        sum += abs(i - (map[k] - ) / ) + abs(j - (map[k] - ) % );
    }
    return sum;
}

inline bool inversionNumberCheck()
{
    int cnt = ;
    for (int i = ; i < ; ++i)
    {
        if (map[i] == ) continue;
        for (int k = i - ; k >= ; --k)
        {
            if (map[k] == ) continue;
            if (map[k] > map[i])
                cnt++;
        }
    }
    return cnt & ;
}

void FindX(int &x, int &y)
{
    for (int i = ; i < ; ++i)
    {
        if (map[i] == )
        {
            y = i / ;
            x = i % ;
            return;
        }
    }
}

int A_star()
{
    int state_canto, state_id;

    state_canto = StateToCanto();
    state_id = StateToId();
    open[state_canto] += ;
    Node start(state_id, , Heuristic(), open[state_canto]);
    f[state_canto] = start.f;
    find_min.push(start);
    pa[state_canto] = -;
    dir[state_canto] = '';

    if (state_id == )
        return state_canto;

    while (!find_min.empty())
    {
        Node parent = find_min.top();
        Node child;
        int p_x, p_y, c_x, c_y, parent_canto;
        find_min.pop();

        IdToState(parent.id);
        parent_canto = StateToCanto();
        if (parent.flags != open[parent_canto]) // 一个状态可能被松弛多次，检测parent是否为该状态最后一次松弛的状态
            continue;
        close[StateToCanto()] = ; // To do

        FindX(p_x, p_y);
        for (int i = ; i < ; ++i)
        {
            int temp_swap, child_state_conto;

            c_x = p_x;
            c_y = p_y;
            c_x += MOVE[i][];
            c_y += MOVE[i][];

            if (c_x <  || c_x >=  || c_y <  || c_y >= )
                continue;
            temp_swap = map[p_x + p_y * ];
            map[p_x + p_y * ] = map[c_x + c_y * ];
            map[c_x + c_y * ] = temp_swap;
            child_state_conto = StateToCanto();

            if (close[child_state_conto] == )
            {
                temp_swap = map[p_x + p_y * ];
                map[p_x + p_y * ] = map[c_x + c_y * ];
                map[c_x + c_y * ] = temp_swap;

                continue;
            }

            child.id = StateToId();
            if (child.id == )
            {
                pa[child_state_conto] = parent_canto;
                dir[child_state_conto] = direction[i];
                return child_state_conto;
            }

            child.h = Heuristic();
            child.g = parent.g + ;
            child.f = child.g + child.h;
            child.flags = open[child_state_conto] + ;
            pa[child_state_conto] = parent_canto;
            dir[child_state_conto] = direction[i];
            if (open[child_state_conto] ==  || f[child_state_conto] > child.f)
            {
                f[child_state_conto] = child.f;
                open[child_state_conto] = child.flags;
                find_min.push(child);
            }
            temp_swap = map[p_x + p_y * ];
            map[p_x + p_y * ] = map[c_x + c_y * ];
            map[c_x + c_y * ] = temp_swap;
        }
    }
    return -;
}

void Find(int i)
{
    if (pa[i] == -)
        return;
    else
    {
        Find(pa[i]);
        printf("%c", dir[i]);
    }
}

void PrintPath()
{
    int end_canto;

    for (int i = ; i < ; ++i)
        map[i] = i + ;
    end_canto = StateToCanto();

    Find(end_canto);
    printf("\n");
}

int main()
{
    int ans = ;

    while (scanf("%s", &map[]) != EOF)
    {
        map[] = (map[] == 'x' ?  : (map[] -= ''));
        for (int i = ; i < ; ++i)
        {
            scanf("%s", &map[i]);
            map[i] = (map[i] == 'x' ?  : (map[i] -= ''));
        }

        if (inversionNumberCheck())
        {
            printf("unsolvable\n");
            continue;
        }
        memset(open, , sizeof(open));
        memset(close, , sizeof(close));
        memset(pa, , sizeof(pa));
        memset(f, , sizeof(f));
        memset(dir, , sizeof(dir));
        ans = A_star();
        if (ans == -)
            printf("unsolvable\n");
        else
            PrintPath();

        while (find_min.empty())
            find_min.pop();
    }
    return ;
}