【SOUTH CENTRAL USA 1998】 eight

【题目链接】

点击打开链接

【算法】

这是经典的八数码问题，据说此题不做人生不完整

这里笔者用的是双向广搜，由于细节较多，笔者花了3h才通过此题

【代码】

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
#include <stack>
#include <limits.h>

using namespace std;

struct info {
        int x,y,h;
        int a[];
};

const int dir[][] = {{,},{,-},{,},{-,}};
const int fac[] = {,,,,,,,,,};

int i,d,h1,t1,h2,t2;
int val[],pre1[],pre2[],
        step1[],step2[],visit[];
int s[] = {,,,,,,,,,};
vector<int> path1,path2;
info q1[],q2[];
char x;

int getcantorHash(int a[]) {
        int i,j,s,ret=;
        for (i = ; i < ; i++) {
                s = ;
                for (j = i + ; j <= ; j++) {
                        if (a[i] > a[j])
                                s++;
                }
                ret += s * fac[-i];
        }
        return ret;
}

void getpath1(int Hash) {
        int i;
        i = t1;
        while (i > ) {
                path1.push_back(step1[q1[i].h]);
                i = pre1[q1[i].h];
        }
        reverse(path1.begin(),path1.end());
        path2.push_back(step2[Hash]);
        i = pre2[Hash];
        while (i > ) {
                path2.push_back(step2[q2[i].h]);
                i = pre2[q2[i].h];
        }
}

void getpath2(int Hash) {
        path1.push_back(step1[Hash]);
        i =    pre1[Hash];
        while (i > ) {
                path1.push_back(step1[q1[i].h]);
                i = pre1[q1[i].h];
        }
        reverse(path1.begin(),path1.end());
        i = t2;
        while (i > ) {
                path2.push_back(step2[q2[i].h]);
                i = pre2[q2[i].h];
        }
}

bool DBFS() {
        int x,y,tx,ty,Hash;
        int arr[];
        h1 = t1 = h2 = t2 = ;
        q1[].x = (d - ) /  + ;
        q1[].y = (d - ) %  + ;
        q1[].h = getcantorHash(val);
        memcpy((char*)&q1[].a[],(char*)&val[],sizeof(int)*);
        step1[getcantorHash(val)] = pre1[getcantorHash(val)] = -;
        visit[getcantorHash(val)] = ;
        q2[].x = q2[].y = ;
        q2[].h = getcantorHash(s);
        memcpy((char*)&q2[].a[],(char*)&s[],sizeof(int)*);
        step2[getcantorHash(s)] = pre2[getcantorHash(s)] = -;
         visit[getcantorHash(s)] = ;
        while ((h1 <= t1) || (h2 <= t2)) {
                x = q1[h1].x; y = q1[h1].y;
                for (i = ; i < ; i++) {
                        memcpy((char*)&arr[],(char*)&q1[h1].a[],sizeof(int)*);
                        tx = x + dir[i][];
                        ty = y + dir[i][];
                        if ((tx <= ) || (tx > ) || (ty <= ) || (ty > ))
                                continue;
                        swap(arr[(x-)*+y],arr[(tx-)*+ty]);
                        Hash = getcantorHash(arr);
                        if (visit[Hash] == ) {
                                visit[Hash] = ;
                                ++t1;
                                q1[t1].x = tx;
                                q1[t1].y = ty;
                                memcpy((char*)&q1[t1].a[],(char*)&arr[],sizeof(int)*);
                                q1[t1].h = Hash;
                                step1[Hash] = i;
                                pre1[Hash] = h1;
                        }else if (visit[Hash] == ) {
                                continue;
                        }else {
                                ++t1;
                                q1[t1].h = Hash;
                                step1[Hash] = i;
                                pre1[Hash] = h1;
                                getpath1(Hash);
                                return true;
                        }
                }
                x = q2[h2].x; y = q2[h2].y;
                for (i = ; i < ; i++) {
                        memcpy((char*)&arr[],(char*)&q2[h2].a[],sizeof(int)*);
                        tx = x + dir[i][];
                        ty = y + dir[i][];
                        if ((tx <= ) || (tx > ) || (ty <= ) || (ty > ))
                                continue;
                        swap(arr[(x-)*+y],arr[(tx-)*+ty]);
                        Hash = getcantorHash(arr);
                        if (visit[Hash] == ) {
                                visit[Hash] = ;
                                ++t2;
                                q2[t2].x = tx;
                                q2[t2].y = ty;
                                q2[t2].h = Hash;
                                memcpy((char*)&q2[t2].a[],(char*)&arr[],sizeof(int)*);
                                step2[Hash] = i;
                                pre2[Hash] = h2;
                        }else if (visit[Hash] == ) {
                                continue;
                        }else {
                                ++t2;
                                q2[t2].h = Hash;
                                step2[Hash] = i;
                                pre2[Hash] = h2;
                                getpath2(Hash);
                                return true;
                        }
                }
                h1++; h2++;
        }
        return false;
}

void print() {
        int i;
        for (i = ; i < path1.size(); i++) {
                switch(path1[i]) {
                        case  : putchar('r');
                                         break;
                        case  : putchar('l');
                                         break;
                        case  : putchar('d');
                                         break;
                        default : putchar('u');
                }
        }
        for (i = ; i < path2.size(); i++) {
                switch(path2[i]) {
                        case  : putchar('l');
                                         break;
                        case  : putchar('r');
                                         break;
                        case  : putchar('u');
                                         break;
                        default : putchar('d');
                }
        }
        puts("");
}

int main() {

        for (i = ; i <= ; i++) {
                x = getchar();
                if (x == 'x') {
                        d = i;
                        val[i] = ;
                }else
                        val[i] = x - '';
                getchar();
        }

        if (DBFS()) print();
        else puts("unsolvable");

        return ;

}