HDU 1043 八数码问题的多种解法

一、思路很简单，搜索。对于每一种状态，利用康托展开编码成一个整数。于是，状态就可以记忆了。

二、在搜索之前，可以先做个优化，对于逆序数为奇数的序列，一定无解。

三、搜索方法有很多。

　　1、最普通的：深搜、广搜。在这题里面，这两个方法直接TLE。所以，我后面没有贴超时的代码。

　　2、既然1超时，那就预处理出所有状态，用map存储，然而，map的insert（使用[]是一样的）实在太慢了，也超时。

　　3、在1的基础上，优化一下，得到：IDA*，双向广搜，A*。

　　3、IDA*我没尝试，不过感觉没有A*快。另外，双向广搜可以加优化，在HDU上可以快大概300ms，就是：对于某一个方向，在开始BFS时，如果当前的队列里面状态个数很多，而另外一个队列里面相对较少，那么，把搜索方面换成另一边。这样，不至于出现两个队列的状态个数相差太远以至于退化成单向BFS的情况。当然，这个题两个队列中的状态都是比较均匀的，即使不加优化，效果也不会太差。

　　4、不管用的是什么搜索，搜索过程中，多个样例经历经历相同的状态是非常有可能的，所以，理论上来说，可以加缓存，也就是其实不管是什么样例，只要序列确定，得到的整数编码一定是确定的，所以，理论上来说，加缓存可以加速，然而， 不知为何，这题，加了缓存还更慢。多半是因为我的缓存用的是C++ STL吧。

四、注意点

　　1、双向BFS加优化时，C++的queue的size()的返回值类型是unsigned int，直接相减，会发生溢出的情况， 导致size()小的队列大小一直不变，size()大的队列一直在扩大，也就是退化成了单向BFS了。T_T。所以，为了防止这种情况发生，在size相减之前，用两个int变量先存储好这两个队列的size。否则，会很坑。

　　2、在循环中开辟新指针，每一次循环开辟的指针值都一样，如代码所示。

#include
using namespace std;

typedef struct Foo{
    int v1, v2;
    Foo(int _v1,int _v2){
        v1 = _v1;
        v2 = _v2;
    }
    Foo(){}
}Node;

set s;
int main(){
    for(int i = 0;i < 5;++i){
        Node node = Node(i, i);
        s.insert(&node);
    }
    printf("%d\n", s.size());
}

输出结果会是1，而不是5。特别要注意。而如果这么写：

#include
using namespace std;

typedef struct Foo{
    int v1, v2;
    Foo(int _v1,int _v2){
        v1 = _v1;
        v2 = _v2;
    }
    Foo(){}
}Node;

set s;
int main(){
    for(int i = 0;i < 5;++i){
        Node* pnode = new Node(i, i);
        s.insert(pnode);
    }
    printf("%d\n", s.size());
}

因为C++没有自动垃圾回收，所以，很有可能会出现MLE的情况。因此，ACM竞赛中，尽可能地不要使用指针。

　　3、C++的容器，map、string、vector之类的，慢！慢！慢！如果条件允许，时间又压得比较紧，特别是像string这种的，最好还是用C语言原生的字符串数组，虽然麻烦些，但是比string快不只一点点。

五、源代码

　　1、双向BFS（队列容量均衡优化）

#include
#include
#include
#include
#include
#include
using namespace std;
int facts[15];

void init() {
    facts[0] = facts[1] = 1;
    for(int i = 2; i <= 10; ++i)facts[i] = facts[i - 1] * i;
}

int encode(vector<int>& seq) {
    int res = 0;
    int num = seq.size();
    for(int i = 0; i < num - 1; ++i) {
        int cnt = seq[i] - 1;
        for(int j = 0; j < i; ++j) {
            if(seq[j] < seq[i])--cnt;
        }
        res += cnt * facts[num - i - 1];
    }
    return res;
}

vector<int> temp;
void decode(int n, int m) {
    temp.clear();
    int buf = 0;
    int i, j, r, t;
    for(t = n; t > 0; --t) {
        r = m / facts[t - 1];
        m %= facts[t - 1];
        for(i = 1; i <= n; ++i) {
            if(!((buf >> i) & 1)) {
                if(r == 0)break;
                --r;
            }
        }
        temp.push_back(i);
        buf |= 1 << i;
    }
}

char line[30];
int get() {
    vector<int> vec;
    int len = strlen(line);
    for(int i = 0; i < len; ++i) {
        if(isdigit(line[i]))vec.push_back(line[i] - '0');
        else if(line[i] == 'x')vec.push_back(9);
    }
    int cnt = 0;
    for(int i = 0, sz = vec.size(); i < sz; ++i) {
        if(vec[i] == 9)continue;
        for(int j = 0; j < i; ++j) {
            if(vec[j] == 9)continue;
            if(vec[j] > vec[i])++cnt;
        }
    }
    if(cnt & 1)return -1;
    else return encode(vec);
}

int findPos() {
    for(int i = 0; i < 9; ++i)if(temp[i] == 9)return i;
    return -1;
}
typedef struct Foo {
    int code;
    char step;
    Foo(int l, char s) {
        code = l;
        step = s;
    }
    Foo() {}
} Node;
string res[2];
const int dirs[] = { -1, 1, -3, 3};
queue<int> que[2];
bool vis[2][362888];
Node pre[2][362888];
bool bfs(int s[]) {
    for(int i = 0; i < 2; ++i) {
        res[i].clear();
        while(!que[i].empty())que[i].pop();
        memset(vis[i], 0, sizeof(vis[i]));
        vis[i][s[i]] = true;
        for(int j = 0; j < 362888; ++j)pre[i][j].code = -1;
        que[i].push(s[i]);
    }
    int k = 0;
    while(!que[k].empty()) {
        int sz1 = que[k].size(), sz2 = que[k ^ 1].size();
        if(sz1 - sz2 > 1)k ^= 1;//队列均衡优化

        int code = que[k].front();
        que[k].pop();
        if(vis[k ^ 1][code]) {
            for(int i = 0; i < 2; ++i) {
                int now = code;
                int last = pre[i][now].code;
                while(last != -1) {
                    res[i].push_back(pre[i][now].step);
                    now = last;
                    last = pre[i][last].code;
                }
                if(i == 0)reverse(res[i].begin(), res[i].end());
            }
            return true;
        }
        decode(9, code);
        int pos = findPos();
        for(int i = 0; i < 4; ++i) {
            int np = pos + dirs[i];
            if(np < 0 || np > 8)continue;
            bool cond = false;
            if(i == 0 || i == 1)cond = (np / 3 == pos / 3);
            else if(i == 2 || i == 3)cond = (np >= 0 && np <= 8);
            if(cond) {
                swap(temp[np], temp[pos]);
                int nv = encode(temp);
                if(!vis[k][nv]) {
                    if(i == 0)pre[k][nv] = Node(code, 'l');
                    else if(i == 1)pre[k][nv] = Node(code, 'r');
                    else if(i == 2)pre[k][nv] = Node(code, 'u');
                    else if(i == 3)pre[k][nv] = Node(code, 'd');
                    que[k].push(nv);
                    vis[k][nv] = true;
                }
                swap(temp[np], temp[pos]);
            }
        }
        k ^= 1;
    }
    return false;
}

void change(string& s) {
    for(int i = 0, len = s.length(); i < len; ++i) {
        if(s[i] == 'l')s[i] = 'r';
        else if(s[i] == 'r')s[i] = 'l';
        else if(s[i] == 'u')s[i] = 'd';
        else if(s[i] == 'd')s[i] = 'u';
    }
    reverse(s.begin(), s.end());
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif // ONLINE_JUDGE
    ios::sync_with_stdio(false);
    init();
    while(gets(line) != NULL) {
        int v = get();
        if(v < 0)cout << "unsolvable" << endl;
        else if(v == 0)cout << endl;
        else {
            int s[] = {v, 0};
            if(bfs(s)) {
                change(res[1]);
                cout << res[0] << res[1] << endl;
            } else cout << "unsolvable" << endl;
        }
    }
}

2、A*搜索。

#include
using namespace std;
int facts[10];
char input[30];
typedef struct Foo {
    int code;
    int pos9;
    double g, h;
    Foo(int c, int p, double _g, double _h) {
        code = c;
        pos9 = p;
        g = _g;
        h = _h;
    }
    Foo() {}
    /*这里写法决定时间的数量级：
        用注释的这种写法：耗时2700+ms；
        用没注释的这种写法，if括号里写成fabs(h - ano.h) < 1e-8,耗时1200+ms；
        现在这种写法：耗时800+ms;；
    */
    bool operator < (const Foo ano) const {
//        if(fabs(f - ano.f) < 1e-8)return h > ano.h;
//        else return f > ano.f;
        if(h == ano.h)return g > ano.g;
        else return h > ano.h;
    }
} Node;

void init0() {
    facts[0] = facts[1] = 1;
    for(int i = 2; i < 10; ++i)facts[i] = facts[i - 1] * i;
}

int encode(string& seq) {
    int res = 0, len = seq.length(), i, j, cnt;
    for(i = 0; i < len; ++i) {
        cnt = (seq[i] - '1');
        for(j = 0; j < i; ++j)if(seq[j] < seq[i])--cnt;
        res += cnt * facts[len - i - 1];
    }
    return res;
}

string decode(int code) {
    int i, j, r, t, board = 0;
    string res;
    for(t = 9; t > 0; --t) {
        r = code / facts[t - 1];
        code %= facts[t - 1];
        for(i = 1; i <= 9; ++i) {
            if(!((board >> i) & 1)) {
                if(r == 0)break;
                else --r;
            }
        }
        res.push_back(i + '0');
        board |= 1 << i;
    }
    return res;
}

double distance(int src) {
    double res = 0.0;
    string seq = decode(src);
    int len = seq.length();
    int i, j, x0, y0, x1, y1, num;
    for(i = 0; i < len; ++i) {
        num = seq[i] - '0';
        x0 = (num - 1) / 3, y0 = (num - 1) % 3;
        x1 = i / 3, y1 = i % 3;
        res += abs(x0 - x1) + abs(y0 - y1);
    }
    return res;
}

int find_pos9(string& str) {
    int len = str.length(), i;
    for(i = 0; i < len; ++i)if(str[i] == '9')return i;
    return -1;
}

const int dirs[] = { -1, 1, -3, 3};
priority_queue que;
bool vis[362888];
pair<int, char> pre[362888];
string ans;

bool bfs(int s) {
    int i, j, k;
    int pos9, npos9, ncode;
    string seq;
    Node top_node;
    while(!que.empty())que.pop();
    memset(vis, 0, sizeof(vis));
    for(i = 0; i < facts[9]; ++i)pre[i].first = -1;
    vis[s] = true;
    seq = decode(s);
    pos9 = find_pos9(seq);
    que.push(Node(s, pos9, 0, distance(s)));
    while(!que.empty()) {
        top_node = que.top();
        que.pop();
        if(top_node.code == 0) {
            ans.clear();
            for(int now = top_node.code, last = pre[top_node.code].first; last != -1; now = last, last = pre[last].first) {
                ans.push_back(pre[now].second);
            }
            reverse(ans.begin(), ans.end());
            return true;
        }
        seq = decode(top_node.code);
        pos9 = top_node.pos9;
        for(i = 0; i < 4; ++i) {
            npos9 = pos9 + dirs[i];
            if(npos9 < 0 || npos9 > 8)continue;
            if((i == 0 || i == 1) && npos9 / 3 != pos9 / 3)continue;
            if((i == 2 || i == 3) && (npos9 < 0 || npos9 > 8))continue;
            swap(seq[npos9], seq[pos9]);
            ncode = encode(seq);
            if(!vis[ncode]) {
                pre[ncode].first = top_node.code;
                if(i == 0)pre[ncode].second = 'l';
                else if(i == 1)pre[ncode].second = 'r';
                else if(i == 2)pre[ncode].second = 'u';
                else if(i == 3)pre[ncode].second = 'd';
                que.push(Node(ncode, npos9, top_node.g + 1, distance(ncode)));
                vis[ncode] = true;
            }
            swap(seq[npos9], seq[pos9]);
        }
    }
    return false;
}

int get_code(char str[]) {
    string temp;
    int len = strlen(str), i, j, cnt;
    for(i = 0; i < len; ++i) {
        if(isdigit(str[i]))temp.push_back(str[i]);
        else if(str[i] == 'x')temp.push_back('9');
    }
    cnt = 0;
    len = temp.length();
    for(i = 0; i < len; ++i) {
        if(temp[i] == '9')continue;
        for(j = 0; j < i; ++j) {
            if(temp[j] == '9')continue;
            if(temp[j] > temp[i])++cnt;

        }
    }
    if(cnt & 1)return -1;
    else return encode(temp);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
    ios::sync_with_stdio(false);
    init0();
    while(gets(input) != NULL) {
        int code = get_code(input);
        if(code < 0)cout << "unsolvable" << endl;
        else if(code == 0)cout << endl;
        else cout << (bfs(code) ? ans : "unsolvable") << endl;
    }
    return 0;
}

3、纯C语言版A*算法。耗时：400+ms。其实priority_queue和stack等都是C++ STL。^_^

#include
using namespace std;
char input[30];
int facts[10];
typedef struct Foo {
    char seq[10];
    int code, pos9;
    double g, h;
    Foo(char s[], int c, int p, double _g, double _h) {
        strcpy(seq, s);
        code = c, pos9 = p;
        g = _g, h = _h;
    }
    Foo() {}
    bool operator < (const Foo ano) const {
        if(h == ano.h)return g > ano.g;
        else return h > ano.h;
    }
} Node;

void init0() {
    facts[0] = facts[1] = 1;
    for(int i = 2; i < 10; ++i)facts[i] = facts[i - 1] * i;
}

int encode(const char seq[]) {
    int res = 0, i, j, cnt, len = strlen(seq);
    for(i = 0; i < len; ++i) {
        cnt = seq[i] - '1';
        for(j = 0; j < i; ++j)if(seq[j] < seq[i])--cnt;
        res += cnt * facts[len - i - 1];
    }
    return res;
}

int find_pos9(const char str[]) {
    int len = strlen(str), i;
    for(i = 0; i < len; ++i)if(str[i] == '9')return i;
    return -1;
}

double dist(const char str[]) {
    int len = strlen(str), i, x0, y0, x1, y1, num;
    double res = 0.0;
    for(i = 0; i < len; ++i) {
        num = str[i] - '0';
        x0 = (num - 1) / 3, y0 = (num - 1) % 3;
        x1 = i / 3, y1 = i % 3;
        res += abs(x0 - x1) + abs(y0 - y1);
    }
    return res;
}

const int dirs[] = { -1, 1, -3, 3};
priority_queue que;
bool vis[362888];
pair<int, char> pre[362888];
stack<char> ans;
bool bfs(int s) {
    int i, j, k;
    Node node, new_node;
    while(!que.empty())que.pop();
    memset(vis, 0, sizeof(vis));
    for(i = 0; i < facts[9]; ++i)pre[i].first = -1;
    vis[s] = true;
    que.push(Node(input, s, find_pos9(input), 0, dist(input)));
    while(!que.empty()) {
        node = que.top();
        que.pop();
        if(node.code == 0) {
            while(!ans.empty())ans.pop();
            for(int last = pre[0].first, now = 0; last != -1; now = last, last = pre[last].first)
                ans.push(pre[now].second);
            return true;
        }
        for(i = 0; i < 4; ++i) {
            new_node = node;
            new_node.pos9 += dirs[i];
            if(new_node.pos9 < 0 || new_node.pos9 > 8)continue;
            if((i == 0 || i == 1) && (new_node.pos9 / 3 != node.pos9 / 3))continue;
            swap(new_node.seq[new_node.pos9], new_node.seq[node.pos9]);
            new_node.code = encode(new_node.seq);
            if(!vis[new_node.code]) {
                ++new_node.g;
                new_node.h = dist(new_node.seq);
                que.push(new_node);
                vis[new_node.code] = true;
                pre[new_node.code].first = node.code;
                if(i == 0)pre[new_node.code].second = 'l';
                else if(i == 1)pre[new_node.code].second = 'r';
                else if(i == 2)pre[new_node.code].second = 'u';
                else if(i == 3)pre[new_node.code].second = 'd';
            }
        }
    }
    return false;
}


int get_code(char str[]) {
    char temp[10];
    int i, j, len = strlen(str);
    for(i = 0, j = 0; i < len; ++i) {
        if(isdigit(str[i]))temp[j++] = str[i];
        else if(str[i] == 'x')temp[j++] = '9';
    }
    temp[j++] = '\0';

    memset(input, '\0', sizeof(input));
    strcpy(input, temp);

    int cnt = 0;
    len = j - 1;
    for(i = 0; i < len; ++i) {
        if(temp[i] == '9')continue;
        for(j = 0; j < i; ++j) {
            if(temp[j] == '9')continue;
            if(temp[j] < temp[i])++cnt;
        }
    }
    if(cnt & 1)return -1;
    else return encode(temp);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    init0();
    while(gets(input) != NULL) {
        int code = get_code(input);
        if(code < 0)printf("unsolvable\n");
        else if(code == 0)putchar('\n');
        else {
            if(bfs(code)) {
                for(; !ans.empty(); ans.pop())putchar(ans.top());
                putchar('\n');
            } else printf("unsolvable\n");
        }
    }
    return 0;
}

六、A*算法确实是厉害。估值函数写得好可以很快；写不好，效果就会很差，甚至退化成普通的BFS。

转载于:https://www.cnblogs.com/fuzhihong0917/p/7966267.html