POJ 1077 Eight（BFS + A* + 逆序对剪枝）

题意：

一个3*3的棋盘里，给8个格子填上1-8这8个数，另一个格子空着。每一步，可以将与空格相邻的格子与空格换位，换位方式可间接体现成空格进行上下左右的移动。先给定一个棋盘状态，问能否经过若干步后，将棋盘变成第一行123，第二行456，第三行78空的状态。若能，输出任意一种可行步骤。

思路：

1. 对于 123456789 的某个全排列，使用 hash 表来记录状态显得浪费。本题采用了康托展开，对于每一个排列生成唯一一个键值;

2. 普通 BFS 能过，但是时间复杂度太高。这里采用启发式的方法 f = h + g; g 表示状态 s 在搜索树中的深度，h 表示状态 s 距离目标状态的曼哈顿距离;

3. 通过 1, 2 时间空间上已经比较优化了，但是还可以再对其进行剪枝。对于 x，如果在所在行移动，逆序数对不变，如果在列上移动，逆序数对成偶数加减，根据这点来判断某个状态是否有可行解的潜质，最终代码优化到了 16ms. 不过还是在HDOJ 1043 WA;

http://zh.wikipedia.org/wiki/%E5%BA%B7%E6%89%98%E5%B1%95%E5%BC%80  康托展开

http://zh.wikipedia.org/wiki/%E6%9B%BC%E5%93%88%E9%A0%93%E8%B7%9D%E9%9B%A2 曼哈顿距离

 

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

const int MAXN = 362880 + 10;
const int fac[15] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
const char dir[5] = {0, 'u', 'd', 'l', 'r'};
const int dis[9][2] = {{0,0}, {0,1}, {0,2}, {1,0}, {1,1}, {1,2}, {2,0}, {2,1}, {2,2}};

bool vis[MAXN];
int F[MAXN], ENDS;
char OP[MAXN];

struct ST {
    char e[10];
    int f, step;
    bool operator < (const ST& other) const {
        return f > other.f;
    }
};

int getvalue(const char e[]) {
    int ans = 0, count;
    for (int i = 0; i < 8; i++) {
        count = 0;
        for (int j = i + 1; j < 9; j++) {
            if (e[i] > e[j]) count += 1;
        }
        ans += fac[8-i] * count;
    }
    return ans;
}

bool challenge(ST& s, int pos, int op) {
    if (op == 1) {
        // up
        if (pos >= 3) {
            swap(s.e[pos-3], s.e[pos]);
            return true;
        }
    } else if (op == 2) {
        // down
        if (pos < 6) {
            swap(s.e[pos], s.e[pos+3]);
            return true;
        }
    } else if (op == 3) {
        // left
        if (pos % 3) {
            swap(s.e[pos-1], s.e[pos]);
            return true;
        }
    } else if (op == 4) {
        // right
        if ((pos + 1) % 3) {
            swap(s.e[pos], s.e[pos+1]);
            return true;
        }
    }
    return false;
}

int getdiff(const char e[]) {
    int ret = 0;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            int k = 3 * i + j;
            if (e[k] != 9) {
                ret += abs(i - dis[e[k]-1][0]) + abs(j - dis[e[k]-1][1]);
            }
        }
    }
    return ret;
}

bool judge(const char e[]) {
    int sum = 0;
    for (int i = 0; i < 9; i++) {
        if (e[i] != 9) {
            for (int j = i + 1; j < 9; j++)
                if (e[i] > e[j])  sum += 1;
        }
    }
    return !(sum & 0x01);
}

bool bfs(ST& s) {
    priority_queue<ST> Q;

    s.step = 0;
    s.f = s.step + getdiff(s.e);

    Q.push(s);
    
    int vals = getvalue(s.e);
    F[vals] = -1;
    OP[vals] = 0;
    vis[vals] = true;

    while (!Q.empty()) {
        ST u = Q.top();
        Q.pop();

        int pos;
        for (int i = 0; i < 9; i++)
            if (u.e[i] == 9) pos = i;

        for (int i = 1; i <= 4; i++) {
            ST v = u;
            if (challenge(v, pos, i)) {
                int state = getvalue(v.e);
                if (!vis[state] && judge(v.e)) {
                    vis[state] = true;
                    v.step = u.step + 1;
                    v.f = v.step + getdiff(v.e);
                    Q.push(v);

                    F[state] = getvalue(u.e);
                    OP[state] = dir[i];

                    if (state == ENDS)
                        return true;
                }
            }
        }
    }
    return false;
}

int main() {
    ST u, E;
    for (int i = 0; i < 9; i++)
        E.e[i] = i + 1;
    ENDS = getvalue(E.e);

    char ch[100];
    while (gets(ch)) {
        for (int i = 0, j = 0; ch[i]; i++) {
            if (ch[i] != ' ') {
                if (ch[i] == 'x')
                    u.e[j++] = 9;
                else
                    u.e[j++] = ch[i] - '0';
            }
        }

        if (getvalue(u.e) == ENDS) {
            //printf("lr\n");
            continue;
        }

        int j = 0;
        char opcode[1000];

        memset(vis, false, sizeof(vis));
        memset(F, -1, sizeof(F));
        memset(OP, 0, sizeof(OP));

        if (judge(u.e) && bfs(u)) {
            for (int i = ENDS; i != -1; i = F[i])
                opcode[j++] = OP[i];
            for (int i = j-2; i >= 0; i--)
                printf("%c", opcode[i]);
            printf("\n");
        } else {
            printf("unsolvable\n");
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/kedebug/archive/2013/03/23/2977232.html