双向广搜+hash+康托展开 codevs 1225 八数码难题

codevs 1225 八数码难题

 时间限制: 1 s

 空间限制: 128000 KB

 题目等级 : 钻石 Diamond

 

题目描述 Description

Yours和zero在研究A*启发式算法.拿到一道经典的A*问题,但是他们不会做,请你帮他们.
问题描述

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

输入描述 Input Description

输入初试状态，一行九个数字，空格用0表示

输出描述 Output Description

只有一行，该行只有一个数字，表示从初始状态到目标状态需要的最少移动次数(测试数据中无特殊无法到达目标状态数据)

样例输入 Sample Input

283104765

样例输出 Sample Output

4

数据范围及提示 Data Size & Hint

详见试题

分类标签 Tags 点此展开 

启发式搜索 广度优先搜索 深度优先搜索 迭代搜索 搜索

/*复杂题目模板加注解*/
# include <stdio.h>
# include <mem.h>

# define MAXN (362880 + 5)

typedef struct 
{
    char a[9];
}state;

const int dir[4][2] = {{-1,0}, {0,1}, {1,0}, {0,-1}};
int fact[9];

int front, rear;
state cur, nst;            /* new state */
char vis[MAXN];
char dist[MAXN];        /* 求的是最短距离( < 100)，可以用 char 类型 */
state Q[MAXN/2];


void read(state *s);
int inversions(state s);
int cantor(state s);
void init_fact(void);
int bfs_d(state start, state goal);

int main()
{
    state start, goal;
    
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    
    init_fact();

    read(&start);/*指针引用*/
    read(&goal);

    if (inversions(start)%2 == inversions(goal)%2)/
    {/*判断能不能到达最终状态，如果能达到最终状态的话，那么格子中的个数在后面有几个比他小的数的和的奇偶是不变的，无论怎么变换，可以用归纳推理证明*/
        printf("%d\n", bfs_d(start, goal));
    }
    else puts("-1");/*找不到最终的状态*/

    return 0;
}

int bfs_d(state start, state goal)
{
    int i, x, y, nx, ny, ct, nt;

    memset(vis, 0, sizeof(vis));
    memset(dist, 0, sizeof(dist));

    front = 1;
    Q[front] = start;
    rear = 2;
    Q[rear++] = goal;
    vis[cantor(start)] = 1;                /* 1 表示从起始节点扩展得到 */
    vis[cantor(goal)] = 2;                /* 2 表示从目标节点扩展得到 */

    while (front < rear)
    {
        cur = Q[front++];
        ct = cantor(cur);
        for (i = 0; cur.a[i] && i < 9; ++i);/*找出0的位置*/
        x = i / 3;/*求出0所在的行数列数*/
        y = i % 3;
        for (i = 0; i < 4; ++i)
        {
            nx = x + dir[i][0];/*把0向四周扩展*/
            ny = y + dir[i][1];
            if (nx>=0 && nx<3 && ny>=0 && ny<3)
            {
                nst = cur;
                nst.a[x*3+y] = cur.a[nx*3+ny];/*互换0的位置与对应元素的位置*/
                nst.a[nx*3+ny] = 0;
                if (!vis[nt = cantor(nst)])/*判断当前这个状态是否已经到过*/
                {
                    Q[rear++] = nst;
                    /* foot[nt] = ct; */
                    dist[nt] = dist[ct] + 1;
                    vis[nt] = vis[ct];/*转移扩展的方向*/
                }
                else if (vis[ct] != vis[nt])/*如果已经到过，就是两者变换的次数和加上最后一次变化*/
                {/*这是双向广搜的精髓，判断两个点是从不同的方向转移来的*/
                    return 1 + dist[nt] + dist[ct];
                }
            }
        }
    }

    return -1;
}

void read(state *s)
{
    int i;
    char c[5];

    for (i = 0; i < 9; ++i)
    {
        scanf("%s", c);
        if (c[0] == 'x') (*s).a[i] = 0;
        else (*s).a[i] = c[0] - '0';
    }
}

int inversions(state s)
{
    char ch;
    int i, j, ret;

    ret = 0;
    for (i = 0; i < 9; ++i)
    {
        if (s.a[i] == 0) continue;
        ch = s.a[i];
        for (j = i+1; j < 9; ++j)
        {
            if (s.a[j] < ch && s.a[j] != 0)
                ++ret;
        }
    }

    return ret;
}

int cantor(state s)/*康托展开应用于哈希表，处理排列问题是不会有冲突的，网上有证明，可以自己看*/
{
    char ch;
    int i, j, ret, cnt;

    ret = 0;
    for (i = 0; i < 9; ++i)
    {
        cnt = 0;
        ch = s.a[i];
        for (j = i+1; j < 9; ++j)
        {
            if (s.a[j] < ch)
                ++cnt;
        }
        ret += cnt*fact[8-i];
    }

    return ret;
}

void init_fact(void)
{
    int i;

    fact[0] = 1;
    for (i = 1; i < 9; ++i)
    {
        fact[i] = i * fact[i-1];/*处理阶乘，整张图一共有9!种状态*/
    }
}

 

本题题解：

#define N 3628800
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
struct state{
    char a[10];
}; 
queue<state>que;
int xx[]={0,0,1,-1};
int yy[]={1,-1,0,0};
int visit[N]={0};
int fact[10]={0};
int dis[N]={0};
void init_goal(state& goal)
{
    goal.a[0]='1';goal.a[1]='2';goal.a[2]='3';
    goal.a[3]='8';goal.a[4]='0';goal.a[5]='4';
    goal.a[6]='7';goal.a[7]='6';goal.a[8]='5';
    //goal.a="123804765";
    //strcpy(goal.a,"123804765");
}
void in_fact()
{
    fact[0]=1;
    for(int i=1;i<9;++i)
      fact[i]=i*fact[i-1];
}
int cantor(state k)
{
    int ret=0;
    for(int i=0;i<9;++i)
    {
        int cnt=0;
        char ch=k.a[i];
        for(int j=i+1;j<9;++j)
          if(ch>k.a[j]) cnt++;
        ret+=cnt*fact[8-i];
    }
    return ret;
}
int bfs(state begin,state goal)
{
    que.push(begin);que.push(goal);
    int k1=cantor(begin);
    int k2=cantor(goal);
    visit[k1]=1;
    visit[k2]=2;
    dis[k1]=0;dis[k2]=0;
    while(!que.empty())
    {
        state fro=que.front();
        int can_fro=cantor(fro);
        que.pop();
        int i;
        for(i=0;fro.a[i]!='0'&&i<9;++i);
        int x=i/3;
        int y=i%3;
        for(int j=0;j<4;++j)
        {
            int nx=x+xx[j],ny=y+yy[j];
            if(nx>=0&&nx<3&&ny>=0&&ny<3)
            {
                state now=fro;
                now.a[3*x+y]=fro.a[3*nx+ny];
                now.a[3*nx+ny]='0';
                int kj=cantor(now);
                if(!visit[kj])
                {
                    que.push(now);
                    visit[kj]=visit[can_fro];/*转移是正向扩展还是逆向扩展*/
                    dis[kj]=dis[can_fro]+1;
                }
                else if(visit[kj]!=visit[can_fro])
                {/*这是双向广搜的精髓，必须用visit表示当前这个是同时由正反广搜扩展来的*/
                    return 1+dis[kj]+dis[can_fro];
                }
            }
        }
    }
}
int main()
{
    state goal,begin;
    init_goal(goal);
    in_fact();
//    scanf("%s",goal.a+1);
    scanf("%s",begin.a);
    printf("%d\n",bfs(begin,goal));
    return 0;
}