排书

排书

给定 $n$ 本书，编号为 $1 \sim n$。

在初始状态下，书是任意排列的。

在每一次操作中，可以抽取其中连续的一段，再把这段插入到其他某个位置。

我们的目标状态是把书按照 $1 \sim n$ 的顺序依次排列。

求最少需要多少次操作。

输入格式

第一行包含整数 $T$，表示共有 $T$ 组测试数据。

每组数据包含两行，第一行为整数 $n$，表示书的数量。

第二行为 $n$ 个整数，表示 $1 \sim n$ 的一种任意排列。

同行数之间用空格隔开。

输出格式

每组数据输出一个最少操作次数。

如果最少操作次数大于或等于 $5$ 次，则输出 5 or more 。

每个结果占一行。

数据范围

$1 \leq n \leq 15$

输入样例：

3
6
1 3 4 6 2 5
5
5 4 3 2 1
10
6 8 5 3 4 7 2 9 1 10

输出样例：

2
3
5 or more

 

解题思路

　　每次要搜下一层的时候，先枚举连续的一段数，然后把这段连续的数插到剩余的数的各个空隙中。

　　比如，如果当前连续的一段数的长度为$i$，假设序列的长度为$n$，那么长度$i$的连续序列有$n-i+1$种。同时剩余的数的空隙有$n - 1$个（这段连续序列原本所在的空隙不算）。因此对于一段长度为$i$的连续序列一共有$(n-i+1) \times (n - i)$种选择。而$i$的取值范围为$1 \leq i < n$，因此在搜索当前层时一共有$\sum\limits_{i=1}^{n-1} {(n-i+1) \times (n - 1)}$种选择。其中这些选择中是有重复的，比如下图：

　　为了避免枚举到重复的情况，可以每次都只把数插到当前位置的后面的空隙，而不再插到前面的空隙。因此实际上一共有$$\frac{\sum\limits_{i=1}^{n-1} {(n-i+1) \times (n - 1)}}{2} = \frac{n \times (n+1) \times (n+2)}{6}$$

　　代入$n=15$，最多有$560$种选择。又因为最多枚举$4$层，因此一共有${560}^4$种选择。

　　这里可以用IDA*，A*，双向bfs来优化。

　　对于估价函数，首先要满足当前状态的估价值不大于实际步数。然后对于任意一个序列，每次移动一段连续的数都会改变三个位置的后继：

　　因此扫描一遍当前序列，统计前后两个数不满足后继关系（即$1$得后面是$2$，以此类推）的对数，假设有$tot$对，因为每次移动一段数可以改变三个后继，因此最好的情况是交换$\left\lceil {\frac{tot}{3}} \right\rceil = \left\lfloor {\frac{tot+2}{3}} \right\rfloor$次，就可以使得整个序列递增。因此估价函数可以是$f(s) = \left\lceil {\frac{tot}{3}} \right\rceil$。

　　IDA*，AC代码如下：

#include <bits/stdc++.h>
using namespace std;

const int N = 20;

int n;
int a[N];

int f() {
    int cnt = 0;
    for (int i = 0; i < n - 1; i++) {
        if (a[i] + 1 != a[i + 1]) cnt++;
    }
    
    return (cnt + 2) / 3;
}

bool dfs(int u, int dep) {
    if (f() + u > dep) return false;    // 剪支，如果估价函数得到的交换次数加上当前层数超过dep，那么不用往下搜
    if (f() == 0) return true;          // 当前序列递增，表面找到解
    
    int backup[N];
    memcpy(backup, a, sizeof(a));
    for (int len = 1; len < n; len++) { // 枚举连续一段数的长度
        for (int i = 0; i + len - 1 < n; i++) { // 枚举左端点
            int j = i + len - 1;    // 右端点
            for (int k = j + 1; k < n; k++) {   // 枚举插到哪个数的后面
                // 交换s[i ~ j]和s[j+1 ~ k]这两段数
                // 对区间s[i ~ k]进行处理
                int l = i;
                
                // 先用s[j+1 ~ k]覆盖s[i ~ i+k-(j+1)]
                for (int u = j + 1; u <= k; u++) {
                    a[l++] = backup[u];
                }
                
                // 此时l = i+k-(j+1)+1
                // 再用s[i ~ j]覆盖s[l ~ k]
                for (int u = i; u <= j; u++) {
                    a[l++] = backup[u];
                }
                
                if (dfs(u + 1, dep)) return true;
                memcpy(a, backup, sizeof(backup));
            }
        }
    }
    
    return false;
}

int main() {
    int tot;
    scanf("%d", &tot);
    while (tot--) {
        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
            scanf("%d", a + i);
        }
        
        // 迭代加深
        int dep = 0;
        while (dep < 5 && !dfs(0, dep)) {
            dep++;
        }
        
        if (dep >= 5) printf("5 or more\n");
        else printf("%d\n", dep);
    }
    
    return 0;
}

　　A*，AC代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, string> PIS;

const int N = 20;

int n;
string beg, ed;

int f(string &s) {
    int cnt = 0;
    for (int i = 0; i < n - 1; i++) {
        if (s[i] + 1 != s[i + 1]) cnt++;
    }
    
    return (cnt + 2) / 3;
}

int astar() {
    if (beg == ed) return 0;
    
    priority_queue<PIS, vector<PIS>, greater<PIS>> pq;
    pq.push({f(beg), beg});
    unordered_map<string, int> dist;
    dist[beg] = 0;
    
    while (!pq.empty()) {
        string t = pq.top().second;
        int d = pq.top().first;
        pq.pop();
        
        if (d > 4) continue;    // 估价变换到升序序列需要的最小步数超过4，则continue
        if (t == ed) return dist[ed];
        
        for (int len = 1; len < n; len++) {
            for (int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;
                for (int k = j + 1; k < n; k++) {
                    string s = t.substr(0, i) + t.substr(j + 1, k - j) + t.substr(i, len) + t.substr(k + 1);
                    if (!dist.count(s) || dist[s] > dist[t] + 1) {
                        dist[s] = dist[t] + 1;
                        pq.push({dist[s] + f(s), s});
                    }
                }
            }
        }
    }
    
    return 5;
}

int main() {
    int tot;
    scanf("%d", &tot);
    while (tot--) {
        scanf("%d", &n);
        
        beg.clear(), ed.clear();
        for (int i = 0; i < n; i++) {
            int v;
            scanf("%d", &v);
            beg += (char)(v + '0');
            ed += (char)(i + '1');
        }
        
        int ret = astar();
        
        if (ret >= 5) printf("5 or more\n");
        else printf("%d\n", ret);
    }
    
    return 0;
}

　　双向bfs，AC代码如下：

#include <bits/stdc++.h>
using namespace std;

const int N = 20;

int n;
string beg, ed;

int f(string &s) {
    int cnt = 0;
    for (int i = 0; i < n - 1; i++) {
        if (s[i] + 1 != s[i + 1]) cnt++;
    }
    
    return (cnt + 2) / 3;
}

int extend(queue<string> &q, unordered_map<string, int> &d1, unordered_map<string, int> &d2) {
    int d = d1[q.front()];  // 记得把当前层数的所有节点枚举完
    while (!q.empty() && d1[q.front()] == d) {
        string t = q.front();
        q.pop();
        
        if (d1[t] + f(t) > 4) continue; // 这个优化很重要，不然会tle
        
        for (int len = 1; len < n; len++) {
            for (int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;
                for (int k = j + 1; k < n; k++) {
                    string s = t.substr(0, i) + t.substr(j + 1, k - j) + t.substr(i, len) + t.substr(k + 1);
                    if (d2.count(s)) return d1[t] + 1 + d2[s];
                    if (d1.count(s)) continue;
                    d1[s] = d1[t] + 1;
                    q.push(s);
                }
            }
        }
    }
    
    return 5;
}

int bfs() {
    if (beg == ed) return 0;
    
    queue<string> q1, q2;
    q1.push(beg), q2.push(ed);
    unordered_map<string, int> d1, d2;
    d1[beg] = d2[ed] = 0;
    
    int cnt = 0;
    while (!q1.empty() && !q2.empty()) {
        int t;
        if (q1.size() <= q2.size()) t = extend(q1, d1, d2);
        else t = extend(q2, d2, d1);
        if (t < 5) return t;
        if (++cnt == 4) return 5;   // 搜索层数要不超过4
    }
    
    return 5;
}

int main() {
    int tot;
    scanf("%d", &tot);
    while (tot--) {
        scanf("%d", &n);
        
        beg.clear(), ed.clear();
        for (int i = 0; i < n; i++) {
            int v;
            scanf("%d", &v);
            beg += (char)(v + '0');
            ed += (char)(i + '1');
        }
        
        int ret = bfs();
        
        if (ret >= 5) printf("5 or more\n");
        else printf("%d\n", ret);
    }
    
    return 0;
}

 

参考资料

　　AcWing 180. 排书（算法提高班）：https://www.acwing.com/video/485/