多校第四场 1012 hdu 5338 ZZX and Permutations(线段树+树状数组+贪心)

题目链接：

hdu 5338

---

题目大意：

1. 首先我们有一个序列：1，2，…….,n。
2. 我们要读入一个操作序列，这个序列是1~n的一个排列，我们可以通过加括号形成一个循环节，循环节不能嵌套和交叉
3. 循环节内部是后面的换到前面，最前面的换到最后面
4. 问如何将操作序列划分循环，能够将原序列通过转换获得字典序最大的序列
   

   ---

题目分析：

1. 首先我们既然要得到要字典序最大，那么我们可以贪心地从高到低地枚举每一个位，每一位尽量取大的，因为如果存在某一高位小于另一个序列，那么它一定在字典序上小于这个序列。
2. 那么如何找到最大的，首先就是当前位置后面的数能够换到前面，或者通过添加循环节，让当前数作为循环节的末位，导致前面的某一个数换到当前数的位置。
3. 因为循环节不能嵌套，所以我们要知道前面最远能够找的区间，和后面这个数是否可以取。
4. 具体操作我们利用如下数组如下维护：
   
   • 定义几个数组,pos[]表示每个数的在操作序列的位置
   • a[]某个数位上的数（与pos[]互为反函数）
   • vis[]表示某个位置上的数是否已经确定了循环节（维护前缀和的树状数组）
   • ans[]表示某个位上最终的数字
   • 一棵维护区间最大值的线段树
5. 每次找的时候，我们可以利用二分找到最远的没有循环节的区间左边界，因为vis的前缀和能让我们求得一个区间和，我们可以知道一个区间有没有被标记的点，如果没有，那么这个区间就是可以被循环节覆盖的，这个可以作为二分的判定条件
6. 然后利用线段树可以找到可选取区间当中最大的那个值，然后利用Pos数组就能中找到这个数的位置，然后判断和后面的数的大小关系，如果选取这个值，那么就可以确定循环节，对点进行标记
7. 如果是后面相邻的数比较大，是不需要标记的，因为它的循环节还没有确定，那么我们就要选取后面的数，在线段树中，将后面的数修改为负数，防止它被后面的数查的时候找到。
8. 然后这个题注意细节就好了。

AC代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define MAX 100007
#define INF (1<<29)

using namespace std;

int t,n;
int a[MAX];
int pos[MAX];
int vis[MAX];
int ans[MAX];

struct Tree
{
    int l,r;
    int maxn;
}tree[MAX<<2];

void push_up ( int u )
{
    tree[u].maxn = max ( tree[u<<1].maxn , tree[u<<1|1].maxn );
}

void build ( int u , int l , int r )
{
    tree[u].l = l;
    tree[u].r = r;
    if ( l == r )
    {
        tree[u].maxn = a[l];
        return;
    }
    int mid = l + r >>1;
    build ( u<<1 , l , mid );
    build ( u<<1|1 , mid+1 , r );
    push_up ( u );
}

void update ( int u , int x )
{
    int l = tree[u].l;
    int r = tree[u].r;
    int mid = l + r >>1;
    if ( l == r )
    {
        tree[u].maxn = -a[l];
        return;
    }
    if ( x > mid ) update ( u<<1|1 , x );
    else update ( u<<1 , x );
    push_up ( u );
}

int query ( int u , int left , int right )
{
    int l = tree[u].l;
    int r = tree[u].r;
    int mid = l + r >>1;
    if ( left <= l && r <= right )
        return tree[u].maxn;
    int ret = -INF;
    if ( left <= mid && right >= l )
        ret = max ( ret , query ( u<<1 , left , right ));
    if ( left <= r && right > mid )
        ret = max ( ret , query ( u<<1|1 , left , right ));
    return ret;
}

int lowbit ( int x )
{
    return x&-x;
}

void add ( int x )
{
    while ( x <= n )
    {
        vis[x] += 1;
        x += lowbit(x);
    }
}

int sum ( int x )
{
    int ret = 0;
    while ( x )
    {
        ret += vis[x];
        x -= lowbit ( x );
    }
    return ret;
}

void init ( )
{
    build ( 1 , 1 , n );
    memset ( vis , 0 , sizeof ( vis ));
}

int bsearch ( int x )
{
    int l = 0 , r = x , mid;
    while ( l != r )
    {
        mid = l+r>>1;
        if ( sum(x) - sum(mid) > 0 ) l = mid+1;
        else r = mid;
    }
    return l+1;
}

int main ( )
{
    scanf ( "%d" , &t );
    while ( t-- )
    {
        scanf ( "%d" , &n );
        for ( int i = 1 ; i <= n ; i++ )
        {
            scanf ( "%d" , &a[i] );
            pos[a[i]] = i;
        }
        init ( );
        for ( int i = 1 ; i <= n ; i++ )
        {
            int x = pos[i];
            if ( sum(x)-sum(x-1) > 0 )
            {
                ans[i] = a[x+1];
                continue;
            }
            int temp = -1;
            if ( x != n && sum(x+1)-sum(x) == 0 ) temp = a[x+1];
            int l = bsearch ( x );
            int v = query ( 1 , l , x );
            int y = pos[v];
            if ( v > temp )
            {
                ans[i] = v;
                for ( int j = y; j <= x ; j++ )
                    add ( j );
            }
            else
            {
                ans[i] = temp;
                update ( 1 , x+1 );
            }
        }
        for ( int i = 1 ; i < n ; i++ )
            printf ( "%d " , ans[i] );
        printf ( "%d\n" , ans[n] );
    }
}