【AtCoder】【思維】【拓撲序】Wide Swap(AGC001)

題意：

你有一個排列，長度爲N。然後將i和j兩個位置的數字交換的條件是：|i-j|>=K並且|Ai-Aj|=1.
然後你可以進行無數次交換，輸出操作後能夠得到的最小的字典序的排列。

數據範圍：

N<=500000.

思路：

這道題在考場上是真的沒做出來…
那就直接說正解了。假設原排列是P，那麼我們在定義一個數組是Q，滿足Q[P[i]]=i（感覺像是反函數）。然後目的P的字典序最小，就是Q的字典序最小。
這個其實很好想。也就是讓Q中的‘1’儘量靠前，因爲這樣子值越小的數字就越靠前了。
那麼問題就這樣子轉換過來了，現在我們可以完全忘記P數組了，只管Q數組。
那麼原問題的交換條件就變成了：$Q_i$,$Q_i+1$可以進行交換，當且僅當$|Q_i-Q_{i+1}|&gt;=K$。那麼利用一下冒泡排序的思想，就有：當$|Q_i-Q_j|&lt;K$的時候，$Q_i$和$Q_j$永遠都不會改變相對位置，那麼就是說Qj永遠都會在Qi的後面。到了這裏就可以看出拓撲序的影子了。滿足$|Q_i-Q_j|&lt;=K-1$的時候，就讓$Q_i$連一條邊到$Q_j$，最後跑一邊拓撲排序就可以了。
但是這樣是有問題的。因爲這樣子建邊是O(n^2)的，炸的慘裂。因爲當x->y,y->z時，x->z這條邊就是沒有用的。那麼對於每一個點，我們只需要找到$Q_i-Q_j&lt;=K-1$的最近的那個點和$Q_j-Q_i&lt;=K-1$的最近的那個點，然後連兩條邊，就能夠保證$Q_i$的相對位置了。這樣子時間和空間複雜度就大大降低了。
還有一點就是拓撲排序需要使用優先隊列來保證字典序最小，這還是比較好想的。
然後最後轉換回來的時候，就是$A_{ans_i}=i$（ans是Q的字典序最小的數組）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define MAXN 500000
using namespace std;
priority_queue<int,vector<int>,greater<int> > que;
int N,K;
int p[MAXN+5],q[MAXN+5];
int tree[MAXN*4],d[MAXN+5];
vector<int> G[MAXN+5],ans;
void Build(int i,int l,int r)
{
	tree[i]=0;
	if(l==r)
		return;
	int mid=(l+r)/2;
	Build(i*2,l,mid);
	Build(i*2+1,mid+1,r);
}
void PushUp(int i)
{
	tree[i]=max(tree[i*2],tree[i*2+1]);
}
void Insert(int i,int l,int r,int p,int val)
{
	if(l==r)
	{
		tree[i]=val;
		return;
	}
	int mid=(l+r)/2;
	if(p<=mid)
		Insert(i*2,l,mid,p,val);
	else
		Insert(i*2+1,mid+1,r,p,val);
	PushUp(i);
}
int Query(int i,int l,int r,int ql,int qr)
{
	if(qr<l||ql>r)
		return 0;
	if(ql<=l&&r<=qr)
		return tree[i];
	int mid=(l+r)/2;
	return max(Query(i*2,l,mid,ql,qr),Query(i*2+1,mid+1,r,ql,qr));
}
void BFS()
{
	for(int i=1;i<=N;i++)
		if(d[i]==0)
			que.push(i);
	while(que.empty()==false)
	{
		int u=que.top();
		que.pop();
		ans.push_back(u);
		for(int i=0;i<(int)G[u].size();i++)
		{
			int v=G[u][i];
			d[v]--;
			if(d[v]==0)
				que.push(v);
		}
	}
}
int main()
{
//	freopen("swap.in","r",stdin);
//	freopen("swap.out","w",stdout);
	scanf("%d %d",&N,&K);
	for(int i=1;i<=N;i++)
	{
		scanf("%d",&p[i]);
		q[p[i]]=i;
	}
	Build(1,1,N);
	for(int i=1;i<=N;i++)
	{
		int pos=Query(1,1,N,max(q[i]-K+1,1),q[i]);
		if(pos!=0)
		{
			G[q[pos]].push_back(q[i]);
			d[q[i]]++;
		}
		pos=Query(1,1,N,q[i],min(N,q[i]+K-1));
		if(pos!=0)
		{
			G[q[pos]].push_back(q[i]);
			d[q[i]]++;
		}
		Insert(1,1,N,q[i],i);
	}
	for(int i=1;i<=N;i++)
		sort(G[i].begin(),G[i].end());
	BFS();
	for(int i=0;i<(int)ans.size();i++)
		p[ans[i]]=i+1;
	for(int i=1;i<=N;i++)
		printf("%d\n",p[i]);
	return 0;
}