HDU1043、3567八数码 bfs+康托展开

康托展开

定义

 

其中表示ai当前未出现的元素中是排第几个(从0开始)。并且0<=ai<i(1<=i<=n)。它的意义是把一个序列映射成一个数。（来自百度百科）

例如，有一个数组 s = ["A", "B", "C", "D"]，它的一个排列 s1 = ["D", "B", "A", "C"]，现在要把 s1 映射成 X。n 指的是数组的长度，也就是4，所以X(s1) = a4*3! + a3*2! + a2*1! + a1*0!
      a4 = "D" 这个元素在子数组 ["D", "B", "A", "C"] 中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，"D"是第3大的元素，所以 a4 = 3。
      a3 = "B" 这个元素在子数组 ["B", "A", "C"] 中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，所以 a3 = 1。
a2 = "A" 这个元素在子数组 ["A", "C"] 中是第几大的元素。"A"是第0大的元素，"C"是第1大的元素，所以 a2 = 0。
      a1 = "C" 这个元素在子数组 ["C"] 中是第几大的元素。"C" 是第0大的元素，所以 a1 = 0。（因为子数组只有1个元素，所以a1总是为0）
所以，X(s1) = 3*3! + 1*2! + 0*1! + 0*0! = 20
       如果已知 s = ["A", "B", "C", "D"]，X(s1) = 20，利用下图的方式可以求出a1，a2，a3，a4，进而推出序列。（来源于http://blog.csdn.net/zhongkeli/article/details/6966805）

 HDU 1043  Eight 是一个经典的八数码问题，对于任意给的一个状态，求出是否可以到达初始的状态，求出最小的步数。利用康托定理，将每个状态转换成一个数，从最终状态出发进行BFS，打表保存最后在做查询。注意点是这道题的输入有多组，不能scanf，用gets处理输入。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 370000;
int st[11];
int fac[10];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
struct node1 {
    int fa;
    char ss;
} f[MAXN];
struct node {
    int loc, cat;
    int ar[11];
}u, v;
void get_fac() {
    fac[0] = 1;
    for (int i = 1; i < 9; i++) {
        fac[i] = i*fac[i - 1];
    }
}
int cantor(int a[]) {
    int res = 0; 
    for(int i = 0; i < 9; i++) {  
        int k = 0;  
        for(int j = i + 1; j < 9; j++)  
        if(a[i] > a[j]) k++;  
        res += k*fac[8 - i];  
    }  
    return res;
}
void bfs() {
    queue<node> que;
    while (que.size()) que.pop();
    u.loc = 8; 
    for (int i = 0; i < 9; i++) u.ar[i] = i + 1;
    u.cat = 0;
    f[u.cat].fa = 0;
    que.push(u);
    while (que.size()) {
        v = que.front(); que.pop();
        for (int i = 0; i < 4; i++) {
            int tx = v.loc/3 + dx[i]; 
            int ty = v.loc%3 + dy[i];
            if (tx >= 3 || tx < 0 || ty >= 3 || ty < 0) continue;
            u = v; u.loc = tx*3 + ty;
            int temp = u.ar[v.loc];
            u.ar[v.loc] = u.ar[u.loc];
            u.ar[u.loc] = temp;
            u.cat = cantor(u.ar);
            if (f[u.cat].fa == -1) {
                if (i == 0) f[u.cat].ss = 'l';
                else if (i == 1) f[u.cat].ss = 'u';
                else if (i == 2) f[u.cat].ss = 'r';
                else f[u.cat].ss = 'd';
                f[u.cat].fa = v.cat;
                que.push(u);
            }
        }
    }
}
void init() {
    get_fac();
    for (int i = 0; i < MAXN; i++) f[i].fa = -1;
}
int main(int argc, char const *argv[]) {
    init();bfs();
    char str[100];
    while (gets(str) > 0) {
        int cnt = 0;
        for (int i = 0; str[i] != '' ; i++) {
            if (str[i] == 'x') st[cnt++] = 9;
            else if (str[i] >= '0' && str[i] <= '9') st[cnt++] = str[i] - '0';
        }
        int d = cantor(st);
        if (f[d].fa == -1) printf("%s
", "unsolvable");
        else {
            while (d) {
                printf("%c", f[d].ss);
                d = f[d].fa;
            }
            printf("
");
        }
    }
    
    return 0;
}

HDU 3567 EightII 是个稍微升级版的题目，一开始我直接BFS，结果超时。然后看到dalao打表X位于9个不同位置，然后每次将初始序列进行映射为九个中的一个，在把最终状态的序列按照同样的法则进行映射，真是膜拜了

#include <bits/stdc++.h>
#define LOCAL
using namespace std;
const int MAXN = 500000;
int fn[20], fac[20];
int fa[10][MAXN], res[10][MAXN];
int dx[] = {1,0,0,-1};
int dy[] = {0,-1,1,0};
char way[] = "dlru";
bool vis[MAXN];
char st[20], pt[MAXN];
struct node {
    char ss[10];
    int loc;
}tp;
int cantor(char s[]) {
    int res = 0;
    for (int i = 0; i < 9; i++) {
        int k = 0;
        for (int j = i + 1; j < 9; j++) {
            if (s[i] > s[j]) k++;
        }
        res += fac[8 - i]*k;
    }
    return res;
}
void bfs(int p) {
    queue<node> que;
    memset(fa[p], -1, sizeof(fa[p]));
    memset(vis, false, sizeof(vis));
    strcpy(tp.ss, st); int tpcat = cantor(tp.ss); 
    tp.loc = p; vis[tpcat] = true;
    que.push(tp);
    node u, v;
    while (!que.empty()) {
        v = que.front(); que.pop();
        int vcat = cantor(v.ss); 
        for (int i = 0; i < 4; i++) {
            u = v; 
            int tx = u.loc/3 + dx[i];
            int ty = u.loc%3 + dy[i];
            if (tx > 2 || tx < 0 || ty > 2 || ty < 0) continue;
            u.loc = tx*3 + ty;
            u.ss[v.loc] = u.ss[u.loc]; u.ss[u.loc] = 'X';
            int ucat = cantor(u.ss);
            if (vis[ucat]) continue;
            vis[ucat] = true;
            res[p][ucat] = way[i];
            fa[p][ucat] = vcat;
            que.push(u);
        }
    }
}
void init() {
    fac[0] = 1;
    for (int i = 1; i < 10; i++) {
        fac[i] = fac[i - 1]*i;
    }
    memset(fa, -1, sizeof(fa));
    strcpy(st, "X12345678"); bfs(0);
    strcpy(st, "1X2345678"); bfs(1);
    strcpy(st, "12X345678"); bfs(2);
    strcpy(st, "123X45678"); bfs(3);
    strcpy(st, "1234X5678"); bfs(4);
    strcpy(st, "12345X678"); bfs(5);
    strcpy(st, "123456X78"); bfs(6);
    strcpy(st, "1234567X8"); bfs(7);
    strcpy(st, "12345678X"); bfs(8);
}
int main(int argc, char const *argv[])
{
    int T;
    // freopen("in.txt", "r", stdin);
    // freopen("out1.txt", "w", stdout);
    init();
    int Kcase  = 0;
    scanf("%d", &T);
    while (T--) {
        int cnt = 0; int p;
        char str[100]; scanf("%s", str);
        for (int i = 0; i < 9; i++) {
            if (str[i] == 'X') p = i;
            else fn[str[i] - '0'] = cnt++;
        }
        scanf("%s", str); cnt = 0;
        for (int i = 0; i < 9; i++) {
            if (str[i] != 'X') str[i] = fn[str[i] - '0'] + '1';
        }
        int d = cantor(str);
        while (d != -1) {
            pt[cnt++] = res[p][d];
            d = fa[p][d];
        }
        printf("Case %d: %d
", ++Kcase, cnt-1);
        for (int i = cnt - 2; i >= 0; i--) {
            printf("%c", pt[i]);
        }
        printf("
");
    }
    return 0;
}