【模拟赛】【AGC010E】Rearranging（拓扑排序）

题面

🔗

有一个 $n$ 个数组成的序列 $a_i$

高桥君会把整个序列任意排列，然后青木君可以选择两个相邻的互质的数交换位置。

高桥君希望最终序列的字典序尽量小，而青木君希望字典序尽量大。求最终序列。

$n\le 2000$

题解

我们可以暴力获得每对数字是否互质。两个数在序列中的相对位置无法改变，当且仅当这两个数不互质。所以，我们把每一对不互质的关系连一条无向边，再把每一条边定向使得整张图是个DAG，那么答案就是最大拓扑序列。

我们的目的就是通过边定向让这个最大拓扑序列字典序最小。

不难想到一种贪心方法：把每个连通块的最小点拿出来，邻接边全部指向外，删掉这个点。然后把之前 与之相邻的点 强制定义为 其所在连通块的最小点。直到所有点删完，把所有边完成定向。

这便是这道题的难点了：难以模拟！

首先我们可以直接将 $a_i$ 从小到大排序，大大简化了问题。同时将每个点的边按照邻接点从小到大排序。然后，我们就可以直接从小到大遍历最小点，然后dfs一次将边定向。不难发现，这样遍历最小点的顺序刚好就是上述贪心中的顺序。

时间复杂度 $O(n^2\log a)$ 。

CODE

代码并不完美，有很多地方在浪费

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<queue>
#include<stack>
#include<random>
#include<bitset>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 2005
#define LL long long
#define ULL unsigned long long
#define ENDL putchar('\n')
#define DB double
#define lowbit(x) (-(x) & (x))
#define FI first
#define SE second
int xchar() {
	static const int maxn = 1000000;
	static char b[maxn];
	static int pos = 0,len = 0;
	if(pos == len) pos = 0,len = fread(b,1,maxn,stdin);
	if(pos == len) return -1;
	return b[pos ++];
}
#define getchar() xchar()
LL read() {
	LL f = 1,x = 0;int s = getchar();
	while(s < '0' || s > '9') {if(s<0)return -1;if(s=='-')f=-f;s = getchar();}
	while(s >= '0' && s <= '9') {x = (x<<1) + (x<<3) + (s^48);s = getchar();}
	return f*x;
}
void putpos(LL x) {if(!x)return ;putpos(x/10);putchar((x%10)^48);}
void putnum(LL x) {
	if(!x) {putchar('0');return ;}
	if(x<0) putchar('-'),x = -x;
	return putpos(x);
}
void AIput(LL x,int c) {putnum(x);putchar(c);}

int n,m,s,o,k;
inline int gcd(int a,int b) {return b==0 ? a:gcd(b,a%b);}
int g[MAXN][MAXN];
int hd[MAXN],nx[MAXN*MAXN],v[MAXN*MAXN],cne;
int ind[MAXN],a[MAXN],b[MAXN];
inline void ins(int x,int y) {
	nx[++ cne] = hd[x]; v[cne] = y; hd[x] = cne;
}
int bfn[MAXN],tim;
void dfs(int x) {
	if(bfn[x]) return ;
	bfn[x] = ++ tim;
	for(int i = hd[x];i;i = nx[i]) {
		dfs(v[i]);
	}return ;
}
int main() {
	freopen("permutation.in","r",stdin);
	freopen("permutation.out","w",stdout);
	n = read();
	for(int i = 1;i <= n;i ++) {
		a[i] = read();
	}
	sort(a + 1,a + 1 + n);
	for(int i = n;i > 0;i --) {
		for(int j = i-1;j > 0;j --) {
			if(gcd(a[i],a[j]) > 1) {
				ins(i,j); ins(j,i);
				g[i][j] = g[j][i] = 1;
			}
		}
	}
	for(int i = 1;i <= n;i ++) {
		if(!bfn[i]) {
			dfs(i);
		}
	}
	cne = 0;
	for(int i = 1;i <= n;i ++) hd[i] = 0;
	for(int i = 1;i <= n;i ++) {
		for(int j = i+1;j <= n;j ++) {
			if(g[i][j]) {
				if(bfn[i] < bfn[j]) ins(i,j),ind[j] ++;
				else ins(j,i),ind[i] ++;
			}
		}
	}
	priority_queue<pair<int,int> > q;
	for(int i = 1;i <= n;i ++) {
		if(ind[i] == 0) q.push({a[i],i});
	}
	while(!q.empty()) {
		AIput(q.top().FI,' ');
		int t = q.top().SE; q.pop();
		for(int i = hd[t];i;i = nx[i]) {
			ind[v[i]] --;
			if(ind[v[i]] == 0) q.push({a[v[i]],v[i]});
		}
	}
	ENDL;
	return 0;
}