迭代加深搜索算法总结 + Editing a Book UVa11212题解

迭代加深搜索算法：

对于可以用回溯法解决，但是解答树结点数大的恐怖的问题的一种解决办法，有的问题甚至用bfs连一层节点都遍历不完就超时了。具体方法就是依次枚举搜索层数，从1到一个上限。

---

结构：

int solve() {

　　for (int maxd = 1; maxd < MAXN; maxd++) {

　　　　if (dfs(0, maxd)) return maxd;

　　}

　　return MAXN;

}

---

优点：

　　相较于bfs老老实实的枚举解答树而言， 迭代加深搜索算法可以以深度优先搜索，也就是说可以第一时间到达最深层次进行搜索。平均时间上而言比bfs逐层搜索要快太多太多了，再配合回溯剪枝。优化效果相当可观！

举例：

UVa11212 Editing a Book

对于这道题， 0 < n < 10, 也就是总状态有9！ ＝ 362880个。 虽然看起来很少，但是每个结点可以扩展到的结点个数是 (n * (n/2) * (n/2)) ＝ (n^3)/4 ≈ 183, 再加上对每个结点判重和剪枝计算，每个结点的计算量大概是 183 * 40 ＝ 7290

所以对于一组n = 9的数据，最差情况的计算量是 n! * (n^3)/4 * 40 ≈ 26亿

然而测试数据一共有20组

也就是说 总计算量是 26亿 ＊ 20 ＝ 520亿

即便我用bfs＋剪枝， 程序还是毫无悬念的超时了。

然而如果我用迭代加深搜索算法，20组数据运行时间总和是49ms， 快了2000倍！

UVa11212 Editing a Book 迭代加深搜索＋剪枝(49ms, Ac)

#include <cstdio>
#include <cstring>
using namespace std;

int n, idx, maxd, a[];
bool ok;

void create(int start, int len, int k) {
    int olda[];
    memcpy(olda, a, sizeof(a));
    int z = , i = ;
    for (; z < k; z++) {
        if (z >= start && z < start + len) { z += (len - ); continue;}
        a[i++] = olda[z];
    }
    for (z = ; z < len; z++) a[i++] = olda[start + z];
    for (z = k; z < n; z++) {
        if (z >= start && z < start + len) { z += (len - ); continue;}
        a[i++] = olda[z];
    }
}

int num_unordered() {
    int cnt = ;
    for (int i = ; i < n; i++) if (a[i - ] +  != a[i]) cnt++;
    cnt = cnt ? cnt +  : ;
    return cnt;
}

bool success() {
    for (int i = ; i < n - ; i++) if (a[i] +  != a[i + ]) return false;
    return true;
}

bool dfs(int d) {
    if (d *  + num_unordered() >  * maxd) return false;
    if (success()) { ok = ; return true;}
    int temp[];
    memcpy(temp, a, sizeof(a));
    for (int i = ; i < n; i++)
        for (int j = i + ; j <= n; j++)
            for (int k = ; k <= n; k++) {
                if (k >= i && k <= j) { k = j; continue;}
                create(i, j - i, k);
                if (dfs(d + )) return true;
                memcpy(a, temp, sizeof(a));
            }
    return false;
}

int solve() {
    if (success()) return ;
    ok = ;
    for (maxd = ; maxd < ; maxd++)
        if (dfs()) return maxd;
    return maxd;
}

int main() {
    int T = ;
    while (scanf("%d", &n) ==  && n) {
        printf("Case %d: ", ++T);
        for (int i = ; i < n; i++) scanf("%d", &a[i]);
        int ans = solve();
        printf("%d\n", ans);
    }
    return ;
}

UVa11212 Editing a Book BFS搜索＋剪枝 (估计耗时18s)

#include <cstdio>
#include <cstdlib>
#include <queue>
#include <algorithm>
#include <cstring>
using namespace std;

const int MAXN = , MAXHASHSIZE = ;
int n, idx, target;
int a[], _head[MAXHASHSIZE], _next[MAXN], st[MAXN];

struct Node {
    int arr[], dis, num;
    Node (int d = ): dis(d) {}
    void trans() {
        num = ;
        for (int i = ; i < n; i++) {
            num *= ;
            num += arr[i];
        }
    }
};

bool try_to_insert(Node &cur) {
    int h = cur.num % MAXHASHSIZE;
    int u = _head[h];
    while (u) {
        if (st[u] == cur.num) return false;
        u = _next[u];
    }
    st[idx] = cur.num;
    _next[idx] = _head[h];
    _head[h] = idx++;
    return true;
}

void create(Node &from, Node &des, int start, int len, int k) {
    int z = , i = ;
    for (; z < k; z++) {
        if (z >= start && z < start + len) { z += (len - ); continue;}
        des.arr[i++] = from.arr[z];
    }
    for (z = ; z < len; z++) des.arr[i++] = from.arr[start + z];
    for (z = k; z < n; z++) {
        if (z >= start && z < start + len) { z += (len - ); continue;}
        des.arr[i++] = from.arr[z];
    }
}

bool impossible(Node &cur) {
    int cnt = ;
    for (int i = ; i < n; i++) if (cur.arr[i - ] +  != cur.arr[i]) cnt++;
    cnt = cnt ? cnt +  : ;
    return cnt >  * ( - cur.dis);
}

int bfs() {
    queue<Node> q;
    Node start;
    for (int i = ; i < n; i++) start.arr[i] = a[i];
    start.trans();
    try_to_insert(start);
    q.push(start);
    while (!q.empty()) {
        Node cur = q.front(); q.pop();
        cur.trans();
        if (cur.num == target) return cur.dis;
        for (int i = ; i < n; i++)
            for (int j = i + ; j <= n; j++)
                for (int k = ; k <= n; k++) {
                    if (k >= i && k <= j) { k = j; continue;}
                    Node nextn;
                    create(cur, nextn, i, j - i, k);
                    nextn.trans();
                    if (!impossible(nextn) && try_to_insert(nextn)) {
                        nextn.dis = cur.dis + ;
                        q.push(nextn);
                    }
                }
    }
    return ;
}

int main() {
    int T = ;
    while (scanf("%d", &n) ==  && n) {
        printf("Case %d: ", ++T);
        target = idx = ;
        for (int i = ; i < n; i++) {
            scanf("%d", &a[i]);
            target *= ;
            target += i + ;
        }
        memset(_head, , sizeof(_head));
        int ans = bfs();
        printf("%d\n", ans);
    }
    return ;
}