Problem Description

在小白成功的通过了第一轮面试后,他来到了第二轮面试。面试的题目有点难度了,为了考核你的思维能量,面试官给你一副(2x4)的初态地图,然后在给你一副(2x4)的终态地图。每一幅地图都是有数字1~8表示,给你的地图的信息是一串序列,然后根据这序列,从地图的左上角开始,按照顺时针排列。 比如地图信息为12345678,则表示地图:

1 2 3 4

8 7 6 5

对于这地图有三种具体操作方式:

A: 上下两行互换,如上图可变换为状态87654321

B: 每行同时循环右移一格,如上图可变换为41236785

C: 中间4个方块顺时针旋转一格,如上图可变换为17245368

根据所给的初状地图和终态地图,请给出完成转化的最少的变换步骤,若有多种变换方案则取字典序最小的那种。

Input

每组测试数据包括两行,分别代表地图信息的初态与终态。

Output

对于每次测试案例,输出需要符合要求的变换步骤。

SampleInput

12345678
17245368
12345678
82754631

SampleOutput

C
AC 最开始预处理了一下直接搜,本地爆炸。
然后想到了用康托展开打个表,然后。。。就AC了。
这里讲一下康托展开算法
  X = An * (n-1)! + An-1 * (n-2)! + ... + A1 * 0!;
康拓展开就是求一个数字字符串在其全排列中的位置。
例如231这个数,全排列为123 132 213 231 312 321
所以231排在第4位,那么康托展开算法是如何求的呢。
例如求231的康托展开,从头至尾依次判断:
  1. 第一位数2,比2小的有一个,有1*2!
  2. 第二位数3,比3小的有两个,但2已经出现,有1*1!
  3. 第三位数1,有0*0!

累加起来就是2 + 1 = 3,表示比231小的有3个,所以231排在第4位。

代码实现的话就是:

 int fac[] = {,,,,,,,,};  //i的阶乘
int kangtuo(int n,char a[]){ //n表示1~n个数,a数组表示数字
int i,j,t,res = ;
for(i = ; i < n; i++){
t = ;
for(j = i+; j < n; j++)
if(a[i] > a[j])
t++;
res += t*fac[n-i-];
}
return sum + ;
}

知道了康托展开后,就可以打表做了,值得一提的是这道题的预处理。因为题目输入两组字符串分别表示初始状态和结束状态,而我们打表是从12345678到各个状态的值,所以预处理我们把输入的初状态转成12345678,末状态也执行相应转换就可以了;

代码:

 #include <iostream>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <deque>
#include <queue>
#include <vector>
#include <set>
#include <list>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <iterator>
#include <cmath>
#include <bitset>
#include <ctime>
#include <fstream>
#include <limits.h>
#include <numeric> using namespace std; #define F first
#define S second
#define mian main
#define ture true #define MAXN 1000000+5
#define MOD 1000000007
#define PI (acos(-1.0))
#define EPS 1e-6
#define MMT(s) memset(s, 0, sizeof s)
typedef unsigned long long ull;
typedef long long ll;
typedef double db;
typedef long double ldb;
typedef stringstream sstm;
const int INF = 0x3f3f3f3f; struct node{
string str,step;
}; bool vis[+];
int pos[],fac[] = {,,,,,,,,};
string ans[]; int fun(string a){
int i,j,t,sum = ;
for(i = ; i < ; ++i){
t = ;
for(j = i+; j < ; ++j)
if(a[i] > a[j])
++t;
sum += t*fac[-i-];
}
return sum+;
} void ma(string &s){
for(int i = ; i < ; ++i)
swap(s[i],s[i+]);
} string mb(string s){
string temp = s;
for(int i = ; i < ; ++i){
if(i== || i==)
temp[i]=s[i+];
else
temp[i]=s[i-];
}
return temp;
} void mc(string &s){
swap(s[],s[]);
swap(s[],s[]);
swap(s[],s[]);
} void bfs( string s ){
MMT(vis);
queue<node>q;
node pre,nxt; pre.str = s;
pre.step = "";
vis[fun(s)] = ;
ans[fun(s)] = pre.step;
q.push(pre); while(!q.empty()){
pre = q.front();
q.pop(); nxt = pre;
ma(nxt.str);
if(!vis[fun(nxt.str)]){
nxt.step += "A";
vis[fun(nxt.str)] = ;
ans[fun(nxt.str)] = nxt.step;
q.push(nxt);
} nxt.str = mb(pre.str);
if(!vis[fun(nxt.str)]){
nxt.step = pre.step + "B";
vis[fun(nxt.str)] = ;
ans[fun(nxt.str)] = nxt.step;
q.push(nxt);
} nxt = pre;
mc(nxt.str);
if(!vis[fun(nxt.str)]){
nxt.step += "C";
vis[fun(nxt.str)] = ;
ans[fun(nxt.str)] = nxt.step;
q.push(nxt);
}
}
} int main(){
ios_base::sync_with_stdio(false);
cout.tie();
cin.tie();
string s1,s2;
int k;
bfs("");
//12345678
//17245368
//12345678
//
while(cin>>s1>>s2){
swap(s1[],s1[]);
swap(s1[],s1[]);
swap(s2[],s2[]);
swap(s2[],s2[]);
for(int i = ; i < ; i++)
pos[s1[i]-''] = i+;
for(int i = ; i < ; i++)
s2[i] = pos[s2[i]-''];
k = fun(s2);
cout<<ans[k]<<endl;
}
return ;
}

其实康托展开也可以求逆运算,具体思想以及代码实现这里就不讲了=7=

转换地图 (康托展开+预处理+BFS)的更多相关文章

  1. UESTC 485 Game(康托展开,bfs打表)

    Game Time Limit: 4000/2000MS (Java/Others) Memory Limit: 65535/65535KB (Java/Others) Submit Status t ...

  2. 康托展开+反向bfs

    康托展开+反向bfs hdu 1043 题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=1043 #include <iostream> # ...

  3. ACM-康托展开+预处理BFS之魔板——hdu1430

    魔板 Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submis ...

  4. HDU1430 BFS + 打表 + 康托展开

    题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1430 , 一道比较好的题. 这道题要用到很多知识,康托展开.BFS.打表的预处理还要用到一一映射,做完 ...

  5. hdu 1430 (BFS 康托展开 或 map )

    第一眼看到这题就直接BFS爆搜,第一发爆了内存,傻逼了忘标记了,然后就改,咋标记呢. 然后想到用map函数,就8!个不同的排列,换成字符串用map标记.然后又交一发果断超时,伤心,最恨超时,还不如来个 ...

  6. HDU 1430 魔板(康托展开+BFS+预处理)

    魔板 Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submis ...

  7. HDU 1043 & POJ 1077 Eight(康托展开+BFS+预处理)

    Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 30176   Accepted: 13119   Special ...

  8. hdu3567 八数码2(康托展开+多次bfs+预处理)

    Eight II Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 130000/65536 K (Java/Others)Total S ...

  9. hdu1430魔板(BFS+康托展开)

    做这题先看:http://blog.csdn.net/u010372095/article/details/9904497 Problem Description 在魔方风靡全球之后不久,Rubik先 ...

随机推荐

  1. 6个美观的纯CSS渐变背景代码分享(亲测有效)

    样式1 background-image: linear-gradient(160deg, #b100ff 20%,#00b3ff 80%); 样式2 background-image: linear ...

  2. ES6中。类与继承的方法,以及与ES5中的方法的对比

    // 在ES5中,通常使用构造函数方法去实现类与继承 // 创建父类 function Father(name, age){ this.name = name; this.age = age; } F ...

  3. 【JS档案揭秘】第二集 Event loop与执行栈

    我时常在思考关于JS的很多知识在工作中有什么用?是否只能存在于面试这种理论性的东西中,对于我们的业务和工作,它们又能扮演怎样的角色.以后在JS档案揭秘的每一期里,都会加入我对于业务的思考,让这些知识不 ...

  4. Django Mysql数据库-F查询和Q查询

    一.F查询和Q查询 F查询: 在上面所有的例子中,我们构造的过滤器都只是将字段值与某个常量做比较.如果我们要对两个字段的值做比较,那该怎么做呢? Django 提供 F() 来做这样的比较.F() 的 ...

  5. LoRaWAN_stack移植笔记(三)__SPI

    stm32相关的配置 由于例程使用的主控芯片为STM32L151C8T6,而在本设计中使用的主控芯片为STM32L051C8T6,内核不一样,并且Cube库相关的函数接口及配置也会有不同,所以芯片的驱 ...

  6. vux-scroller实现移动端上拉加载功能

    本文将讲述vue-cli+vux-scroller实现移动端的上拉加载功能: 纠错声明:网上查阅资料看到很多人都将vux和vuex弄混,在这里我们先解释一下,vuex是vue框架自带的组件,是数据状态 ...

  7. 从强转 byte 说起

    折腾的心,颤抖的手,只因在 main 函数中执行了一次 int 强转 byte 的操作,输出结果太出所料,于是入坑,钻研良久,遂有此篇. 我们都知道,Java中有8中基本数据类型,每种类型都有取值范围 ...

  8. 牛客练习赛22C Bitset

    牛客练习赛22C 一共有 n个数,第 i 个数是 xi  xi 可以取 [li , ri] 中任意的一个值. 设 ,求 S 种类数. 感觉二进制真是一个神奇的东西. #include <iost ...

  9. atcoder D - 11(组合数学)

    题目链接:http://arc077.contest.atcoder.jp/tasks/arc077_b 题解:有n+1个数只有一个数字是有重复出现的,要求一共有多少不同的组合显然和这两个数的位置有关 ...

  10. codeforces 456 D. A Lot of Games(字典数+博弈+思维+树形dp)

    题目链接:http://codeforces.com/contest/456/problem/D 题意:给n个字符串.进行k次游戏.每局开始,字符串为空串,然后两人轮流在末尾追加字符,保证新的字符串为 ...