poj 1077 Eight (BFS)

最新推荐文章于 2022-02-25 19:38:17 发布
最新推荐文章于 2022-02-25 19:38:17 发布
阅读量639 收藏
点赞数
分类专栏： 算法—搜索 文章标签： poj 1077 bfs c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangxinxin_/article/details/45678417
版权

八数码问题，各种解法。


/*
// BFS
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;

// 把1..n的排列映射为数字 0..(n!-1)
int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };//...
int order(const char *s, int n) {
    int i, j, temp, num;

    num = 0;

    for (i = 0; i < n-1; i++) {
        temp = 0;
        for (j = i + 1; j < n; j++) {
            if (s[j] < s[i])
                temp++;
        }
        num += fac[s[i] -1] * temp;
    }
    return num;
}

bool is_equal(const char *b1, const char *b2){
    for(int i=0; i<9; i++)
        if(b1[i] != b2[i])
            return false;
    return true;
}


//hash
struct node{
    char board[9];
    char space;//空格所在位置
};

const int TABLE_SIZE = 362880;

int hash(const char *cur){
    return order(cur, 9);
}

// 整数映射成排列
void get_node(int num, node &tmp) {
    int n=9;
    int a[9]; //求逆序数
    for (int i = 2; i <= n; ++i) {
        a[i - 1] = num % i;
        num = num / i;
        tmp.board[i - 1] = 0;//初始化
    }
    tmp.board[0] = 0;
    int rn, i;
    for (int k = n; k >= 2; k--) {
        rn = 0;
        for (i = n - 1; i >= 0; --i) {
            if (tmp.board[i] != 0)
                continue;
            if (rn == a[k - 1])
                break;
            ++rn;
        }
        tmp.board[i] = k;
    }
    for (i = 0; i < n; ++i)
        if (tmp.board[i] == 0) {
            tmp.board[i] = 1;
            break;
        }
    tmp.space = n - a[n-1] -1;
}

char visited[TABLE_SIZE];
int parent[TABLE_SIZE];
char move[TABLE_SIZE];
int step[4][2] = {{-1, 0},{1, 0}, {0, -1}, {0, 1}};//u, d, l, r

void BFS(const node & start){
    int x, y, k, a, b;
    int u, v;

    for(k=0; k<TABLE_SIZE; ++k)
        visited[k] = 0;
    u = hash(start.board);
    parent[u] = -1;
    visited[u] = 1;

    queue<int> que;
    que.push(u);

    node tmp, cur;
    while(!que.empty()){
        u = que.front();
        que.pop();

        get_node(u, cur);

        k = cur.space;
        x = k / 3;
        y = k % 3;
        for(int i=0; i<4; ++i){
            a = x + step[i][0];
            b = y + step[i][1];
            if(0<=a && a<=2 && 0<=b && b<=2){
                tmp = cur;
                tmp.space = a*3 + b;
                swap(tmp.board[k], tmp.board[tmp.space]);
                v = hash(tmp.board);
                if(visited[v] != 1){
                    move[v] = i;
                    visited[v] = 1;
                    parent[v] = u;
                    if(v == 0) //目标结点hash值为0
                        return;

                    que.push(v);
                }
            }
        }
    }
}

void print_path(){
    int n, u;
    char path[1000];
    n = 1;
    path[0] = move[0];
    u = parent[0];
    while(parent[u] != -1){
        path[n] = move[u];
        ++n;
        u = parent[u];
    }
    for(int i=n-1; i>=0; --i){
        if(path[i] == 0)
            printf("u");
        else if(path[i] == 1)
            printf("d");
        else if(path[i] == 2)
            printf("l");
        else
            printf("r");
    }
}

int main(){
//    freopen("in", "r", stdin);

    node start;
    char c;
    for(int i=0; i<9; ++i){
        cin>>c;
        if(c == 'x'){
            start.board[i] = 9;
            start.space = i;
        }
        else
            start.board[i] = c - '0';
    }
    BFS(start);

    if(visited[0] == 1)
        print_path();
    else
        printf("unsolvable");
    return 0;
}

// A*
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<queue>
using namespace std;

// 把1..n的排列映射为数字 0..(n!-1)
int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };//...
int order(const char *s, int n) {
    int i, j, temp, num;

    num = 0;

    for (i = 0; i < n-1; i++) {
        temp = 0;
        for (j = i + 1; j < n; j++) {
            if (s[j] < s[i])
                temp++;
        }
        num += fac[s[i] -1] * temp;
    }
    return num;
}

bool is_equal(const char *b1, const char *b2){
    for(int i=0; i<9; i++)
        if(b1[i] != b2[i])
            return false;
    return true;
}


//hash
struct node{
    char board[9];
    char space;//空格所在位置
};

const int TABLE_SIZE = 362880;

int hash(const char *cur){
    return order(cur, 9);
}

// 整数映射成排列
void get_node(int num, node &tmp) {
    int n=9;
    int a[9]; //求逆序数
    for (int i = 2; i <= n; ++i) {
        a[i - 1] = num % i;
        num = num / i;
        tmp.board[i - 1] = 0;//初始化
    }
    tmp.board[0] = 0;
    int rn, i;
    for (int k = n; k >= 2; k--) {
        rn = 0;
        for (i = n - 1; i >= 0; --i) {
            if (tmp.board[i] != 0)
                continue;
            if (rn == a[k - 1])
                break;
            ++rn;
        }
        tmp.board[i] = k;
    }
    for (i = 0; i < n; ++i)
        if (tmp.board[i] == 0) {
            tmp.board[i] = 1;
            break;
        }
    tmp.space = n - a[n-1] -1;
}

//启发函数: 除去x之外到目标的网格距离和
int goal_state[9][2] = {{0,0}, {0,1}, {0,2},
        {1,0}, {1,1}, {1,2}, {2,0}, {2,1}, {2,2}};
int h(const char *board){
    int k;
    int hv = 0;
    for(int i=0; i<3; ++i)
        for(int j=0; j<3; ++j){
            k = i*3+j;
            if(board[k] != 9){
                hv += abs(i - goal_state[board[k]-1][0]) +
                        abs(j - goal_state[board[k] -1][1]);
            }
        }
    return hv;
}

int f[TABLE_SIZE], d[TABLE_SIZE];//估计函数和深度

//优先队列的比较对象
struct cmp{
    bool operator () (int u, int v){
        return f[u] > f[v];
    }
};
char color[TABLE_SIZE];//0, 未访问；1, 在队列中，2, closed
int parent[TABLE_SIZE];
char move[TABLE_SIZE];
int step[4][2] = {{-1, 0},{1, 0}, {0, -1}, {0, 1}};//u, d, l, r

void A_star(const node & start){
    int x, y, k, a, b;
    int u, v;
    priority_queue<int, vector<int>, cmp> open;
    memset(color, 0, sizeof(char) * TABLE_SIZE);

    u = hash(start.board);
    parent[u] = -1;
    d[u] = 0;
    f[u] = h(start.board);
    open.push(u);
    color[u] = 1;

    node tmp, cur;
    while(!open.empty()){
        u = open.top();
        if(u == 0)
            return;
        open.pop();

        get_node(u, cur);

        k = cur.space;
        x = k / 3;
        y = k % 3;
        for(int i=0; i<4; ++i){
            a = x + step[i][0];
            b = y + step[i][1];
            if(0<=a && a<=2 && 0<=b && b<=2){
                tmp = cur;
                tmp.space = a*3 + b;
                swap(tmp.board[k], tmp.board[tmp.space]);
                v = hash(tmp.board);
                if(color[v] == 1 && (d[u] + 1) < d[v]){//v in open
                    move[v] = i;
                    f[v] = f[v] - d[v] + d[u] + 1;//h[v]已经求过
                    d[v] = d[u] + 1;
                    parent[v] = u;
                    //直接插入新值, 有冗余，但不会错
                    open.push(v);
                }
                else if(color[v] == 2 && (d[u]+1)<d[v]){//v in closed
                    move[v] = i;
                    f[v] = f[v] - d[v] + d[u] + 1;//h[v]已经求过
                    d[v] = d[u] + 1;
                    parent[v] = u;
                    open.push(v);
                    color[v] = 1;
                }
                else if(color[v] == 0){
                    move[v] = i;
                    d[v] = d[u] + 1;
                    f[v] = d[v] + h(tmp.board);
                    parent[v] = u;
                    open.push(v);
                    color[v] = 1;
                }
            }
        }
        color[u] = 2; //
    }
}

void print_path(){
    int n, u;
    char path[1000];
    n = 1;
    path[0] = move[0];
    u = parent[0];
    while(parent[u] != -1){
        path[n] = move[u];
        ++n;
        u = parent[u];
    }
    for(int i=n-1; i>=0; --i){
        if(path[i] == 0)
            printf("u");
        else if(path[i] == 1)
            printf("d");
        else if(path[i] == 2)
            printf("l");
        else
            printf("r");
    }
}

int main(){
    //freopen("in", "r", stdin);

    node start;
    char c;
    for(int i=0; i<9; ++i){
        cin>>c;
        if(c == 'x'){
            start.board[i] = 9;
            start.space = i;
        }
        else
            start.board[i] = c - '0';
    }
    A_star(start);

    if(color[0] != 0)
        print_path();
    else
        printf("unsolvable");
    return 0;
}

// IDA*
#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;

#define    SIZE 3

char board[SIZE][SIZE];

//启发函数: 除去x之外到目标的网格距离和
int goal_state[9][2] = {{0,0}, {0,1}, {0,2},
        {1,0}, {1,1}, {1,2}, {2,0}, {2,1}, {2,2}};
int h(char board[][SIZE]){
    int cost = 0;
    for(int i=0; i<SIZE; ++i)
        for(int j=0; j<SIZE; ++j){
            if(board[i][j] != SIZE*SIZE){
                cost += abs(i - goal_state[board[i][j]-1][0]) +
                        abs(j - goal_state[board[i][j]-1][1]);
            }
        }
    return cost;
}

int step[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};//u, l, r, d
char op[4] = {'u', 'l', 'r', 'd'};

char solution[1000];
int bound;     //上界
bool ans;    //是否找到答案
int DFS(int x, int y, int dv, char pre_move){// 返回next_bound
    int hv = h(board);
    if(hv + dv > bound)
        return dv + hv;
    if(hv == 0){
        ans = true;
        return dv;
    }

    int next_bound = 1e9;
    for(int i=0; i<4; ++i){
        if(i + pre_move == 3)//与上一步相反的移动
            continue;
        int nx = x + step[i][0];
        int ny = y + step[i][1];
        if(0<=nx && nx<SIZE && 0<=ny && ny<SIZE){
            solution[dv] = i;
            swap(board[x][y], board[nx][ny]);

            int new_bound = DFS(nx, ny, dv+1, i);
            if(ans)
                return new_bound;
            next_bound = min(next_bound, new_bound);

            swap(board[x][y], board[nx][ny]);
        }
    }
    return next_bound;
}

void IDA_star(int sx, int sy){
    ans = false;
    bound = h(board);//初始代价
    while(!ans && bound <= 100)//上限
        bound = DFS(sx, sy, 0, -10);
}

int main(){
    freopen("in", "r", stdin);

    int sx, sy;//起始位置
    char c;
    for(int i=0; i<SIZE; ++i)
        for(int j=0; j<SIZE; ++j){
            cin>>c;
            if(c == 'x'){
                board[i][j] = SIZE * SIZE;
                sx = i;
                sy = j;
            }
            else
                board[i][j] = c - '0';
        }

    IDA_star(sx, sy);

    if(ans){
        for(int i=0; i<bound; ++i)
            cout<<op[solution[i]];
    }
    else
        cout<<"unsolvable";

    return 0;
}

*/
#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN=1000000;
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};//康拖展开判重
//         0!1!2!3! 4! 5!  6!  7!   8!    9!
bool vis[MAXN];//标记

int cantor(int s[])//康拖展开求该序列的hash值
{
    int sum=0;
    for(int i=0;i<9;i++)
    {
        int num=0;
        for(int j=i+1;j<9;j++)
          if(s[j]<s[i])num++;
        sum+=(num*fac[9-i-1]);
    }
    return sum+1;
}
struct Node
{
    int s[9];
    int loc;//“0”的位置,把“x"当0
    int status;//康拖展开的hash值
    string path;//路径
};
string path;
int aim=46234;//123456780对应的康拖展开的hash值
int move[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//u,d,l,r
char indexs[5]="udlr";//正向搜索
Node ncur;
bool bfs()
{
    memset(vis,false,sizeof(vis));
    Node cur,next;
    queue<Node>q;
    q.push(ncur);
    while(!q.empty())
    {
        cur=q.front();
        q.pop();
        if(cur.status==aim)
        {
            path=cur.path;
            return true;
        }
        int x=cur.loc/3;
        int y=cur.loc%3;
        for(int i=0;i<4;i++)
        {
            int tx=x+move[i][0];
            int ty=y+move[i][1];
            if(tx<0||tx>2||ty<0||ty>2)continue;
            next=cur;
            next.loc=tx*3+ty;
            next.s[cur.loc]=next.s[next.loc];
            next.s[next.loc]=0;
            next.status=cantor(next.s);
            if(!vis[next.status])
            {
                vis[next.status]=true;
                next.path=next.path+indexs[i];

                if(next.status==aim)
                {
                    path=next.path;
                    return true;
                }

                q.push(next);
            }
        }
    }
    return false;
}
int main()
{
    char ch;
    while(cin>>ch)
    {
        if(ch=='x') {ncur.s[0]=0;ncur.loc=0;}
        else ncur.s[0]=ch-'0';
        for(int i=1;i<9;i++)
        {
            cin>>ch;
            if(ch=='x')
            {
                ncur.s[i]=0;
                ncur.loc=i;
            }
            else ncur.s[i]=ch-'0';
        }
        ncur.status=cantor(ncur.s);
        if(bfs())
        {
            cout<<path<<endl;
        }
        else cout<<"unsolvable"<<endl;
    }
    return 0;
}


王老大_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj 1077 (康托展开+bfs)
Avalon_cc的博客
04-13 221
这是一个八数码问题，正好学习了康托展开，就做了这题，和hdu1043很像。康托展开并不难理解，其实就是一种hash。先上模板方便以后自己看。康托展开：int Contor(int str[],int n) { int ans = 0; for(int i = 0; i &lt; n; i++) { int cnt = 0; for(int j...
poj 1077 八数码(BFS+康托展开)
dianxie7120的博客
05-03 223
1 /* 2 题意：八数码问题，给出3*3的矩阵含1~8以及x，给出一个符合的解使得移动后的矩阵的顺序为1~8，最后为x 3 4 题解：BFS 5 需要用到康托展开来表示状态，不然数组无法完全表示所有状态，这样BFS就无法判断找不到解的情况(status 6 的0ms,0KB究竟是怎么做到的，简直不能想象=。=) 7 */ 8 #inc...
POJ 1077-Eight(BFS+优先队列)
梧桐下的四叶草
03-14 511
Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 28463   Accepted: 12420   Special Judge Description The 15-puzzle has been around for over 100 years; e
POJ1077八数码
loveSiri的博客
03-03 1026
POJ1077:八数码问题(Eight) POJ1077查看 文章目录POJ1077:八数码问题(Eight)@[toc]**解题思路**基础知识铺垫广度优先搜索BFS+康托展开广度优先搜索BFS+set二分查找双向广搜DBFS+set二分查找启发式算法+堆+普通标记数组更多策略 解题思路 求步数最少的解时候用广搜 状态的表示问题 若以字符串的形式表示，需要10字节，且检查是否达到目标状...
POJ 1077 Eight
u010084308的专栏
05-04 1292
链接：http://poj.org/problem?id=1077 题目： Language: Default Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 23382   Accepted: 10325   Special Judge
POJ 1077 Eight BFS -
BRCOCOLI的博客
09-12 223
题目地址：http://poj.org/problem?id=1077 木有A*快.. #include #include #include #include #include using namespace std; struct Node{ int status; int parent; int move; Node(int s=0,int p=0,int m=-1):status
POJ1077 Eight —— 反向BFS
alince20008的博客
09-05 102
主页面：http://www.cnblogs.com/DOLFAMINGO/p/7538588.html 代码一：以数组充当队列，利用结构体中的pre追溯上一个状态在数组（队列）中的下标： 1 #include <iostream> 2 #include <cstdio> 3 #include <cstrin...
POJ1077 Eight A*
Kevin的博客
09-11 329
题目链接 http://poj.org/problem?id=1077 分析 直接用BFS进行状态扩展会超时，需要设计估价函数跑A*算法。 每次只能使一个数位置改变，因此未来的操作次数不会小于每个数当前位置于最终位置的曼哈顿距离之和。 用这个作为估价函数，用康托展开将排列映射成整数来记录某一状态是否访问过。 有一结论，如果列数为奇数，那么初始状态和最终状态的逆序对数奇偶性相同。 AC代码 // 调...
poj 1077 Eight.md
11-17
poj 1077 Eight.md
POJ 1077 算法
08-09
关于C++ 算法 北大网站POJ 八数码问题
NOI2002.rar_NOI 2002 dragon_poj bfs
09-14
SPOJ3 AC程序 BF SPOJ3 AC程序 BF SPOJ3 AC程序 BF
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 8783
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）
北豼不太皮的博客
02-21 3200
10天智能锁项目实战第1天（了解单片机STM32F401RET6和C语言基础）一、学习目标二、了解单片机STM32F401RET6三、C语言基础 一、学习目标 二、了解单片机STM32F401RET6 4、STM32F401RE特征 三、C语言基础 1.数据类型 常用2的次方： 2^7 = 128 2^8 = 256 2^15 = 32768 2^16= 65536 51单片机常见的数据类型： char: 占内存1字节 取值范围：-128~127 -2^7 ~ 2
Android开发（1） | Fragment 的应用——新闻应用
Jormungand_V的博客
02-21 3670
文章目录 news_item.xml： <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/news_title" android:layout_width="match_parent" android:layout_height="wrap_content" android:lines="1" android:ellipsize="
系统学习 TypeScript（四）——变量声明的初步学习
编程三昧
02-25 1518
认识了 TypeScript 中的基础类型，接下来当然是变量声明的相关学习了，我在这里记录一下我学习过程中的一些总结。
清除浮动的五种方法
weixin_52212950的博客
02-22 2365
为什么要清除浮动？因为往往浮动后的子元素因为脱离了标准流，不能自动撑起父元素的高度，所以会对后续布局产生影响，对此清除浮动不如理解为清除浮动产生的影响更为合理。 例如：我们设置了两个盒子如图所示，粉色为父盒子，只有宽度没有高度，蓝色盒子有宽有高，粉色盒子的高由蓝盒子的高度撑开。 但是给蓝色的子盒子设置了左浮动后，脱离了标准流，无法再撑开粉盒子，可以看到粉盒子高度变成了0； 清除浮动有五种方法： 直接设置父元素的高度 额外标签法 单伪元素法 双伪元素法 ove.
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出文件中，如果给定的整数序列可被K整除，则写入单词“Divisible”，否则写入“Not divisible”。 该问题的解决方法可以使用动态规划来实现。我们可以使用一个二维数组dp来记录前i个数产生的余数情况。具体操作如下： - 初始化dp为1，表示前0个数产生的余数为0。 - 对于每个数a[i]，遍历0到K-1的余数j，如果前i-1个数可以产生余数j，则更新dp[i][(j+a[i])%K]和dp[i][(j-a[i])%K]为1。 - 最后判断dp[N]是否为1，如果是，则输出“Divisible”，否则输出“Not divisible”。 举个例子，对于序列17, 5, -21, 15，根据题目中的描述，可以通过添加加号和减号来得到不同的算术表达式，如17+5-21+15=16，17+5-21-15=-14等。在这个例子中，序列是可被7整除的，因为存在一个算术表达式17+5-21-15=-14的结果可以被7整除，但不可被5整除。 因此，根据题目的描述和动态规划的思想，我们可以编写一个程序来解决POJ Divisibility问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值