ZOJ - 2477 Magic Cube 【迭代加深+模拟】

最新推荐文章于 2020-05-01 08:23:27 发布
最新推荐文章于 2020-05-01 08:23:27 发布
阅读量343 收藏
点赞数
分类专栏： DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/godleaf/article/details/87199699
版权

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2477

从接触acm到现在，一直很抵触ZOJ的题目，我做过的很多ZOJ的题目大部分题意都很模糊，阐述不清楚。

这道题的难点不在搜索，光看题目的问法都应该知道是用迭代加深，但是真正让人崩溃的是什么地方？

首先是立方的展开图，如果没指名哪一面是正面或者背面，对应的顺逆时针方向也会不同，题目没说明怎么办？能咋办，我只有去试啊，我最先是以索引为1的这一面为立方的背面，然后模拟顺逆时针的旋转，一直WA，而且还不敢肯定WA的原因是顺逆时针还是其他地方没写好，当我以索引为1的这一面为正面的时候，重新修改模拟顺逆时针的代码，就AC了。真的无话可说。

 

#include <iostream>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;
const int Maxn = 4e5+10;

int cube[10][4][4];

bool check() {
    for(int i = 0; i < 6; ++i) {
        int tmp = cube[i][0][0];
        for(int j = 0; j < 3; ++j) {
            for(int k = 0; k < 3; ++k) if(tmp != cube[i][j][k]) {
                return false;
            }
        }
    }
    return true;
}

void Size(int x, int dir) {
    if(dir == 1) {
        swap(cube[x][0][0], cube[x][0][2]);
        swap(cube[x][0][0], cube[x][2][2]);
        swap(cube[x][0][0], cube[x][2][0]);
        swap(cube[x][0][1], cube[x][1][2]);
        swap(cube[x][0][1], cube[x][2][1]);
        swap(cube[x][0][1], cube[x][1][0]);
    } else {
        swap(cube[x][0][0], cube[x][2][0]);
        swap(cube[x][0][0], cube[x][2][2]);
        swap(cube[x][0][0], cube[x][0][2]);
        swap(cube[x][0][1], cube[x][1][0]);
        swap(cube[x][0][1], cube[x][2][1]);
        swap(cube[x][0][1], cube[x][1][2]);
    }
}

void solve(int x, int dir) {
    Size(x, dir);
    if(x == 1 && dir == 1) { //
        swap(cube[4][2][0], cube[2][0][0]); swap(cube[4][2][2], cube[2][2][0]);
        swap(cube[4][2][0], cube[5][0][2]); swap(cube[4][2][2], cube[5][0][0]);
        swap(cube[4][2][0], cube[0][2][2]); swap(cube[4][2][2], cube[0][0][2]);
        swap(cube[4][2][1], cube[2][1][0]);
        swap(cube[4][2][1], cube[5][0][1]);
        swap(cube[4][2][1], cube[0][1][2]);
    } else if(x == 1 && dir == -1) {
        swap(cube[4][2][0], cube[0][2][2]); swap(cube[4][2][2], cube[0][0][2]);
        swap(cube[4][2][0], cube[5][0][2]); swap(cube[4][2][2], cube[5][0][0]);
        swap(cube[4][2][0], cube[2][0][0]); swap(cube[4][2][2], cube[2][2][0]);
        swap(cube[4][2][1], cube[0][1][2]);
        swap(cube[4][2][1], cube[5][0][1]);
        swap(cube[4][2][1], cube[2][1][0]);
    }

    if(x == 3 && dir == -1) { //
        swap(cube[4][0][0], cube[2][0][2]); swap(cube[4][0][2], cube[2][2][2]);
        swap(cube[4][0][0], cube[5][2][2]); swap(cube[4][0][2], cube[5][2][0]);
        swap(cube[4][0][0], cube[0][2][0]); swap(cube[4][0][2], cube[0][0][0]);
        swap(cube[4][0][1], cube[2][1][2]);
        swap(cube[4][0][1], cube[5][2][1]);
        swap(cube[4][0][1], cube[0][1][0]);
    } else if(x == 3 && dir == 1) {
        swap(cube[4][0][0], cube[0][2][0]); swap(cube[4][0][2], cube[0][0][0]);
        swap(cube[4][0][0], cube[5][2][2]); swap(cube[4][0][2], cube[5][2][0]);
        swap(cube[4][0][0], cube[2][0][2]); swap(cube[4][0][2], cube[2][2][2]);
        swap(cube[4][0][1], cube[0][1][0]);
        swap(cube[4][0][1], cube[5][2][1]);
        swap(cube[4][0][1], cube[2][1][2]);
    }

    if(x == 2 && dir == -1) { //
        swap(cube[3][0][0], cube[4][2][2]); swap(cube[3][2][0], cube[4][0][2]);
        swap(cube[3][0][0], cube[1][2][2]); swap(cube[3][2][0], cube[1][0][2]);
        swap(cube[3][0][0], cube[5][2][2]); swap(cube[3][2][0], cube[5][0][2]);
        swap(cube[3][1][0], cube[4][1][2]);
        swap(cube[3][1][0], cube[1][1][2]);
        swap(cube[3][1][0], cube[5][1][2]);
    } else if(x == 2 && dir == 1) {
        swap(cube[3][0][0], cube[5][2][2]); swap(cube[3][2][0], cube[5][0][2]);
        swap(cube[3][0][0], cube[1][2][2]); swap(cube[3][2][0], cube[1][0][2]);
        swap(cube[3][0][0], cube[4][2][2]); swap(cube[3][2][0], cube[4][0][2]);
        swap(cube[3][1][0], cube[5][1][2]);
        swap(cube[3][1][0], cube[1][1][2]);
        swap(cube[3][1][0], cube[4][1][2]);
    }

    if(x == 0 && dir == 1) { //
        swap(cube[3][0][2], cube[4][2][0]); swap(cube[3][2][2], cube[4][0][0]);
        swap(cube[3][0][2], cube[1][2][0]); swap(cube[3][2][2], cube[1][0][0]);
        swap(cube[3][0][2], cube[5][2][0]); swap(cube[3][2][2], cube[5][0][0]);
        swap(cube[3][1][2], cube[4][1][0]);
        swap(cube[3][1][2], cube[1][1][0]);
        swap(cube[3][1][2], cube[5][1][0]);
    } else if(x == 0 && dir == -1) {
        swap(cube[3][0][2], cube[5][2][0]); swap(cube[3][2][2], cube[5][0][0]);
        swap(cube[3][0][2], cube[1][2][0]); swap(cube[3][2][2], cube[1][0][0]);
        swap(cube[3][0][2], cube[4][2][0]); swap(cube[3][2][2], cube[4][0][0]);
        swap(cube[3][1][2], cube[5][1][0]);
        swap(cube[3][1][2], cube[1][1][0]);
        swap(cube[3][1][2], cube[4][1][0]);
    }

    if(x == 5 && dir == -1) { //
        swap(cube[3][2][0], cube[2][2][0]); swap(cube[3][2][2], cube[2][2][2]);
        swap(cube[3][2][0], cube[1][2][0]); swap(cube[3][2][2], cube[1][2][2]);
        swap(cube[3][2][0], cube[0][2][0]); swap(cube[3][2][2], cube[0][2][2]);
        swap(cube[3][2][1], cube[2][2][1]);
        swap(cube[3][2][1], cube[1][2][1]);
        swap(cube[3][2][1], cube[0][2][1]);
    } else if(x == 5 && dir == 1) {
        swap(cube[3][2][0], cube[0][2][0]); swap(cube[3][2][2], cube[0][2][2]);
        swap(cube[3][2][0], cube[1][2][0]); swap(cube[3][2][2], cube[1][2][2]);
        swap(cube[3][2][0], cube[2][2][0]); swap(cube[3][2][2], cube[2][2][2]);
        swap(cube[3][2][1], cube[0][2][1]);
        swap(cube[3][2][1], cube[1][2][1]);
        swap(cube[3][2][1], cube[2][2][1]);
    }

    if(x == 4 && dir == -1) { //
        swap(cube[0][0][0], cube[1][0][0]); swap(cube[0][0][2], cube[1][0][2]);
        swap(cube[0][0][0], cube[2][0][0]); swap(cube[0][0][2], cube[2][0][2]);
        swap(cube[0][0][0], cube[3][0][0]); swap(cube[0][0][2], cube[3][0][2]);
        swap(cube[0][0][1], cube[1][0][1]);
        swap(cube[0][0][1], cube[2][0][1]);
        swap(cube[0][0][1], cube[3][0][1]);
    } else if(x == 4 && dir == 1) {
        swap(cube[0][0][0], cube[3][0][0]); swap(cube[0][0][2], cube[3][0][2]);
        swap(cube[0][0][0], cube[2][0][0]); swap(cube[0][0][2], cube[2][0][2]);
        swap(cube[0][0][0], cube[1][0][0]); swap(cube[0][0][2], cube[1][0][2]);
        swap(cube[0][0][1], cube[3][0][1]);
        swap(cube[0][0][1], cube[2][0][1]);
        swap(cube[0][0][1], cube[1][0][1]);
    }
}

int ans[10][2], cnt;

void print() {
    for(int i = 0; i < 6; ++i) {
        for(int j = 0; j < 3; ++j) {
            for(int k = 0; k < 3; ++k) cout << cube[i][j][k] << " ";
            cout << endl;
        }
        cout << endl;
    }
}

bool dfs(int dep, int step) {
    if(check()) return true;
    if(step == dep) return false;

    for(int i = 0; i < 6; ++i) {
        ans[cnt][0] = i; ans[cnt][1] = -1;
        cnt++; solve(i, -1);
        if(dfs(dep, step+1)) return true;
        cnt--; solve(i, 1);

        ans[cnt][0] = i; ans[cnt][1] = 1;
        cnt++; solve(i, 1);
        if(dfs(dep, step+1)) return true;
        cnt--; solve(i, -1);
    }
    return false;
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--) {
        int r = 0, c = 0;
        while(r < 2 || c < 3) {
            char ch = getchar();
            if(c == 3) {
                c = 0; r++;
            }
            if(ch >= 'a' && ch <= 'z') cube[4][r][c++] = ch-'a';
        }
        r = 0; c = 0;
        while(r < 2 || c < 12) {
            char ch = getchar();
            if(c == 12) {
                c = 0; r++;
            }
            if(ch < 'a' || ch > 'z') continue;
            if(c < 3) cube[0][r][c] = ch-'a';
            else if(c < 6) cube[1][r][c-3] = ch-'a';
            else if(c < 9) cube[2][r][c-6] = ch-'a';
            else cube[3][r][c-9] = ch-'a';
            c++;
        }
        r = 0; c = 0;
        while(r < 2 || c < 3) {
            char ch = getchar();
            if(c == 3) {
                c = 0; r++;
            }
            if(ch >= 'a' && ch <= 'z') cube[5][r][c++] = ch-'a';
        }
      //  print();
        cnt = 0; bool ok = false;

        for(int dep = 1; dep <= 5; ++dep) {
            if(dfs(dep, 0)) {
                ok = true; break;
            }
        }
        if(!ok) printf("-1\n");
        else {
            printf("%d\n", cnt);
            for(int i = 0; i < cnt; ++i) printf("%d %d\n", ans[i][0], ans[i][1]);
        }
    }
	return 0;
}

 

Y390d
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AlgoSolutions：AlgoSolutions-LeetCode +剑指提供+编程之美+ zoj + CrackigCode150
02-02
算法刷题与练习 LeetCodeOJ-解决方案 欢迎访问作者的个人网站：
Magic Cube ZOJ - 2477
m0_52007929的博客
01-03 95
题目链接 题意： 给出魔方初始图，每次从6个面中选一个面进行旋转操作，求还原魔方所需要的最小步数，并输出每次操作和旋转方向，答案保证在5步以内 题目分析： 很恶心的一道题，题意5步一眼IDA* 启发函数也挺好想，找出每个面与中心颜色不同的数量， 每次旋转最多改变12个， 当不同数量／12>深度时剪枝，每次操作我们可以打表模拟6种操作时会导致的位置变化 不懂操作变化的可以点击 代码： #include <bits/stdc++.h> #define x first #define y sec
ZOJ-2477 Magic Cube
wl16wzl的博客
03-12 305
用迭代加深搜索来做，主要任务是模拟魔方的旋转，要使用旋转数组（必须细心，小心弄错）一开始理解错题意了，只要每个面颜色都一样就可以了，而不是还原成题中给出的样子#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;cmath&gt; #...
ZOJ - 2477 dfs [kuangbin带你飞]专题二
weixin_30340617的博客
02-16 118
注意输入的处理，旋转操作打表。递增枚举可能步数，作为限制方便找到最短路。 AC代码：90ms #include<cstdio> #include<cstring> char magic[60]; int cube[6][9] = { {4,0,1,2,3,5,6,7,8},{22,9,10,11,21,23,33,34,35},{25,12,13,14...
[IDA*] ZOJ 2477
Aria461863631的博客
11-12 320
最大深度只有5层， 所以用IDA* 算法
zoj-cpp.zip_zoj
09-14
zoj网站中多个练习的c++解答，文件名即为题目序号。经本人测试可以使用，主要为动态规划方面的问题，希望给初学者提供帮助。
zoj 3590 -3+1.md
11-17
zoj 3590 -3+1.md
zoj 2247 Magic Trick.md
11-17
zoj 2247 Magic Trick.md
ZOJ1055-Oh_Those_Achin_Feet.rar_BFS最短路径_ZOJ1055_bfs求最短路径_zoj
09-24
ZOJ 1055 Oh, Those Achin Feet.bfs求最短路径.
ZOJ 2477 Magic Cube 三阶魔方还原（IDA*）
java开发指南博客 【转载】
07-19 398
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 三阶魔方还原。因为只搜5层，所以使用IDA*搜索。由于每次旋转，每面中心颜色总不变，也就确定了最终的状态，找出每个面中与中间颜色不同的个数的最大值，其中每次旋转会更改每个面的3个位置的颜色，所以 就是（最大值+2）/3。 总共有12种旋转，找到其中...
ZOJ2477 IDA*搜索进阶
HPU WIN
12-11 311
问题大意就是给你一个魔方，让你在五步之内还原这个魔方，这个魔方只能让每个面进行顺时针或者逆时针操作，问能否在五步内解决战斗，如果可以，请输出每一步转动的面，以及是逆时针还是顺时针。 分析：对于这个问题，核心在于如何魔方的转动，以及预估函数的判断；  关于预估函数，我的观点是当你想出正确的模拟转动过程后这个预估函数也就很好写了，所以先对魔方转动模拟的分析：首先可以知道每转动一次都会有20个方块改变...
ZOJ2477 拼魔方
zxwsbg的博客
03-13 364
每日打卡（1/2）传送门：点击打开链接题目大意：    给你一个摊开的魔方，问你是否能在五步之内复原，如果能，输出对应的步骤。题目思路：    首先需要预处理一下（打表），将各种转动模拟出来。#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; us...
ZOJ2477
终究我要华丽逆袭
11-25 904
IDA搜索。。。。想法不难，难在，旋转的时候每个点对应哪个点要改变、、、wa了5次，写的泪奔了。。。change函数是相邻4个面的变化，rotate是自转#include #include #include char mp[6][3][3],s[2]; int T,ansx[10],ansy[10]; int judge(char mp[6][3][3]) { for(int i=0;i<6;i
zoj2477 Magic Cube (bfs)
Shion的专栏
12-23 570
题意是给一个3阶魔方输出复原的步骤。如果步数大于5就输出-1。 这道题有IDA*的做法……但是蒟蒻只会bfs…… 200行代码简直就像一坨*。 完整代码（我都不好意思贴出来）： #include #include #include #include #include using namespace std; struct Node { char cube[6][3]
ZOJ Magic Cube 2477
Chris_Home
10-26 1297
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2477 最大深度只有5层， 用IDA* 算法, 这题的亮点就是用数组来预处理模方的每种旋转，节约时间和代码量 。 h函数的选择： 因为无论怎么旋转，每块魔方的中间位置的颜色是不会变的，因此可以用总共不在原来面上的方块数来作为h函数。 每次旋转，最多能使12块魔方回到原来的
ZOJ 2477Magic Cube(打表模拟)
Bran
05-01 292
感觉这道题真的是很好的一道题，我比较认可这个方法就是按照读入顺序来对颜色块，进行编码然后预先打表处理出每个面顺逆时针旋转之后的位置，认真一点把表打对，然后可以利用迭代加深搜索出最小的步数。 #include <bits/stdc++.h> using namespace std; char readchar() { char ch = 0; while (!isalp...
紫书搜索 习题7-8 UVA - 12107 Digit Puzzle IDA*迭代加深搜索
weixin_30270561的博客
03-14 107
题目链接: https://vjudge.net/problem/UVA-12107 题意: 给出一个数字谜，要求修改尽量少的数，使修改后的数字谜只有唯一解。空格和数字可以随意替换，但不能增删，数字谜中所有涉及的数必须是没有前导零的正数。输入数字谜一定形如a*b=c，其中a、b、c分别最多有2、2、4位。 题解: http://www.cnblogs.com/tyty-Somnusp...
ZOJ-1091-Knight Moves
最新发布
06-02
这是一个IT类问题，该问题是一个经典的图论问题，需要计算从一个棋盘上某个起点到达另一个点的最短路径。在这个问题中，棋盘上的每个格子都可以看做是图中的一个节点，而马可以看做是从一个节点到达另一个节点的一条...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值