算法学习笔记：康托展开&逆康托展开

1.概述

康托展开&逆康托展开，是全排列问题中常用的两种算法。

康托展开：已知一个 $n$ 阶全排列 $a$，求出这是第几个全排列（按照字典序排序）。

逆康托展开：已知一个 $n$ 阶全排列 $a$ 的排名，求出这个全排列。

可以发现这两个操作简直就是孪生兄弟。

2.实现

2.1 康托展开

例题

康托展开的公式：$a_1\times (n-1)!+a_2\times (n-2)!+...+a_{n-1}\times 1!+a_n\times 0!+1$。本博客中约定：$0!=0$。

上式中，$a_i$ 表示比 $a_i$ 小并且不在 $i$ 位置前面的数的个数。

那么我们以 5 2 3 1 4 为例，模拟康托展开的步骤。

1. 比 5 小的数有四个，其中有 0 个在前面，因此 $a_1=4$。这 4 个数能够产生 $4\times 4!$ 个全排列。
2. 比 2 小的数有一个，其中有 0 个在前面，因此 $a_2=1$。考虑到第 1 个数已经确定，那么剩下这个数能够产生 $1\times 3!$ 个全排列。
3. （此处省略若干字）
4. 最后的结果为 $4\times 4!+1\times 3!+1\times 2!+0\times 1!+0\times 0!+1=105$

为什么这么做？

比如第一位，我们可以发现：对于 1 2 3 4 这四个数而言，我们需要计算 5 不在第一位的全排列。根据排列组合的知识，结果为 $4\times 4\times 3\times 2\times 1=4\times 4!$。其余同理。

那么代码呢？其实还是比较好写的。

计算 $a_i$ 我们可以使用权值线段树、set 等来解决。

当然我用的是 FHQ Treap，结果被卡常了。

没学过 FHQ Treap 的同学可以看看 这篇博文，里面有很详细的讲解。当然也可以使用别的来实现。

代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;
const int MAXN = 1e6 + 10, P = 998244353;
int n, a[MAXN], cnt, root;
LL ans, f[MAXN];

struct node
{
    
    
	int l, r, size, val, key;
}tree[MAXN];

int read()
{
    
    
	int sum = 0, fh = 1; char ch = getchar();
	while (ch < '0' || ch > '9') {
    
    if (ch == '-') fh = -1; ch = getchar();}
	while (ch >= '0' && ch <= '9') {
    
    sum = (sum << 3) + (sum << 1) + (ch ^ 48); ch = getchar();}
	return sum * fh;
}

int Make_Node(int val)
{
    
    
	int now = ++cnt;
	tree[now].size = 1;
	tree[now].val = val;
	return now;
}

void update(int x) {
    
    tree[x].size = tree[tree[x].l].size + tree[tree[x].r].size + 1;}

void split(int now, int val, int &x, int &y)
{
    
    
	if (now == 0) x = y = 0;
	else
	{
    
    
		if (tree[now].val <= val)
		{
    
    
			x = now;
			split(tree[now].r, val, tree[now].r, y);
		}
		else
		{
    
    
			y = now;
			split(tree[now].l, val, x, tree[now].l);
		}
		update(now);
	}
}

int merge(int x, int y)
{
    
    
	if (!x || !y) return x + y;
	if (rand() & 1)
	{
    
    
		tree[x].r = merge(tree[x].r, y);
		update(x); return x;
	}
	else
	{
    
    
		tree[y].l = merge(x, tree[y].l);
		update(y); return y;
	}
}

void Insert(int val)
{
    
    
	int x, y; split(root, val - 1, x, y);
	root = merge(merge(x, Make_Node(val)), y);
}

int Find(int val)
{
    
    
	int x, y, ans;
	split(root, val - 1, x, y);
	ans = tree[x].size;
	root = merge(x, y);
	return ans;
}

int main()
{
    
    
	srand(time(0));
	n = read(); f[0] = 1; cnt = root = 0;
	for (int i = 1; i <= n; ++i) a[i] = read();
	for (int i = 1; i <= n; ++i) f[i] = f[i - 1] * i % P;
	f[0] = 0;
	for (int i = 1; i <= n; ++i)
	{
    
    
		Insert(a[i]); ans = (ans + ((LL)a[i] - 1 - Find(a[i])) * f[n - i]) % P;
//		printf("%d/%d/%d\n", f[n - i], Find(a[i]), ans);//调试用
	}
	printf("%lld\n", ans + 1);
	return 0;
}

2.2 逆康托展开

由于作者太弱，所以没有学习。