搜索:IDA* (迭代加深 + 估计函数) 1:排书

题目链接：https://www.acwing.com/problem/content/description/182/

题目：

给定 n 本书，编号为 1∼n。

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

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

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

求最少需要多少次操作。

输入格式

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

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

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

同行数之间用空格隔开。

输出格式

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

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

每个结果占一行。

数据范围

1≤n≤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

分析：

 此题需要注意到每次交换，都会改变三个点对应的后缀上的值。

举例：

1 _ 2 _ 3 _ 4_5_6

现在将2 _3 换到4_的后面

则1_4_2_3_5_6

原先的1后面为2，3后面为4，4后面为5.

现在1后面为4，3后面为5，4后面为2.

所以需要了解到，每次交换都会修改3个数的后缀。

而我们需要得到的答案是1_2_3_4_..._n。

这个的后缀是固定的。后面的数比前面相邻的一个数大1.

从而求估计函数的时候，我们可以计算一下不符合条件的后缀有多少个tt。

而每次交换都只会改变3个后缀，所以最优的情况下也需要交换 tt / 3 向上取整。也就是( tt + 2) / 3 向下取整。

这样估计函数就求出来了。

然后在使用迭代加深的方式，按照深度限制进行遍历。 

如果当前的深度 + 估计函数的值 > 限制深度，直接return.因为至少还需要限制深度 + 1甚至更多，所以不用在往后枚举了。

代码实现：

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

const int N = 20;

int n;

int a[N];
int backup[5][N];  // 每一层还原都用到当前这一层的备份

int len;

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

bool dfs(int u , int depth) // 总共可以改depth步，现在已经改了u步，f()为最少还需要改f()步
{
    if(u + f() > depth)
    {
        return false;
    }
    if(f() == 0)
    {
        return true;
    }
    for(int len = 1 ; len <= n ; len++)
    {
        for(int i = 1 ; i + len - 1 <= n ; i++)
        {
            int j = i + len - 1;
            for(int k = j + 1 ; k <= n ; k++)
            {
                memcpy(backup[u],a,sizeof a);

                //对a进行修改，将i ~ j 部分 换到j + 1 ~ k 的后面

                int y = i;
                for(int t = j + 1 ; t <= k ; t++ , y++)
                {
                    a[y] = backup[u][t];
                }

                for(int t = i ; t <= j ; t++,y++)
                {
                    a[y] = backup[u][t];
                }
                for(int t = k + 1 ; t <= n ; t++,y++)
                {
                    a[y] = backup[u][t];
                }
                
                if( dfs(u + 1 , depth) )
                {
                    return true;
                }
                memcpy(a,backup[u],sizeof a);
            }
        }
    }
    return false;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        a[0] = 0 ;
        for(int i = 1 ; i <= n ; i++)
        {
            scanf("%d",&a[i]);
        }

        len = 0;  // 一步都不用变的情况
        while(true)
        {
            if(len >= 5 || dfs(0,len))
            {
               break;
            }
            len++;
        }
        if(len >= 5)
        {
            printf("5 or more\n");
        }
        else
        {
            printf("%d\n",len);
        }
    }
    return 0;
}