【AtCoder Regular Contest 080E】Young Maids [堆][线段树]

Young Maids

Time Limit: 50 Sec  Memory Limit: 512 MB

Description

　　给定一个排列，每次选出相邻的两个放在队头，要求字典序最小。

Input

　　第一行一个整数n，第二行n个数表示这个排列。

Output

　　n个数表示答案。

Sample Input

　　8
　　4 6 3 2 8 5 7 1

Sample Output

　　3 1 2 7 4 6 8 5

HINT

　　n%2=0，2 <= n <= 2e5

Solution

　　倒着考虑。
　　我们维护一个小根堆，堆里面存[l, r, val]，表示在区间[l, r]中选择两个元素，第一个元素A的权值为val（保证合法），以val为第一关键字。

　　那么显然，我们每次选出堆顶进行操作。

　　显然，若我们取走了A,B（pos[A] < pos[B]），[l,r]就被拆成了 [l,A-1], [A+1,B-1], [B+1,r]，我们要保证每一个区间长度都是偶数。
　　那么只要有，pos[A]%2 == pos[l]%2，pos[B]%2 == pos[r]%2。
　　又由于我们每次减少两个数，所以这样显然可以保证 pos[B]-pos[A]+1 % 2 == 0。

　　现在问题就是怎么求出A、B具体是那两个数，显然写个线段树维护一下 某段区间内奇数/偶数位置的min_val和所在的pos即可。

Code

 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<queue>
 using namespace std;
 typedef long long s64;

 const int ONE = ;
 const int INF = ;

 int get()
 {
         int res = , Q = ; char c;
         while( (c = getchar()) <  || c > )
             if(c == '-') Q = -;
         if(Q) res = c - ;
         while( (c = getchar()) >=  && c <= )
             res = res *  + c - ;
         return res * Q;
 }

 int n;
 int a[ONE];

 struct point
 {
         int id, val;
         friend bool operator <(point a, point b)
         {
             if(a.val != b.val) return a.val < b.val;
             return a.id < b.id;
         }
 };
 point res;

 namespace Seg
 {
         struct power {point odd, eve;} Node[ONE * ];

         void Build(int i, int l, int r)
         {
             Node[i].odd.val = Node[i].eve.val = INF;
             if(l == r)
             {
                 if(l & ) Node[i].odd = (point){l, a[l]};
                 else Node[i].eve = (point){l, a[l]};
                 return;
             }
             int mid = l + r >> ;
             Build(i << , l, mid), Build(i <<  | , mid + , r);
             Node[i].odd = min(Node[i << ].odd, Node[i <<  | ].odd);
             Node[i].eve = min(Node[i << ].eve, Node[i <<  | ].eve);
         }

         void Query(int i, int l, int r, int L, int R, int opt)
         {
             if(L <= l && r <= R)
             {
                 if(opt == ) res = min(res, Node[i].odd);
                 else res = min (res, Node[i].eve);
                 return;
             }
             int mid = l + r >> ;
             if(L <= mid) Query(i << , l, mid, L, R, opt);
             if(mid +  <= R) Query(i <<  | , mid + , r, L, R, opt);
         }
 }

 struct power
 {
         int l, r, val;
         bool operator <(power a) const
         {
             if(a.val != val) return a.val < val;
             return a.l < l;
         }
 };
 priority_queue <power> q;

 point Get(int l, int r, int opt)
 {
         res = (point){n + , INF};
         Seg::Query(, , n, l, r, opt);
         return res;
 }

 void Add(int l, int r)
 {
         if(l > r) return;
         q.push((power){l, r, Get(l, r, l % ).val});
 }

 int main()
 {
         n = get();
         for(int i = ; i <= n; i++)
             a[i] = get();

         Seg::Build(, , n);
         Add(, n);

         for(int i = ; i <= n / ; i++)
         {
             power u = q.top(); q.pop();
             point A = Get(u.l, u.r - , u.l % );
             point B = Get(A.id + , u.r, u.r % );
             printf("%d %d ", A.val, B.val);

             Add(u.l, A.id - ), Add(A.id + , B.id - ), Add(B.id + , u.r);
         }
 }