Burnside引理和Polya定理学习笔记

前言

求·······的方案数
循环同构算一种
一脸懵逼
（于是我觉得系统的学一遍Burnside引理和Polya定理）

正文

置换

置换的概念

对于一个排列$a_i$
我们想成$i$输进去会出来一个$a_i$
那么我们如果输入一个排列，将能得到一个排列
就比如我们输入的排列是$1$到$n$有序的，那么这个置换就是
$$\left(\begin{array}{ccccc}1& 2& 3& \cdot \cdot \cdot & n\\ a_1& a_2& a_3& \cdot \cdot \cdot & a_n\end{array}\right)$$
当然我们如果随便输入一个排列$b_i$，并且得到一个新的排列，那么这个置换就是
$$\left(\begin{array}{ccccc}{b}_1& b_2& b_3& \cdot \cdot \cdot & b_n\\ a_{b_1}& a_{b_2}& a_{b_3}& \cdot \cdot \cdot & a_{b_n}\end{array}\right)$$
只要排列$a_i$相同，无论输入什么排列$b_i$生成的置换都是一样的
即置换与横向位置无关，只与纵向的对应关系有关
我们设$A=\{a_1,a_2\cdot \cdot \cdot a_n\}$，即$|A|=n$，我们称上面的那些置换为$A$上的$n$次置换
不难发现，本质不同的$n$次置换一共有$n!$种

置换的乘积形式

我们发现，对于一个置换，一个位置的数如果是$i$，进行若干次置换后，这个位置的数会变回$i$
比如一个置换
$$\left(\begin{array}{cccccc}1& 2& 3& 4& 5& 6\\ 2& 3& 1& 6& 5& 4\end{array}\right)$$
一个数$1$其变化是$1\to 2\to 3\to 1$
那么我们可以写成$(2,3,1)$
所有的循环的乘积就是这个置换的不相交循环的乘积写法
比如刚刚这个置换就是$(2,3,1)(6,4)(5)$
我们发现$5$这个位置无论进行几次置换值都是$5$，对于这些位置我们称其为不动点

置换群

是一种群，里面每个元素都是置换
然后满足群的一些性质
对于一个$n$，在$n!$种本质不同的$n$次置换中选$x$个($x\ge 1$)置换作为元素的群被称为$x$阶$n$次置换群，特殊的，当$x=n!$时，其被称为$n$次对称群
对于一个$n$次置换群，我们发现其元素中必有置换
$$\left(\begin{array}{ccccc}{a}_1& a_2& a_3& \cdot \cdot \cdot & a_n\\ a_1& a_2& a_3& \cdot \cdot \cdot & a_n\end{array}\right)$$
另外，若其元素中有置换
$$\left(\begin{array}{ccccc}{b}_1& b_2& b_3& \cdot \cdot \cdot & b_n\\ a_{b_1}& a_{b_2}& a_{b_3}& \cdot \cdot \cdot & a_{b_n}\end{array}\right)$$
则其元素中也必有
$$\left(\begin{array}{ccccc}{a}_{b_1}& a_{b_2}& a_{b_3}& \cdot \cdot \cdot & a_{b_n}\\ b_1& b_2& b_3& \cdot \cdot \cdot & b_n\end{array}\right)$$
以上就差不多是一些定义了
百度百科链接，群
良好并且完整的置换群课件，链接

Burnside引理

设$G=\{a_1,a_2,\dots a_g\}$（$a$是置换）是目标集$[1,n]$上的置换群。每个置换都写成不相交循环的乘积。$c_1(a_k)$是在置换$a_k$的作用下不动点的个数，也就是长度为$1$的循环的个数。通过上述置换的变换操作后可以相等的元素属于同一个等价类。若$G$将$[1,n]$划分成$l$个等价类，则：
$$l=\frac{1}{|G|}[c_1(a_1)+c_1(a_2)+\cdot \cdot \cdot +c_1(a_{|G|})]$$

---

证明：
对于一个置换$a$，将其写成不相交循环的乘积
我们设${\chi }_a(x)=\{\begin{array}{ll}0& x不是不动点\\ 1& x是不动点\end{array}$
根据定义，我们展开
$$\sum _{a_i\in G}{c}_1(a_i)=\sum _{a_i\in G}\sum _{1\le j\le n}{\chi }_{a_i}(j)=\sum _{1\le j\le n}\sum _{a_i\in G}{\chi }_{a_i}(j)$$
我们设$\mathrm{Z}(x)$为满足$x$是不动点的置换集合，我们发现上式的后半部分可以直接套入
$$\sum _{1\le j\le n}\sum _{a_i\in G}{\chi }_{a_i}(j)=\sum _{1\le j\le n}|\mathrm{Z}(j)|$$
我们发现，对于同一个等价类里的元素$x_1,x_2$，一定满足$Z(x_1)=Z(x_2)$，原因是$Z(x)$集合是一个置换群元素集合的子集
这样我们设$C$为一个等价类元素集合，设$c=\forall x\in C$，那么无论$c$的取值，$Z(c)$的值都是一样的
那么继续上式
$$\sum _{1\le j\le n}|\mathrm{Z}(j)|=\sum _C|C|\ast Z(c)=|G|\sum _{C}1=|G|\cdot |C|=|G|l$$
对于第二个等号，可能你会感到疑惑
这里用到了$|C|\ast \mathrm{Z}(c)=|G|$，即“轨道-稳定集定理”，这里就不展开了，因为这个的证明还需要拉格朗日定理等群论基本知识，有兴趣的可以看这篇博客，里面有一些基本概念的介绍，另外，据说具体证明可以参照 《组合数学》（第5版）P181 定理4-11（暂未考证）
综上$$l=\frac{1}{|G|}\sum _{a_i\in G}{c}_1(a_i)$$

---

这篇博客里有比较清楚的例子，我这里就不举例了
我们发现，在染色问题循环同构的题中，$|G|$是旋转方式数，$|A|$是所有染色种类数，算法的复杂度是$\mathcal{O}(|G||A|)$的，而后者很容易变得很大，这个时候就需要用到Polya定理
（也正因为如此在OI中应用不多）

Polya定理

前提条件：如果将$[1,n]$用$k$种颜色进行染色
我们定义$\lambda (a_i)$为置换$a_i$的循环数量
Polya定理：
$$l=\frac{1}{|G|}\sum _{a_i\in G}{k}^{\lambda (a_i)}$$
Polya定理其实就是一种Burnside引理的具体化，就是把上面的$c_1(a_i)$算出来了

例题

[poj1286]Necklace of Beads
题目大意：现在有$3$种颜色的珠子，问有多少种长度为$n$的环，旋转、轴对称同构算一种
题解： 我们发现对于一个$n$的置换只有$2\ast n$种，直接套polya定理求环数量即可，复杂度$\mathcal{O}(n^2)$

#include
#include
#include
#include
typedef long long ll;
#define rg register
template <typename T> inline void read(T&x){char cu=getchar();x=0;bool fla=0;while(!isdigit(cu)){if(cu=='-')fla=1;cu=getchar();}while(isdigit(cu))x=x*10+cu-'0',cu=getchar();if(fla)x=-x;}
template <typename T> inline void printe(const T x){if(x>=10)printe(x/10);putchar(x%10+'0');}
template <typename T> inline void print(const T x){if(x<0)putchar('-'),printe(-x);else printe(x);}
ll n,ans[24];
int a[24];
bool vis[24];
ll pow(ll x,ll y)
{
	ll res=1;
	for(;y;y>>=1,x=x*x)if(y&1)res*=x;
	return res; 
}
void dfs(const int x)
{
	if(vis[x])return;
	vis[x]=1;
	dfs(a[x]);
}
void calc()
{
	memset(vis,0,sizeof(vis));
	int k=0;
	for(rg int i=0;i<n;i++)
		if(!vis[i])
			dfs(i),k++;
	ans[n]+=pow(3,k);
}
int main()
{
	for(n=1;n<24;n++)
	{
		for(rg int i=0;i<n;i++)
		{
			for(rg int j=0;j<n;j++)a[j]=(i+j)%n;
			calc();
			for(rg int j=0;j<n-j-1;j++)std::swap(a[j],a[n-j-1]);
			calc();
		}
		ans[n]/=2*n;
	}
	while(1)
	{
		read(n);
		if(n==-1)break;
		print(ans[n]),putchar('\n');
	}
    return 0;
}