hdu5338 ZZX and Permutations(贪心、线段树)

转载请注明出处： http://www.cnblogs.com/fraud/           ——by fraud

ZZX and Permutations

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 181    Accepted Submission(s): 38

Problem Description

ZZX likes permutations.

ZZX knows that a permutation can be decomposed into disjoint cycles(see https://en.wikipedia.org/wiki/Permutation#Cycle_notation). For example:
145632=(1)(35)(462)=(462)(1)(35)=(35)(1)(462)=(246)(1)(53)=(624)(1)(53)……
Note that there are many ways to rewrite it, but they are all equivalent.
A cycle with only one element is also written in the decomposition, like (1) in the example above.

Now, we remove all the parentheses in the decomposition. So the decomposition of 145632 can be 135462,462135,351462,246153,624153……

Now you are given the decomposition of a permutation after removing all the parentheses (itself is also a permutation). You should recover the original permutation. There are many ways to recover, so you should find the one with largest lexicographic order.

 

Input

First line contains an integer t, the number of test cases.
Then t testcases follow. In each testcase:
First line contains an integer n, the size of the permutation.
Second line contains n space-separated integers, the decomposition after removing parentheses.

n≤105. There are 10 testcases satisfying n≤105, 200 testcases satisfying n≤1000.

 

Output

Output n space-separated numbers in a line for each testcase.
Don't output space after the last number of a line.

 

Sample Input

2 6 1 4 5 6 3 2 2 1 2

 

Sample Output

4 6 2 5 1 3 2 1

和题解的解法几乎一致，然而却在比赛结束后才意识到自己跪在了一个傻逼的地方，真是2333333

贪心，先放第一个位置，放尽可能大的值，然后依次往后，对于每个值，看其后面的一个位置，或者前面没有使用过的连续区间

//#####################
//Author:fraud
//Blog: http://www.cnblogs.com/fraud/
//#####################
//#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <sstream>
#include <ios>
#include <iomanip>
#include <functional>
#include <algorithm>
#include <vector>
#include <string>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <climits>
#include <cctype>
using namespace std;
#define XINF INT_MAX
#define INF 0x3FFFFFFF
#define MP(X,Y) make_pair(X,Y)
#define PB(X) push_back(X)
#define REP(X,N) for(int X=0;X<N;X++)
#define REP2(X,L,R) for(int X=L;X<=R;X++)
#define DEP(X,R,L) for(int X=R;X>=L;X--)
#define CLR(A,X) memset(A,X,sizeof(A))
#define IT iterator
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<PII> VII;
typedef vector<int> VI;
int Scan() {
    int res=0, ch;
    while(ch=getchar(), ch<'0'||ch>'9');
    res=ch-'0';
    while((ch=getchar())>='0'&&ch<='9')
        res=res*10+ch-'0';
    return res;
}
void Out(int a) {
    if(a>9)
        Out(a/10);
    putchar(a%10+'0');
}
int a[100010];
int vis[100010];
int pos[100010];
int fa[100010];
int dp[600010];
int ans[100010];
set<int> ms;
int n;
set<int>::IT it;
int find(int x){
    if(fa[x]!=x)fa[x] = find(fa[x]);
    return fa[x];
}
void push_up(int cur){
    dp[cur] = max(dp[cur<<1],dp[cur<<1|1]);
}
void build(int l,int r,int cur){
    if(l==r){
        dp[cur] = a[l];
        return;
    }
    int mid = (l+r)>>1;
    build(l,mid,cur<<1);
    build(mid+1,r,cur<<1|1);
    push_up(cur);
}
void update(int l,int r,int cur,int x,int inc){
    if(l==r&&l==x){
        dp[cur] = inc;
        return;
    }
    int mid = (l+r)>>1;
    if(x<=mid)update(l,mid,cur<<1,x,inc);
    else update(mid+1,r,cur<<1|1,x,inc);
    push_up(cur);
}
void update(int x,int num){
    update(1,n,1,x,num);
}
int query(int l,int r,int lx,int rx,int cur){
    if(l>=lx&&r<=rx)return dp[cur];
    if(lx>r||rx<l)return 0;
    int mid = (l+r)>>1;
    return max(query(l,mid,lx,rx,cur<<1),query(mid+1,r,lx,rx,cur<<1|1));
}
int query(int l,int r){
    return query(1,n,l,r,1);
}    
int main(){
    int t;
    t = Scan();
    while(t--){
        n = Scan();
        for(int i = 1;i<=n;i++){
            a[i] = Scan();
            vis[i] = 0;
            pos[a[i]] = i;
            fa[i] = i;
        }
        for(int i=0;i<=3*n;i++)dp[i] = 0;
        build(1,n,1);
        ms.clear();
        ms.insert(0);
        ms.insert(-INF);
        for(int i=1;i<=n;i++){
            if(vis[i])continue;
            int l;
            int posi = pos[i];
            int maxx = find(i);
            int p =pos[maxx];
            if(posi+1<=n&&!vis[a[posi+1]]){
                if(a[posi+1]>maxx){
                    p = posi+1;
                    maxx = a[p];
                }
            }
            if(posi>1){
                it = ms.upper_bound(-posi);
                l = *it;
                l = -l;
                l++;
                int tmp = query(l,posi);
                //tmp = find(tmp);
                //cout<<l<<" "<<tmp<<endl;
                if(tmp>maxx){
                    maxx = tmp;
                    p = pos[tmp];
                }
            }
            if(p==posi){
                ans[i] = i;
                vis[i] = 1;
                ms.insert(-posi);
            }else if(p==posi+1){
                fa[maxx] = fa[i];
                //ans[posi] = maxx;
                update(p,0);
            }else{
                ans[i] = a[p];
                vis[a[p]] = 1;
                for(int j=p+1;j<=posi;j++){
                    ans[a[j-1]] = a[j];
                    vis[a[j]] = 1;
                }
                ms.insert(-posi);
            }
        /*    cout<<i<<" "<<p<<" "<<maxx<<endl;
            for(int i=1;i<=n;i++){
                cout<<ans[i]<<" ";
            }
            cout<<endl;*/
        }
        for(int i=1;i<=n;i++){
            if(i!=1)putchar(' ');
            Out(ans[i]);
        }
        puts("");
    }
    return 0;
}