群论——从入门到放弃(群、置换、Burnside引理和Polya定理)

前言

正如大家所知，我是一个蒟蒻，所以我滚来学群论了QAQ
群论其实是个很厉害的东西，不知道比反演什么的简单到哪里去了。
啊，学渣苦，学渣累。——Friedrich Taylor

什么是群？

首先我们要知道什么是群。
群的定义：给定一个集合G={a,b,c,…}和集合上的二元运算”$*$”,满足以下四条性质：
1.封闭性：$\forall a,b\in{\bf G},\exists c\in{\bf G},a*b=c$
2.结合律：$\forall a,b,c\in{\bf G},(a*b)*c=a*(b*c)$
3.单位元：$\exists e\in{\bf G}，\forall a\in{\bf G},a*e=e*a=a$
4.逆元：$\forall a\in{\bf G},\exists b\in{\bf G},a*b=b*a=e,记b=a^{-1}$
则称集合G在运算”$*$”下是一个群，可以简称为G是群。
顺便普及一下关于群的两个定理
1.如果(G,$*$)是群，则$\forall g\in{\bf G},g*\bf G=\bf G*g=G$
其中$g*\bf G=\{ {g*h}|h\in{\bf G}\}$
2.如果(G,$*$)是群，H是G的非空子集，且(H,$*$)也是群，那么称H为G的子群。
根据定理2可以判断子集是否为一个子群：$HH=H且H^{-1}=H$等价于H是G的子群。

什么是置换？什么是置换群？

在学习了群的基础概念后，我们还需要一个知识补丁。
n个元素之间的置换$\begin{pmatrix}1&2&3&...&n \\ a_1&a_2&a_3&...&a_n \end{pmatrix}$表示1被1到n中的某个数$a_1$取代，直到n被1-n中的某个数$a_n$取代，且$a_1,a_2,...,a_n$互不相同。
置换群的元素是置换，运算是置换连接。
$e.g. \begin{pmatrix}1&2&3&4\\3&1&2&4\end{pmatrix}\begin{pmatrix}1&2&3&4\\4&3&2&1\end{pmatrix}=\begin{pmatrix}1&2&3&4\\3&1&2&4\end{pmatrix}\begin{pmatrix}3&1&2&4\\2&4&3&1\end{pmatrix}=\begin{pmatrix}1&2&3&4\\2&4&3&1\end{pmatrix}$
貌似我们可以验证置换群的确是群。
具体的简单感性认知如下
1.封闭性：$\begin{pmatrix}1&2&...&n\\a_1&a_2&...&a_n\end{pmatrix}\begin{pmatrix}a_1&a_2&...&a_n\\b_1&b_2&...&b_n\end{pmatrix}=\begin{pmatrix}1&2&...&n\\b_1&b_2&...&b_n\end{pmatrix}$
2.结合律：$\begin{Bmatrix}\begin{pmatrix}1&2&...&n\\a_1&a_2&...&a_n\end{pmatrix}\begin{pmatrix}a_1&a_2&...&a_n\\b_1&b_2&...&b_n\end{pmatrix}\end{Bmatrix}\begin{pmatrix}b_1&b_2&...&b_n\\c_1&c_2&...&c_n\end{pmatrix}\\=\begin{pmatrix}1&2&...&n\\a_1&a_2&...&a_n\end{pmatrix}\begin{Bmatrix}\begin{pmatrix}a_1&a_2&...&a_n\\b_1&b_2&...&b_n\end{pmatrix}\begin{pmatrix}b_1&b_2&...&b_n\\c_1&c_2&...&c_n\end{pmatrix}\end{Bmatrix}$
3.单位元：
$e=\begin{pmatrix}1&2&....&n\\1&2&...&n\end{pmatrix}$
4.逆元：
$\begin{pmatrix}1&2&...&n\\a_1&a_2&...&a_n\end{pmatrix}^{-1}=\begin{pmatrix}a_1&a_2&...&a_n\\1&2&...&n\end{pmatrix}$

Polya定理

我们都知道大名鼎鼎的Polya定理：
$L=\frac{1}{|G|}\sum_{i=1}^s {m^{c(g_i)}}$
其中$L$表示本质不同的方案数，$|G|$表示置换数,$c(g_i)$表示置换i中循环节的个数,m表示染色的方案数。
首先介绍一下循环的概念：
$(a_1,a_2,...,a_n)=\begin{pmatrix}a_1&a_2&...&a_n-1&a_n\\a_2&a_3&...&a_n&a_1\end{pmatrix}$被称为n阶循环
两个循环$(a_1,a_2,...a_n)$与$(b_1,b_2,...b_n)$互不相交，当且仅当$a_i\not=b_j$，其中$i,j=1,2,...,n$.
例如：$\begin{pmatrix}1&2&3&4&5\\3&1&2&5&4\end{pmatrix}=(123)(45)$对于这个置换，其循环节数为2.
$e.g.$等边三角形三顶点分别用红绿蓝三种颜色着色，有多少种不同的方案？其中的置换操作为：
（1）沿中心旋转$0^\circ$,$120^\circ$,$240^\circ$
（2）沿三条中线翻转
解：易知对于沿中心旋转$0^\circ$，置换为$\begin{pmatrix}1&2&3\\1&2&3\end{pmatrix}$，循环节数为3
沿中心旋转$120^\circ$，置换为$\begin{pmatrix}1&2&3\\2&3&1\end{pmatrix}$，循环节数为1
沿中心旋转$240^\circ$，置换为$\begin{pmatrix}1&2&3\\3&1&2\end{pmatrix}$，循环节数为1
沿三条中线翻转的置换分别为$\begin{pmatrix}1&2&3\\1&3&2\end{pmatrix}$，$\begin{pmatrix}1&2&3\\2&1&3\end{pmatrix}$，$\begin{pmatrix}1&2&3\\2&1&3\end{pmatrix}$，循环节数均为2
根据Polya定理可以知道不同的方案数$L$为
$\frac{1}{6}(3^3+3^1+3^1+3^2+3^2+3^2)=10$

如何证明Polya定理？Burnside！

Burnside引理是群论中的一个结论，可以用来计算等价类的个数，即
$L=\frac{1}{|G|}\sum_{j=1}^{s}D(a_j)$
其中$D(a_j)$表示在置换$a_j$下不变的染色方案的个数。
同样我们可以用Burnside引理来解决上述等边三角形的问题
沿中心旋转$0^\circ$时，所有的$3^3$种染色方案均不变
沿中心旋转$120^\circ$或$240^\circ$时，只有三点颜色相同的染色方案才不变色
分别沿三条中线对折时，分别有$3^2$种方案不变色
所以L为$\frac{1}{6}(3^3+3^1+3^1+3^2+3^2+3^2)=10$
相信大家都应该发现了：要得到在置换下稳定不动的方案，只需把置换的每个循环节染上相同的颜色即可，所以$D(a_j)=m^{c(a_j)}$
那么我们如何证明Burnside引理呢？
我们先引进一个定理($x$)：
$|E_k|*|Z_k|=|G|,k=1,2,...,n$
$E_k$：设$G$是1,2,…,n的置换群，若$k$是1,2,…,n中的某个元素,$k$在$G$作用下的轨迹，即$k$在$G$作用下能够变化成的所有元素的集合，称之为$k$的等价类。
$Z_k$：设$G$是1,2,…,n的置换群，若$k$是1,2,…,n中的某个元素,$G$中使$k$保持不变的置换的全体，记做$Z_k$，称之为$G$中使$k$不动的置换类。
我们通过又一个例题来最终”推导”出Burnside引理
$e.g.$对2$*$2的方块进行黑白染色，能得到多少不同的图像？
其中的置换操作为：
旋转$0^\circ,90^\circ,180^\circ,270^\circ$
解：我们很容易根据burnside引理或者是Polya定理亦或是手推都能得到最后的方案一定是6种。那么我们继续无聊但有必要地推导一下：
总方案数：$2^4$=16种
设方案1为四格均白，则有
$|E_1|*|Z_1|=1*4=4$
设方案a为只有右上角一个黑格，其馀皆白，则有
$|E_a|*|Z_a|=4*1=4$
设方案b为右上左下皆为黑格，左上右下均为白格，则有
$|E_b|*|Z_b|=2*2=4$
所以定理$x$是可以直观感知的
现在我们推一推Burnside
接下来我们研究每种方案在各个置换下不变的次数之和
设$a_i$为第i种置换,n表示方案数，s表示置换数
设$S_{ij}=\begin{cases}0,当a_i\notin{\bf{Z_j}}，即方案j在置换a_i下变动了\\1,当a_i\in{\bf{Z_j}}，即方案j在置换a_i下保持不变\end{cases}$
由$S_{i,1}+S_{i,2}+...S_{i,n}=D(a_i)$
以及$S_{1,i}+S_(2,i)+...+S_(s,i)=Z_k$
由此可得$\sum_{j=1}^nZ_j=\sum_{i=1}^s\sum_{j=1}^nS_{i,j}=\sum_{i=1}^sD(a_i)$
也就是$\sum_{j=1}^nZ_j=\sum_{i=1}^sD(a_i)$
或者我们继续假设n个方案中总共有L个等价类
那么$n=E_1+E_2+...+E_L$
同时，当$i,j$属于同一等价类时，有$|Z_i|=|Z_j|$
所以可以如是推导：
$\sum_{i=1}^sD(a_i)=\sum_{j=1}^nZ_j=\sum_{i=1}^L\sum_{j\in{E_i}}|Z_k|=\sum_{i=1}^L|E_i|*|Z_i|=\sum_{i=1}^{L}|G|=L*|G|$
很明显我们求的就是L
所以$L=\frac{1}{|G|}\sum_{j=1}^sD(a_j)$,Burnside引理得证

一些简单得如南极冰盖瞬间融化一样水的习题

（1）Cipher(Central Europe 1995)
题面见链接(http://poj.org/problem?id=1026 )
题意：对于一个长度为n的字符串，有一个数组表示第i个字符放到那个位置。输入多个字符串，问这样操作k次后的字符串的形态
题解：暴力肯定是药丸的。
我们可以这样做：对于每个数组，求其循环节，再用总操作数依次模每个字符所在循环节长度后再暴力求解即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline long long read(){
    long long i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<3)+(i<<1)+(ch^48);
    return i*f;
}
int buf[1024];
void write(long long x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ; 
}
#define stan 222
int sze[stan],trans[stan],tmp,n,k,pos,len;
char word[stan],ans[stan];
signed main(){
    n=read();
    while(n!=0){
        memset(sze,0,sizeof(sze));
        for(int i=1;i<=n;++i)
            trans[i]=read();
        for(int i=1;i<=n;++i){
            tmp=i;
            while(!sze[i]||tmp!=i){
                ++sze[i];
                tmp=trans[tmp];
            }
        }
        k=read();
        while(k!=0){
            memset(word,0,sizeof(word));
            memset(ans,0,sizeof(ans));
            gets(word+1);
            len=0;
            for(int i=1;i<=n;++i){
                if(word[i]==0) len=1;
                tmp=k%sze[i],pos=i;
                while(tmp--)
                    pos=trans[pos];
                if(len) ans[pos]=' ';
                else ans[pos]=word[i];
            }
            ans[n+1]=0;
            puts(ans+1);
            k=read();
        }
        puts("");
        n=read();
    }
    return 0;
}

（2）cow sorting(USACO 2007 February Gold)
题面依旧见链接(http://poj.org/problem?id=3270)
题意：给你n个数，按升序排序，可以交换任意两个数且每次交换的代价是这两个数的和，求最小代价。
题解：考虑一种比较优秀的方法：求出这个序列的循环节，那么对于这个循环节，设其为$a_1,a_2,...a_x$,若数列只有该循环节，最小代价为
$a_1*(x-1)+(a_2+a_3+...+a_x)$①
但还有一种情况：如果把$a_1$换做整个数列最小的数$a_{min}$后再进行上述操作，则花费为$2*(a_1+a_{min})+a_{min}*(x-1)+(a_2+a_3+...+a_x)$②
对于每个循环节，取①、②的最小值即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline long long read(){
    long long i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<3)+(i<<1)+(ch^48);
    return i*f;
}
int buf[1024];
void write(long long x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ; 
}
#define stan 111111
int m,n,a[stan],pos[stan],inner[stan],mini;
long long ans;
signed main(){
    while(scanf("%d",&n)!=EOF){
        memset(inner,0,sizeof(inner));
        mini=999999999;
        for(int i=0;i<n;++i){
            a[i]=read();
            mini=min(a[i],mini);
            pos[a[i]]=i;
        }
        sort(a,a+n);
        for(int i=0;i<n;++i){
            if(i==pos[a[i]]||inner[a[i]]) continue;
            int temp_pos=i,sze=0;
            while(!inner[a[temp_pos]]){
                inner[a[temp_pos]]=true;
                temp_pos=pos[a[temp_pos]];
                ++sze;
                if(!inner[a[temp_pos]]) ans+=a[temp_pos];
            }
            ans+=min(a[i]*(sze-1),(a[0]+a[i])*2+a[0]*(sze-1));
        }
        write(ans);puts(" ");
    }
    return 0;
}

（3）Let it Bead(Ulm Local 2000)
题面依然见链接(http://poj.org/problem?id=2409)
题意：一个有n个元素的环，有m种颜色，求不同染色方案数
其中的置换操作为：顺时针旋转$1,2,...,n-1$个元素
题解：此处用到一个结论：第i个置换的循环节个数为$gcd(n,i)$
然后就是愉快的暴力套Polya

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline long long read(){
    long long i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<3)+(i<<1)+(ch^48);
    return i*f;
}
int buf[1024];
void write(long long x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ; 
}
int m,n;
long long ans;
long long gcd(long long a,long long b){
    if(b) return gcd(b,a%b);
    else return a;
}
long long ksm(long long a,long long b){
    long long ret=1;
    while(b){
        if(b&1) ret*=a;
        a*=a;
        b>>=1;
    }
    return ret;
}
signed main(){
    m=read();n=read();
    while(n!=0&&m!=0){
        ans=0;
        if(n==0||m==0){
            puts("0");
        }else{
            for(int i=1;i<=n;++i)
                ans+=ksm(m,gcd(n,i));
            if(n&1)
                ans+=n*ksm(m,(n+1)/2);
            else
                ans+=(n>>1)*(ksm(m,n/2)+ksm(m,n/2+1));
            write(ans/(2*n));
            puts(" ");
        }
        m=read();n=read();
    }
    return 0;
}

（4）Magic Bracelet(POJ2888)
题面见链接(http://poj.org/problem?id=2888)
题意：n个元素m种颜色，某些颜色不能匹配，求染色方案数对9973取模。其中的置换操作为顺时针旋转$1,2,...n-1$个元素。
题解：因为有限制所以只能用Burnside引理。
但是因为n达到了$10^9$，显然不能暴力枚举
观察发现$\sum_{i=1}^Ne[gcd(i,N)=k]=\phi(N/k)$
所以我们只需要枚举$1$到$\sqrt n$中能整除 n <script type="math/tex" id="MathJax-Element-106">n</script>的数即可
同时因为n过大我们也需要矩阵快速幂优化
注意这道题卡模运算常数

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#define mod 9973
using namespace std;
inline int read(){
    int i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<3)+(i<<1)+(ch^48);
    return i*f;
}
int buf[1024];
void write(int x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ; 
}
int n,m,k,T,a,b;
struct matrix{
    int mat[11][11];
    inline void I()
    {
        memset(mat,0,sizeof(mat));
        for(int i=1;i<=m;i++)mat[i][i]=1;
    }
    inline matrix operator * (const matrix &b)
    {
        matrix c;
        for(int i=1;i<=m;i++)
            for(int j=1;j<=m;j++)
            {
                int sum=0;
                for(int k=1;k<=m;k++)
                    sum+=mat[i][k]*b.mat[k][j];
                c.mat[i][j]=sum%mod;        
            }
        return c;
    }
    inline matrix operator ^ (int x)
    {
        matrix res,tmp=*this;
        res.I();
        for(;x>0;x>>=1,tmp=tmp*tmp)
            if(x&1)res=res*tmp;
        return res;
    }
}basic;
int getphi(int x){
    int ret=x;
    for(int i=2;i*i<=x;++i)
        if(x%i==0){
            ret-=ret/i;
            while(x%i==0) x/=i;
        }
    if(x>1) ret-=ret/x;
    return ret%mod;
}
int calc(matrix x){
    int ret=0;
    for(int i=1;i<=m;++i)
        ret+=x.mat[i][i];
    return ret%mod;
}
int inv(int n){
    n%=mod;
    int b=mod-2,ret=1;
    while(b){
        if(b&1) ret=(ret*n)%mod;
        n=(n*n)%mod;
        b>>=1;
    }
    return ret;
}
int getans(int n){
    int ret=0;
    for(int i=1;i*i<=n;++i)
        if(n%i==0){
            ret=(ret+calc(basic^i)*getphi(n/i))%mod;
            if(i*i<n) ret=(ret+calc(basic^(n/i))*getphi(i))%mod;
        }
    return ret*inv(n)%mod;
}
signed main(){
    T=read();
    while(T--){
        n=read();m=read();k=read();
        for(int i=1;i<=m;++i)
            for(int j=1;j<=m;++j)
                basic.mat[i][j]=1;
        for(int i=1;i<=k;++i){
            a=read();b=read();
            basic.mat[a][b]=basic.mat[b][a]=0;
        }
        write(getans(n));
        puts("");
    }
    return 0;
}

小结

啊，终于水完了。
群论还是很有趣的
这篇文章（我们姑且这么称呼这一大摞字）主要涉及的是关于群论中Polya定理的证明、理解以及群论的常识。
在信息学竞赛中，群论的主要运用是Polya定理以及Burnside引理进行组合计数。而作为研究贪心算法的数学基础的拟阵在本文中毫无提及。
感谢现代群论的创始者迦罗瓦先生(Évariste Galois,1811-1832)。
本文的脉络思路主要参考了林厚从先生《信息学奥赛之数学一本通》(2016年版)关于群论一章的内容。该书的编者之一，闫书弈先生于NOI2017以627的高分夺rank1，%%%
这里甩一个课件
哈工程沈晶老师的PPT：(https://wenku.baidu.com/view/2c7a737b02768e9951e7387a.html?from=search)