八数码 poj1077 Eight（A*、IDA*)

最新推荐文章于 2020-03-01 18:25:06 发布
原创 最新推荐文章于 2020-03-01 18:25:06 发布 · 2.6k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#搜索 #八数码

本文主要探讨八数码问题的解决方案，重点在于A*和IDA*搜索算法。通过状态表示、判重方法以及A*算法的估价函数深入解析这两种启发式搜索策略。A*算法结合历史信息与启发信息，而IDA*通过迭代加深避免了判重和使用优先队列，空间效率更高。
部署运行你感兴趣的模型镜像

八数码主要参考：刘亚宁学长的八数码八境界 等

A*主要参考：百度百科，初识A*算法，深入A*算法 等

IDA*主要参考：http://blog.youkuaiyun.com/urecvbnkuhbh_54245df/article/details/5856756，http://blog.youkuaiyun.com/nomad2/article/details/6562140 等


人工智能课的作业，借此研究下八数码，及相关的搜索算法

八数码（九宫格）是一个空间搜索的问题，而且空间只有9！（362 880）的大小，只是10e5的数量级。

八数码的解决的方案由很多：

（1）非启发性的搜索：暴力广搜，双向广搜，迭代加深的深搜；

（2）启发性搜索：A*，IDA*；（启发性算法有局部择优搜索和最好优先搜索，A*和IDA*都属于最好优先搜索，局部择优搜索有爬山算法，不过还没有研究）

（3）基于概率的随机搜索；遗传算法（比较有名的还有蚁群算法，模拟退火算法等智能搜索，不过没有研究）


本文主要说明A*、IDA*的搜索解法。

下面是搜索可能用到的问题的分析处理

（1）状态表示每一个状态用一个二维数组记录当前的八数码位置信息，并用记录其它属性


（2）判重方法，hash方法。

1）比较直接的是hash成字符串在，set中判重，不过字符串的操作和set的处理，效率可能要低些

2）将九宫格的hash成十进制（或九进制的表示），不过表示的实际的数据范围要大于真实空间（9! ），因为有一些数据是不可能出现在九宫格中的，

比如数据：（111111111） 是不可能出现在九宫格中

3）利用康托展开，康拓展开计算了，一个排列在所有的全排列的名次。比如4个数的一个排列3 2 1 4，其在4的全排列的名次是 2 * （3！）+ 1 * (2!) + 0 * (1！) + 0 *（0！）；其中第i个数是ai：则康拓展开的ai处的值 = （排列中ai后面比ai小的数的个数） * （ai后面数的个数的阶乘）；这样就完全没有空间的浪费，所以采用此法。


（3）关于A*算法。A*算法是一个启发性算法，最好优先搜索算法。关键在于其估价函数，

状态n 的估价值为：f‘（n）= g'（n）+ h'(n)；

g’（n）表示从初始状态开始到状态n的最短路径值（最小消耗值），h'（n）表示重状态n到终止状态的最短路经值的启发值。由于f‘(n)实现不可知，所以用f（n）来代替 

f（n）= g（n）+ h（n）；

g（n）表示初始状态到状态n的实际路径值（消耗值）（代表搜索历史信息），是已知的，h（n）表示状态n到终止状态的消耗估计值，包含着搜索的启发信息。

满足条件：1)g（n）> =g'(n)通常是满足的

    2)h(n) <= h'(n),满足此条件时，可以保证最优解

h（n）的取值可以是，状态n和终止状态中不同位置数字的个数，也可以是没有就位数字到相应位置的曼哈顿距离之和（选择此法）。

关于估价函数的理解，还有待加深。。。

关于A*的理解。A*和之前的广度优先搜索，和优先队列的搜索（最短路的dij算法）很相似。它们搜索的区别就在于估价函数不同而已。

A*既包含历史信息，也包含启发信息，广搜和优先对列的搜索则只有历史信息，没有启发信息。

广搜的估价函数值就是其搜索的深度（或实际的路径值，只不过边值是1）（历史信息，也可以说是最短路径值，其实仔细考虑也是状态图所决定的，可以说是状态的属性），是A*的特例；

优先对列的搜索的估价函数则是从初始状态到n状态的实际路径值，只不过边值不一定是1而已（历史信息，也可以说最短路径值），也可以说是A*的特例。

当然还有待加深理解。。。


（4）A*解法的过程见：百度百科

数据结构Open表，Close表

Open表即优先队列或最小堆，用priority_queue时不能实现修改值，则直接插入即可；自己实现的最小堆，可以实现修改值，效率更高。（还没有实现最小堆的方法）

Close表即hash_tab[]，利用康托展开后，hash到一个数组中，实现判重。


（5）IDA*，迭代加深的A*，或者说是迭代加深的深度优先搜索。此法不用判重，不用优先队列。只是普通的迭代加深的深度优先搜索+利用股价函数的剪枝，枚举估价值MaxH，利用估价函数剪枝，当节点估价函数的值大于MaxH。关键在于剪枝。

不需要判重的原因是，估价函数中包含了历史信息（深度信息），当超过规定的枚举深度MaxH，即剪去。

还有的一个剪枝是，不走相邻的重复路（不如，走left后走right）

值得注意的是，相对于A*，其不仅方法简单，而且，空间使用要小很多

（6）优先对列的使用是该注意下了。


具体代码：

A*：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <queue>

using namespace std;

///Data!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
struct node {
    int tab[3][3];///table
    int r, c;///0的位置
    int hash_val;///hash值

    node* pre;
    int op;///path
    int f, g;///估价函数

    bool operator<(const node &a) const {
        return f > a.f;
    }
}st, ed;
node t[370000];
int tot;
int hash_tab[370000];///362880
priority_queue<node>open;
int fn[10];
int ed_map[10][2];
int dir_i[4] = {0, 0, 1, -1};///r, l, u, d
int dir_j[4] = {1, -1, 0, 0};
char print_op[4] = {'r', 'l', 'd', 'u'};
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

void out(node a);
///Calc!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_hash(node a) {
    int ret;
    ret = 0;
    int num = 8;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            int x = 0;
            for (int jj = j + 1; jj < 3; jj++)
                if (a.tab[i][jj] < a.tab[i][j]) x++;///
            for (int ii = i + 1; ii < 3; ii++)
                for (int jj = 0; jj < 3; jj++)
                    if (a.tab[ii][jj] < a.tab[i][j]) x++;

            ret += fn[num] * x;
            num--;
        }
    return ret;
}
int get_f(node a, int g) {///f = g + h;
    int h = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (a.tab[i][j])///不考虑零
                h += abs(i - ed_map[a.tab[i][j]][0]) + abs(j - ed_map[a.tab[i][j]][1]);
    return g + h;
}
void change(node &tmp, node a, int nextr, int nextc, int i, int idx) {
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        tmp.tab[i][j] = a.tab[i][j];
    swap(tmp.tab[nextr][nextc], tmp.tab[a.r][a.c]);
    tmp.hash_val = get_hash(tmp);

    tmp.r = nextr; tmp.c = nextc;
    tmp.pre = &t[idx];///!!!
    tmp.op = i;
    tmp.g = a.g + 1;
    tmp.f = get_f(tmp, tmp.g);
}
int check(int i, int j) {
    if (i > 2 || i < 0 || j > 2 || j < 0) return 0;
    return 1;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

///Input()Init()
void input(node &st) {
    char ch;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            scanf(" %c", &ch);
            if (ch <= '9' && ch > '0') st.tab[i][j] = ch - '0';
            else { st.r = i; st.c = j; st.tab[i][j] = 0; }
        }
}
void In(char s[], node &st)
{
    char ch;
    int next = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            while (s[next] == ' ') next++;
            ch = s[next++];
            if (ch <= '9' && ch > '0') st.tab[i][j] = ch - '0';
            else { st.r = i; st.c = j; st.tab[i][j] = 0; }
        }
}
void pre()
{
    fn[0] = 1;
    for (int i = 1; i < 9; i++) fn[i] = i * fn[i - 1];

    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        ed.tab[i][j] = (i * 3) + j + 1;
    ed.tab[2][2] = 0;
    ed.hash_val = get_hash(ed);

    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        if (ed.tab[i][j]) {
                ed_map[ed.tab[i][j]][0] = i; ed_map[ed.tab[i][j]][1] = j;
        }
}
void init() {

    memset(hash_tab, 0, sizeof(hash_tab));
    while (!open.empty()) open.pop();
    tot = 0;

    st.f = get_f(st, 0);
    st.g = 0;
    st.hash_val = get_hash(st);
    open.push(st);
    hash_tab[st.hash_val] = 1;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

void path(node* a) {
    if (a->hash_val == st.hash_val) return ;
    path(a->pre);
    printf("%c", print_op[a->op]);
}

void out_table(node a) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++)
        cout << a.tab[i][j] << ' ';
        cout <<endl;
    }
    cout <<endl;
}

///astar
void astar() {
    int s = 0;
    int nextr, nextc;
    node ans = st;
    int fla = 0;

    if (st.hash_val != ed.hash_val)
    while (!open.empty()) {
        node a = open.top(); open.pop();
        t[++tot] = a;///

        for (int i = 0; i < 4; i++) {
            nextr = a.r + dir_i[i];
            nextc = a.c + dir_j[i];
            if (check(nextr, nextc)) {
                node tmp;
                change(tmp, a, nextr, nextc, i, tot);
                if (hash_tab[tmp.hash_val]) continue;
                if (tmp.hash_val == ed.hash_val) { fla = 1; ans = tmp; break; };
                open.push(tmp);
            }
        }
        if (fla) break;
        hash_tab[a.hash_val] = 1;
    }
    path(&ans);
    puts("");
}

///main!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_preval(node a) {
    int ret = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if (!a.tab[i][j]) continue;
            int x = 0;
            for (int jj = j + 1; jj < 3; jj++)
                    if (a.tab[i][jj] && a.tab[i][jj] < a.tab[i][j]) x++;///
            for (int ii = i + 1; ii < 3; ii++)
                for (int jj = 0; jj < 3; jj++)
                    if (a.tab[ii][jj] && a.tab[ii][jj] < a.tab[i][j]) x++;
            ret += x;
        }
    return ret % 2;
}
bool pre_solve() {
    return (get_preval(st) ^ get_preval(ed));
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

int main() {
    char ss[12];
    while (gets(ss))
    {
        pre();
        In(ss, st);
//        input(st);
        init();
    //    input(ed);
    //    out_table(st);
    //    out_table(ed);

        if (pre_solve()) puts("unsolvable");
        else astar();
    }
    return 1;
}


/*
1 2 3 x 4 6 7 5 8
x 2 3 1 4 6 7 5 8

1 2 3 x 4 6 7 5 8
1 2 3 4 x 6 7 5 8


1 2 3 4 5 x 7 8 6

1 2 3 4 x 8 7 6 5
*/

另种优先队列的使用和路径记录法： 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <queue>

using namespace std;

///Data!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
struct node {
    int tab[3][3];///table
    int r, c;///0的位置
    int hash_val;///hash值

    int pre;
    int op;///path
    int f, g;///估价函数

    bool operator<(const node &a) const {
        return f > a.f;
    }
};
node t[370000];
int tot;
struct cmp{
    bool operator()(int x, int y)
    {
        return t[x].f > t[y].f;
    }
};
int st, ed;
int hash_tab[370000];///362880
priority_queue<int, vector<int>, cmp>open;
int fn[10];
int ed_map[10][2];
int dir_i[4] = {0, 0, 1, -1};///r, l, u, d
int dir_j[4] = {1, -1, 0, 0};
char print_op[4] = {'r', 'l', 'd', 'u'};
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

void out(node a);
///Calc!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_hash(node a) {
    int ret;
    ret = 0;
    int num = 8;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            int x = 0;
            for (int jj = j + 1; jj < 3; jj++)
                if (a.tab[i][jj] < a.tab[i][j]) x++;///
            for (int ii = i + 1; ii < 3; ii++)
                for (int jj = 0; jj < 3; jj++)
                    if (a.tab[ii][jj] < a.tab[i][j]) x++;

            ret += fn[num] * x;
            num--;
        }
    return ret;
}
int get_f(node a, int g) {///f = g + h;
    int h = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (a.tab[i][j])///不考虑零
                h += abs(i - ed_map[a.tab[i][j]][0]) + abs(j - ed_map[a.tab[i][j]][1]);
    return g + h;
}
void change(int tmp, int a, int nextr, int nextc, int i) {
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        t[tmp].tab[i][j] = t[a].tab[i][j];
    swap(t[tmp].tab[nextr][nextc], t[tmp].tab[t[a].r][t[a].c]);
    t[tmp].hash_val = get_hash(t[tmp]);

    t[tmp].r = nextr; t[tmp].c = nextc;
    t[tmp].pre = a;///!!!
    t[tmp].op = i;
    t[tmp].g = t[a].g + 1;
    t[tmp].f = get_f(t[tmp], t[tmp].g);
}
int check(int i, int j) {
    if (i > 2 || i < 0 || j > 2 || j < 0) return 0;
    return 1;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

///Input()Init()
void input(node &a) {
    char ch;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            scanf(" %c", &ch);
            if (ch <= '9' && ch > '0') a.tab[i][j] = ch - '0';
            else { a.r = i; a.c = j; a.tab[i][j] = 0; }
        }
}
void In(char s[], node &st)
{
    char ch;
    int next = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            while (s[next] == ' ') next++;
            ch = s[next++];
            if (ch <= '9' && ch > '0') st.tab[i][j] = ch - '0';
            else { st.r = i; st.c = j; st.tab[i][j] = 0; }
        }
}
void pre()
{
    tot = 0;
    st = tot++;
    ed = tot++;

    fn[0] = 1;
    for (int i = 1; i < 9; i++) fn[i] = i * fn[i - 1];

    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        t[ed].tab[i][j] = (i * 3) + j + 1;
    t[ed].tab[2][2] = 0;
    t[ed].hash_val = get_hash(t[ed]);

    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        if (t[ed].tab[i][j]) {
                ed_map[t[ed].tab[i][j]][0] = i; ed_map[t[ed].tab[i][j]][1] = j;
        }
}
void init() {

    memset(hash_tab, 0, sizeof(hash_tab));
    while (!open.empty()) open.pop();

    t[st].f = get_f(t[st], 0);
    t[st].g = 0;
    t[st].hash_val = get_hash(t[st]);
    open.push(st);
    hash_tab[t[st].hash_val] = 1;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

void path(int x) {
    if (t[x].hash_val == t[st].hash_val) return ;
    path(t[x].pre);
    printf("%c", print_op[t[x].op]);
}

void out_table(node a) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++)
        cout << a.tab[i][j] << ' ';
        cout <<endl;
    }
    cout <<endl;
}

///astar
void astar() {
    int s = 0;
    int nextr, nextc;
    int ans = st;
    int fla = 0;

    if (t[st].hash_val != t[ed].hash_val)
    while (!open.empty()) {
        int a = open.top(); open.pop();

        for (int i = 0; i < 4; i++) {
            nextr = t[a].r + dir_i[i];
            nextc = t[a].c + dir_j[i];
            if (check(nextr, nextc)) {
                int tmp = tot++;
                change(tmp, a, nextr, nextc, i);
                if (hash_tab[t[tmp].hash_val]) continue;
                if (t[tmp].hash_val == t[ed].hash_val) { fla = 1; ans = tmp; break; };
                open.push(tmp);
            }
        }
        if (fla) break;
        hash_tab[t[a].hash_val] = 1;
    }
    path(ans);
    puts("");
}

///main!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_preval(node a) {
    int ret = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if (!a.tab[i][j]) continue;
            int x = 0;
            for (int jj = j + 1; jj < 3; jj++)
                    if (a.tab[i][jj] && a.tab[i][jj] < a.tab[i][j]) x++;///
            for (int ii = i + 1; ii < 3; ii++)
                for (int jj = 0; jj < 3; jj++)
                    if (a.tab[ii][jj] && a.tab[ii][jj] < a.tab[i][j]) x++;
            ret += x;
        }
    return ret % 2;
}
bool pre_solve() {
    return (get_preval(t[st]) ^ get_preval(t[ed]));
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

int main() {
    char ss[12];
    while(gets(ss))
    {
        pre();
//        input(t[st]);
        In(ss, t[st]);
        init();
    //    input(ed);
    //    out_table(st);
    //    out_table(ed);

        if (pre_solve()) puts("unsolvable");
        else astar();
    }
    return 1;
}


/*
1 2 3 x 4 6 7 5 8
x 2 3 1 4 6 7 5 8

1 2 3 x 4 6 7 5 8
1 2 3 4 x 6 7 5 8


1 2 3 4 5 x 7 8 6

1 2 3 4 x 8 7 6 5
*/

IDA*法： 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

///Data!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
struct node {
    int tab[3][3];///table
    int r, c;///0的位置
    int f, g;///估价函数
}st, ed;
int ed_map[10][2];
int dir_i[4] = {0, 0, 1, -1};///r, l, u, d
int dir_j[4] = {1, -1, 0, 0};
char print_op[4] = {'r', 'l', 'd', 'u'};
int MaxH;
//stack<int>sk;
int ans[5000000];
int ansn;
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

///Calc!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_f(node a, int g) {///f = g + h;
    int h = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (a.tab[i][j])///不考虑零
                h += abs(i - ed_map[a.tab[i][j]][0]) + abs(j - ed_map[a.tab[i][j]][1]);
    return g + 2 * h;
}
void change(node &tmp, node a, int nextr, int nextc, int i) {
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        tmp.tab[i][j] = a.tab[i][j];
    swap(tmp.tab[nextr][nextc], tmp.tab[a.r][a.c]);

    tmp.r = nextr; tmp.c = nextc;
    tmp.g = a.g + 1;
    tmp.f = get_f(tmp, tmp.g);
}
int check(int i, int j) {
    if (i > 2 || i < 0 || j > 2 || j < 0) return 0;
    return 1;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

///Input()Init()
void input(node &st) {
    char ch;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            scanf(" %c", &ch);
            if (ch <= '9' && ch > '0') st.tab[i][j] = ch - '0';
            else { st.r = i; st.c = j; st.tab[i][j] = 0; }
        }
}
void In(char s[], node &st)
{
    char ch;
    int next = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            while (s[next] == ' ') next++;
            ch = s[next++];
            if (ch <= '9' && ch > '0') st.tab[i][j] = ch - '0';
            else { st.r = i; st.c = j; st.tab[i][j] = 0; }
        }
}
void init()
{
    for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++)
        ed.tab[i][j] = (i * 3) + j + 1;
    ed.tab[2][2] = 0;

    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        if (ed.tab[i][j]) {
                ed_map[ed.tab[i][j]][0] = i; ed_map[ed.tab[i][j]][1] = j;
        }

    st.f = get_f(st, 0);
    st.g = 0;
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

void out_table(node a) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++)
        cout << a.tab[i][j] << ' ';
        cout <<endl;
    }
    cout <<endl;
}

bool isfind(node a)
{
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
        if (a.tab[i][j] != ed.tab[i][j]) return false;
    return true;
}
bool dfs(node a, int d)
{
    if (a.f > MaxH) return false;
    if (isfind(a)) return true;

    for (int i = 0; i < 4; i++)
    {
        if (d != i && i / 2 == d / 2) continue;///相邻不往返
        int nextr = a.r + dir_i[i];
        int nextc = a.c + dir_j[i];
        if (check(nextr, nextc))
        {
            node tmp;
            change(tmp, a, nextr, nextc, i);
            if (dfs(tmp, i)) {
                    ans[ansn++] = i;
//                sk.push(i);
                return true;
            }
        }
    }
    return false;
}
void ida_star()
{
//    while (!sk.empty()) sk.pop();
    ansn = 0;
    MaxH = st.f;
    while (!dfs(st, 6)) MaxH+=1;
    for (int i = ansn - 1; i >= 0; i--) putchar(print_op[ans[i]]);
//    while(!sk.empty()) printf("%c", print_op[sk.top()]), sk.pop();
    puts("");
}

///main!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int get_preval(node a) {
    int ret = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if (!a.tab[i][j]) continue;
            int x = 0;
            for (int jj = j + 1; jj < 3; jj++)
                    if (a.tab[i][jj] && a.tab[i][jj] < a.tab[i][j]) x++;///
            for (int ii = i + 1; ii < 3; ii++)
                for (int jj = 0; jj < 3; jj++)
                    if (a.tab[ii][jj] && a.tab[ii][jj] < a.tab[i][j]) x++;
            ret += x;
        }
    return ret % 2;
}
bool pre_solve() {
    return (get_preval(st) ^ get_preval(ed));
}
///!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

int main() {
    char ss[12];
    while (gets(ss))
    {
        In(ss, st);
//        input(st);
    //    input(ed);
        init();
    //    out_table(st);
    //    out_table(ed);

        if (pre_solve()) puts("unsolvable");
        else ida_star();
    }
    return 1;
}


/*
1 2 3 x 4 6 7 5 8
x 2 3 1 4 6 7 5 8

1 2 3 x 4 6 7 5 8
1 2 3 4 x 6 7 5 8


1 2 3 4 5 x 7 8 6

1 2 3 4 x 8 7 6 5
*/




您可能感兴趣的与本文相关的镜像

HunyuanVideo-Foley

HunyuanVideo-Foley

语音合成

HunyuanVideo-Foley是由腾讯混元2025年8月28日宣布开源端到端视频音效生成模型，用户只需输入视频和文字，就能为视频匹配电影级音效

POJ1077(经典的八数码问题)
飞翔的小鸟
08-05 3763
很经典的八数码问题，可以用单向广度优先搜索、双向广度优先搜索、A*算法、IDA算法解。 用了双向广度优先搜索和A*算法解，在用A*算法时，纠结了好几天，后来在网上看了一份博客才发现自己错在哪。之后解出来了。虽然做这题时很纠结，不过收获真的很大，痛而快乐着………… 下面贴出用双向广度优先搜索和A*算法做的代码   //A*算法 #include #include #include
八数码难题 (IDA*解法）
lcey_的博客
05-18 1008
翻题解的时候看到大佬们都打的双向广搜。（蒟蒻在墙角瑟瑟发抖 在这里提供一种IDA*解法， 还是一层层地搜索，如果超出预期层数就返回 然后用评估函数进行剪枝（就是可行性剪枝） 感觉写起来比双向广搜好多了 评估函数越好，搜索效率越高； 如果评估函数太差，那IDA*和普通爆搜复杂度差不多。 所有一个好的评估函数很关键； 主要是看这道题评估函数(h)怎么写， 对于评估函数想到的有两个方案： 方案一：不在自...
八码数-IDA*算法
weixin_43769146的博客
11-16 1145
A是用在BFS上的 A=优先队列+估价函数 IDA是用在DFS上的 IDA=迭代加深+估价函数 一般来说IDA优于A主要在A的BSF内存的需求，且不需要对启发值排序。我是更喜欢用IDA*。 IDA*相对于DFS有两个特点：运用了迭代加深的思路和乐观函数。 具体原理我怕讲不清楚，推荐阅读:   算法思想：迭代加深 A算法 和 IDA算法   看题吧： HDU1043—Eight 给出一个3×33...
POJ 1077 Eight（八数码A*+IDA*）
piaocoder
04-05 991
Eight 题目链接： http://poj.org/problem?id=1077 解题思路： 题目大意： 将分别标有数字1，2，3，…，8的八块正方形数码牌任意地放在一块3×3的数码盘上。放牌时要求不能重叠。于是，在3×3的数码盘 上出现了一个空格。现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘摆成如下的状态。 1 2 3 4 5 6 7
POJ - 1077 Eight
那些年
05-22 1010
题意：经典八数码问题 思路：HASH+BFS#include #include #include #include using namespace std; const int MAXN = 500000; const int size = 1000003; typedef int State[9]; char str[30]; int state[9],goal[9]={1, 2,
POJ1077 Eight A*
Kevin的博客
09-11 457
题目链接 http://poj.org/problem?id=1077 分析 直接用BFS进行状态扩展会超时，需要设计估价函数跑A*算法。 每次只能使一个数位置改变，因此未来的操作次数不会小于每个数当前位置于最终位置的曼哈顿距离之和。 用这个作为估价函数，用康托展开将排列映射成整数来记录某一状态是否访问过。 有一结论，如果列数为奇数，那么初始状态和最终状态的逆序对数奇偶性相同。 AC代码 // 调...
POJ1077 Eight —— A*算法
A man can be destroyed, but not defeated.
09-05 1383
主页面： #include #include #include #include #include #include #include #include #include #include #include #define ms(a,b) memset((a),(b),sizeof((a))) using namespace std; typedef lon
poj 1077 Eight.md
11-17
poj 1077 Eight.md
八数码 POJ1077 （康托展开与奇偶排列详解）
Keep eating codes!
03-01 793
题目链接 八数码问题有多种解决方法，在这里只具体讲述一下康托展开在状态压缩中的应用。 题意： 输入一段数字序列，表示3×3棋盘0到8的一种排列状态，要求计算从初始状态到达目标状态（1 2 3 4 5 6 7 8 0）所需的最少步数，并输出操作过程。 思路： 本题的关键是标记每一种可能扩展到的状态，由于所有的状态个数对应的是9的全排列，如果仅仅是简单地扩展标记数组的维度必然会超内存，所以此时...
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
八数码IDA*实现
12-27
代码注释清晰，逻辑连贯，有助于理解IDA*和八数码问题
POJ 1077 八数码问题
WA是一笔财富
01-23 623
传送门：POJ1077 题意：经典八数码问题求解。建议做之前先看一下http://www.cnblogs.com/goodness/archive/2010/05/04/1727141.html，八数码问题的八种境界，不过个人感觉其中的hash部分讲的有问题，至少和代码中的hash方法不一样，不过也有可能是我理解的不到位，不管怎样，以代码为准吧，而且这篇博客其他部分写的还挺好的。 我这里用的是
八数码（POJ-1077或HDU-1043）
白黑菜的博客
04-21 439
Eight The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and a
poj1077
weixin_34075551的博客
07-19 117
题意：给出一个八数码问题，求解法，不可解则输出unsolvable。 分析：可以用ida*算法，估价函数可以使用每个数码到其最终位置的最短距离之和。对于不可解的判断，我这里用迭代深度大于100时判定为不可解。 还有一种更高级的无解判断方法。就是将八数码矩阵中的空格忽略，然后将8个数字排成一排，第二行接在第一行后面，第三行接在第二行后面，通过观察我们发现移动空格不会影响这个8个数字组成的数列中逆...
poj1077Eight
ithome
08-30 169
Eight Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 21880 Accepted: 9674 Special Judge Description The 15-puzzle has been around for over 100 years; even if...
POJ-1077 Eight
JSure的代码库
04-16 1137
Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 23270   Accepted: 10269   Special Judge Description The 15-puzzle has been around for over 100 years;
HDU-1043 逆向bfs 打表
刷题记录
03-11 294
Problem Description The 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 o...
用 A* 解决八数码问题
hazqfp的专栏
02-27 1019
#include 8 s% W2 b- F3 j$ Y4 o #include 3 _  h, ^$ P9 ?/ ? #include using namespace std; 9 S+ n& Q  g  R4 y #define HEAP_PARENT(i)                        (i >> 1); n- q# z9 x0 {. O
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值