北京网络赛G BOXES 状态压缩+有序BFS+高维数组判重

题目描述

Description

There is a strange storehouse in PKU. In this storehouse there are n slots for boxes, forming a line. In each slot you can pile up any amount of boxes. The limitation is that you can only pile a smaller one above a bigger one, in order to keep balance. The slots are numbered from 1 to n. The leftmost one is slot 1.

At first there is exactly one box in each slot. The volume of the box in slot i is v_i. As a virgo, you decide to sort these boxes by moving some of them. In each move you can choose a slot and move the top box in this slot to an adjacent slot (of course you can only put it on the top). You should ensure that the limitation mentioned above is still satisfied after this move. After the sort operation, there should be exactly one box in each slot, and for each pair of adjacent slots, the box in the left one should be smaller than the box in the right one.

Your task is to calculate the minimum number of moves you need to sort the boxes.

Input

In the first line there’s an integer T(T≤6000), indicating the number of test cases. The following 2T lines describe the test cases.

In each test case, the first line contains an integer n, indicating the number of slots. The second line contains n integers v₁,v₂…v_n, indicating the volume of the boxes. It is guaranteed that all v_i in a test case are different.

Please note that n<8,0≤v_i≤10⁴

Output

For each test case, print a line containing one integer indicating the answer. If it’s impossible to sort the boxes, print -1.

Sample Input

4
3
2 1 3
2
7 8
2
10000 1000
3
97 96 95

Sample Output

4
0
-1
20

#include <bits/stdc++.h>
using namespace std;
int vis1[];
int vis2[][];
int vis3[][][];
int vis4[][][][];
int vis5[][][][][];
int vis6[][][][][][];
int vis7[][][][][][][];
struct node{
    int a[];
    int step;
};
map<int,int> Hash;
int a[],b[],c[];
bool check(int a[],int num,int step){
    if(num==){
        if(vis1[a[]]>=) return true;
        else{vis1[a[]]=step;return false;}
    }
    if(num==){
        if(vis2[a[]][a[]]>=) return true;
        else {vis2[a[]][a[]]=step;return false;}
    }
    if(num==){
        if(vis3[a[]][a[]][a[]]>=) return true;
        else {vis3[a[]][a[]][a[]]=step;return false;}
    }
    if(num==){
        if(vis4[a[]][a[]][a[]][a[]]>=) return true;
        else {vis4[a[]][a[]][a[]][a[]]=step;return false;}
    }
    if(num==){
        if(vis5[a[]][a[]][a[]][a[]][a[]]>=) return true;
        else {vis5[a[]][a[]][a[]][a[]][a[]]=step;return false;}
    }
    if(num==){
        if(vis6[a[]][a[]][a[]][a[]][a[]][a[]]>=) return true;
        else {vis6[a[]][a[]][a[]][a[]][a[]][a[]]=step;return false;}
    }
    if(num==){
        if(vis7[a[]][a[]][a[]][a[]][a[]][a[]][a[]]>=) return true;
        else {vis7[a[]][a[]][a[]][a[]][a[]][a[]][a[]]=step;return false;}
    }
    return false;
}
void init(){
    memset(vis1,-,sizeof(vis1));
    memset(vis2,-,sizeof(vis2));
    memset(vis3,-,sizeof(vis3));
    memset(vis4,-,sizeof(vis4));
    memset(vis5,-,sizeof(vis5));
    memset(vis6,-,sizeof(vis6));
    memset(vis7,-,sizeof(vis7));
}
void bfs(int a[],int num){
    node k;k.step=;
    for(int i=;i<num;i++){k.a[i]=i;}
    check(a,num,);
    queue<node> que;que.push(k);
    int b[];
    while(!que.empty()){
        node top=que.front();que.pop();
        for(int i=;i<num;++i)
            b[i]=top.a[i];
        for(int i=;i<num;++i){
            int l=b[i]-;
            int r=b[i]+;
            if(l<) l=-;
            if(r>=num) r=-;
            for(int j=;j<i;++j) if(b[j]==b[i]){l=r=-;}
            for(int j=;j<i;++j) if(b[j]==b[i]-) {l=-;}
            for(int j=;j<i;++j) if(b[j]==b[i]+) {r=-;}
            if(l!=-){
                int temp=b[i];
                b[i]=l;
                node s;
                for(int j=;j<num;++j) {s.a[j]=b[j];}
                s.step=top.step+;
                if(!check(b,num,s.step)){
                    que.push(s);
                }
                b[i]=temp;
            }
            if(r!=-){
                int temp=b[i];
                b[i]=r;
                node s;
                for(int j=;j<num;++j) {s.a[j]=b[j];}
                s.step=top.step+;
                if(!check(b,num,s.step)){
                    que.push(s);
                }
                b[i]=temp;
            }
        }
    }
}

int main(){
    int T,n;
    for(int i=;i<;i++){
        a[i]=i;
    }
    init();
    for(int i=;i<=;i++){
        bfs(a,i);
    }
    for(scanf("%d",&T);T;--T){
        scanf("%d",&n);Hash.clear();
        vector<int> Q;
        for(int i=;i<n;i++){
            scanf("%d",b+i);
            Q.push_back(b[i]);
        }
        sort(Q.begin(),Q.end());
        for(int i=;i<(int)Q.size();i++){
            Hash[Q[i]]=i;
        }
        for(int i=;i<n;i++){
            c[Hash[b[i]]]=i;
        }
        if(n==){
            if(c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis1[c[]]);
        }
        if(n==){
            if(c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis2[c[]][c[]]);
        }
        if(n==){
            if(c[]==&&c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis3[c[]][c[]][c[]]);
        }
        if(n==){
            if(c[]==&&c[]==&&c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis4[c[]][c[]][c[]][c[]]);
        }
        if(n==){
            if(c[]==&&c[]==&&c[]==&&c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis5[c[]][c[]][c[]][c[]][c[]]);
        }
        if(n==){
            if(c[]==&&c[]==&&c[]==&&c[]==&&c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis6[c[]][c[]][c[]][c[]][c[]][c[]]);
        }
        if(n==){
            if(c[]==&&c[]==&&c[]==&&c[]==&&c[]==&&c[]==&&c[]==){
                printf("0\n");
            }
            else printf("%d\n",vis7[c[]][c[]][c[]][c[]][c[]][c[]][c[]]);
        }
    }
    return ;
}

首先对之前搜到这个题解的人说声对不起，因为之前写的有问题也没修补

好了我来解释一下代码的关键部分。。。

好的，这其实是个sb题，没睡醒的同学可以看一下下面的解释。。。

首先是状态定义

a[i]:第i大的元素在值为a[i]的位置上

然后，我们可以离线地做这道题

初始状态有序让a[i]=i

然后让他去搜索所有有效的状态，因为你正着搜结果和结果往乱了推其实值是一样的，这是一个可逆的过程

然后我们使用bfs爆搜所有从有序状态出发的状态并且记录答案

bfs中的关键判断是

1，这个第i大的元素，上面有没有东西

检查方法，遍历0~i-1大的元素，看一下这些元素里有没有和它在同一个位置

2,相邻的右边的柱子能不能放东西

检查方法，遍历0~i-1大的元素，看一下这些元素有没有放到a[i]+1这个槽里，只要有那么至少是不能放的，因为只可能更小

3,相邻的左边的柱子能不能放东西

检查方法，遍历0~i-1大的元素，看一下这些元素有没有放到a[i]-1这个槽里，只要有那么至少是不能放的，因为只可能更小

然后就是复制状态，检查访问过没有，判断一下加入队列

然后就是一些细节的东西

数组下标什么的千万别搞混。。。离散化之后记得维护c[i]的意义，千万别直接扔个rank数组进去...