Reorder the Books HDU 5500

Reorder the Books

 

 Accepts: 127

 

 Submissions: 237

 Time Limit: 4000/2000 MS (Java/Others)

 

 Memory Limit: 131072/131072 K (Java/Others)

问题描述

dxy家收藏了一套书，这套书叫《SDOI故事集》，《SDOI故事集》有n(nleq 19)n(n≤19)本，每本书有一个编号，从11号到nn号。
dxy把这些书按编号从小到大，从上往下摞成一摞。dxy对这套书极其重视，不允许任何人动这套书。
有一天Evensgn到dxy家玩，dxy因为和妹子有约会，就让Evensgn自己待在他家。Evensgn对这套书非常好奇，偷偷的看了一下，结果发现这里面竟然有当年小E和小Q的故事。Evensgn看得出神，结果把一摞书的顺序打乱了。
眼看着dxy就要回来了，Evensgn需要尽快把这摞书恢复到原先排好序的状态。由于每本书都非常重，所以Evensgn能做的操作只有把一本书从书堆中抽出来，然后把这本书放到书堆的顶部。
给你打乱的书的顺序，你能帮Evensgn算算最少需要几次上述的操作，他才能把这套书恢复顺序？假如你能算出来的话，Evensgn答应送给你一本他签名的书《SDOI故事集9:小E的故事》

输入描述

输入包含多组数据。
第一行包含一个正整数T(Tleq 30)T(T≤30)表示数据组数。
对于每组数据，第一行为一个正整数nn表示这套《SDOI故事集》中有多少本书。
接下来一行nn个用空格分开的正整数，表示Evensgn打乱后的这摞书的书号顺序（从上往下）。

输出描述

对于每组数据，输出一行一个整数，表示Evensgn最少需要几次操作才能讲书恢复顺序。

输入样例

2
4
4 1 2 3
5
1 2 3 4 5

输出样例

3
0

Hint

对于第一组数据，我们先把33号书放到最上面，接着操作22号书，最后操作11号书，(4,1,2,3)
ightarrow (3,4,1,2)
ightarrow(2,3,4,1)
ightarrow(1,2,3,4)(4,1,2,3)→(3,4,1,2)→(2,3,4,1)→(1,2,3,4),这样就有序了
对于第二组数据，这摞书本来就有序了，所以不需要任何操作
n>15n>15的数据不超过1010组


官方解题报告：

把这题的模型简化一下，有一个1 ightarrow n1→n的排列形成的数列，我们要用最少的操作次数把这个数列排序，每次操作都是把一个数放到整个数列的最前面。 首先我们可以注意到每个数最多只会被操作一次。因为假如有一个数被往前拿了两次，显然第一次的操作是没有意义的。 然后能发现一定先操作大的数，再操作小的数。因为假如先把小的数放前面去了，再把大的数放前面去，小的数就又在大的数后面了，小的数必定还得再操作一次，然而操作两次是不划算的。

到这里，对于19的数据范围，我们有一个很暴力的做法，2^n2​n​​枚举要操作哪些数，这些操作按数的大小从大往小的顺序，模拟一下，然后检查一下最后的序列是否有序，复杂度O(n*2^n)O(n∗2​n​​)。

我们很快又能发现，假如操作了大小等于kk的数，那么所有小于kk的数也都得操作了。所以我们不用2^n枚举，直接mm从11开始从小到大枚举，表示要操作前mm小的数，然后模拟，验证，这样复杂度为O(n^2)O(n​2​​)。

不过其实mm也是不用枚举的。 首先可以发现最大的数nn是不用操作的（其他数操作好了，数"nn"自然就在最后面了）。 于是我们先找到最大的数"nn"的位置，从这个位置往前找，直到找到(n-1)(n−1)。假如找到头也没找到(n-1)(n−1)，那么数"(n-1)(n−1)"需要操作，而一旦操作了(n-1)(n−1)，根据前面结论，总共就需要(n-1)(n−1)次操作了;假如找到了(n-1)，那么数"(n-1)(n−1)"也不需要操作（和数"nn"不需要操作一个道理）。 同理，我们接着从(n-1)(n−1)的位置往前找(n-2)(n−2),再从(n-2)(n−2)的位置往前找(n-3)(n−3)...假如数kk找不到了，那么就至少需要kk次操作。这种做法的复杂度是O(n)O(n)的

先用暴力试一下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int a[21],c[21];
struct node
{
    int elem,id;
    bool operator < (const node & a) const
    {
        return elem>a.elem;
    }
}vis[21];
int n;

bool check(int c[])
{
    for(int i=1; i<n; i++) if(c[i]>=c[i+1]) return 0;
    return 1;
}

void chage(int c[],int k)
{
   int  temp=c[k];
    for(int kk=k; kk>2; kk--)
    {
        c[kk]=c[kk-1];
    }
    c[2]=c[1];
    c[1]=temp;
}

int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        cin>>n;
        int ans,sum;
        for(int i=1; i<=n; i++) cin>>a[i];
        ans=100000;
        int idd;
        for(int boo=0; boo<=(1<<n)-1; boo++)
        {
            sum=0;
            memset(vis,0,sizeof(vis));
            int book=boo;
            memcpy(c,a,sizeof(int)*(1+n));
            for(int k=1; k<=n; k++)
            {
                if(book&1)
                {
                    vis[sum].elem=a[k];
                    vis[sum].id=k;
                    sum++;
                }
                book=book>>1;
            }
            sort(vis,vis+sum);
            for(int i=0;i<sum;i++)
            {
         //   cout<<vis[i].elem<<" ";
            idd=min(n,vis[i].id+i);
            chage(c,idd);
            }
           // puts("");
         //   for(int i=1;i<=n;i++) cout<<c[i]<<" ";puts("");
            if(check(c)) ans=min(ans,sum);
        }
        cout<<ans<<endl;
    }
    return 0;
}

再是高效解法：

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int a[21];
int pos[100];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n;cin>>n;
        for(int i=1;i<=n;i++) {cin>>a[i];pos[a[i]]=i;}
        sort(a+1,a+n+1);
        int ans=0;
        while(n>=1)
        {
            if(pos[a[n]]<pos[a[n-1]]) {ans=n-1;break;}
            n--;
        }
        cout<<ans<<endl;
    }
    return 0;
}