【AtCoder Grand Contest 001F】Wide Swap [线段树][拓扑]

Wide Swap

Time Limit: 50 Sec  Memory Limit: 512 MB

Description

　　

Input

　　

Output

　　

Sample Input

　　8 3
　　4 5 7 8 3 1 2 6

Sample Output

　　1
　　2
　　6
　　7
　　5
　　3
　　4
　　8

HINT

　　

Solution

　　首先，直接做难度系数较高，假设原序列为a，我们考虑设一个p，p[a_i] = i，即将题目中的权值与下标调换。

　　那么显然，要令a字典序最小，只要让p字典序最小即可。因为“权值小的尽量前”与“前面的权值尽量小”是一个意思。

　　现在操作转化为：相邻元素且权值差>=k的可以换顺序。

　　考虑一个暴力怎么做，显然是 i 与后面的所有 j 比，如果 abs(p_i - p_j) < k，则 i 和 j 的相对顺序就确定了， 连一条 p_i -> p_j 的边。

　　连边之后跑一边拓扑即可。

　　显然复杂度在于连边，因为这样暴力会有很多无用边。比如A->B, B->C, A->C，这条A->C显然无用。

　　我们考虑如何删掉 A->C 这种边。

　　倒着加入，显然 p_i 连向 (p_i-k, p_i)∪(p_i, p_i+k)。我们只需要分别连向两个区间中下标最小的那一个即可。用线段树维护一下区间最小值。

Code

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

 #define next nxt
 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, k;
 int A[ONE], p[ONE];
 int next[ONE], first[ONE], go[ONE], Input[ONE], tot;
 priority_queue <int, vector <int>, greater <int> > q;

 int res = INF;
 namespace Seg
 {
         struct power {int val;} Node[ONE * ];
         void Build(int i, int l, int r)
         {
             Node[i].val = INF;
             if(l == r) return;
             int mid = l + r >> ;
             Build(i << , l, mid), Build(i <<  | , mid + , r);
         }

         void Update(int i, int l, int r, int L, int x)
         {
             if(L <= l && r <= L)
             {
                 Node[i].val = x;
                 return;
             }
             int mid = l + r >> ;
             if(L <= mid) Update(i << , l, mid, L, x);
             else Update(i <<  | , mid + , r, L, x);
             Node[i].val = min(Node[i << ].val, Node[i <<  | ].val);
         }

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

 void Add(int u, int v)
 {
         Input[v]++, next[++tot] = first[u], first[u] = tot, go[tot] = v;
 }

 void Deal()
 {
         int now = ;
         for(int i = ; i <= n; i++)
             if(!Input[i]) q.push(i);
         while(!q.empty())
         {
             int u = q.top(); q.pop();
             A[u] = ++now;
             for(int e = first[u]; e; e = next[e])
             {
                 int v = go[e];
                 if(--Input[v] == ) q.push(v);
             }
         }
         for(int i = ; i <= n; i++) printf("%d\n", A[i]);
 }

 int main()
 {
         n = get(), k = get();
         for(int i = ; i <= n; i++) p[get()] = i;

         Seg::Build(, , n);
         for(int i = n; i >= ; i--)
         {
             res = INF, Seg::Query(, , n, p[i] + , min(p[i] + k - , n));
             if(res != INF) Add(p[i], p[res]);

             res = INF, Seg::Query(, , n, max(, p[i] - k + ), p[i] - );
             if(res != INF) Add(p[i], p[res]);

             Seg::Update(, , n, p[i], i);
         }

         Deal();
 }