浅谈群论

群

一些基础

子群

若 $H$ 是 $G$ 的子集且 $<H,op>$ 为群,则 $<H,op>$ 为 $<G,op>$ 的子群

则 $H$ 既满足封闭性且求逆封闭, $\forall a,b\in H,ab\in H,a^{-1}\in H$

等价于 $\forall a,b\in H,ab^{-1}\in H$

一些特殊特殊的子群:

生成子群: $a\in G$ ,则 $<\{a^i,i\in Z\},op>$ 称为生成子群

正规化子: $a\in G$ ,则 $<\{x|ax=xa,x\in G>$ 称为正规化子,记为 $N(a)$

共轭子群: $a\in G,H$ 为 $G$ 的子群,则 $xHx^{-1}$ 称为 $H$ 的共轭子群

等价类

等价关系:满足自反性 $a=a$ ,对称性 $a=b\Leftrightarrow b=a$ ,传递性 $a=b,b=c\Leftrightarrow a=c$ ( $=$ 代表的是等价关系)

等价类: $x$ 的等价类 $[x]_R=\{y|<x,y>\in R\}$ , $R$ 是满足某种等价关系两个元素所有集合

可以认为是把等价关系看作边, $[x]_R$ 是 $x$ 所在联通块的大小

商集: $[A/R]$ 指在以 $R$ 为等价关系时等价类的集合

陪集

陪集分为右陪集与左陪集,两个没区别

对于 $a\in G$ , $H$ 是 $G$ 的子群,称 $Ha=\{ha|h\in H\}$ 为 $H$ 的右陪集

如果 $H$ 为有限集,则 $|Ha|=|H|$ (不会证)

Lagrange定理

设 $H$ 为 $G$ 的子群,则 $|G|$ 为 $|H|$ 的倍数

考虑用陪集分解群

首先有个结论, $\forall a,b\in G,H$ 为 $G$ 的子群, $a\in Hb\Leftrightarrow Ha=Hb\Leftrightarrow ab^{-1}\in H$

若已知 $a\in Hb$ ,则 $a=h_1b,h_1\in H$ , $\forall h_2\in H$ , $h_2a=h_2h_1b$ ,且 $h_2h_1\in H$

则 $Ha\subseteq Hb$ ,反过来同理的 $Hb\subseteq Ha$ ,即 $Ha=Hb$

若已知 $Ha=Hb$ ,则 $\exist h_1,h_2\in H,h_1a=h_2b$ , $ab^{-1}=h_1^{-1}h_2\in H$

若已知 $ab^{-1}\in H$ ,则 $ab^{-1}=h\in H$ ,则 $a=hb\in Hb$

如果将 $Ha=Hb$ 视为一种等价关系, $H$ 一定单独是一个等价类

若 $a\notin H$ ,则 $Ha\not=He$ ,即 $a$ 一定不与 $e$ 在同一等价类

又 $|Ha|=|H|$ ,所以所有等价类大小相同

即 $\dfrac{|G|}{|H|}=|[G/R]|,R=\{<a,b>,Ha=Hb\}$

由此还可以得到共轭类分解

共轭关系也是一种等价关系,将 $a\in G$ ,所有与 $a$ 共轭的 $b$ 形成的集合称为共轭类

$a$ 所在的共轭类大小为 $\dfrac{|G|}{|N(a)|}$

令 $x,y\in G,xax^{-1}=yay^{-1}$

$xa=yay^{-1}x\Rightarrow y^{-1}xa=ay^{-1}x\Rightarrow y^{-1}x\in N(a)\Rightarrow xN(a)=yN(a)$

如果沿用陪集分解的思路,因为 $xN(a)=yN(a)$ 则 $x,y$ 属于同一个等价类

用 $N(a)$ 陪集分解,对于其中的一个等价类中所有的元素 $x$ , $xax^{-1}$ 确定 $a$ 的一个共轭

则共轭类的大小即为 $N(a)$ 陪集分解后的等价类个数

置换群相关定理

置换群

置换群即为一个 $n$ 元排列 $P$ 组成的集合,定义运算 $PG=(G_{P_i})$

可证满足封闭性与求逆封闭

如果将 $i$ 和 $P_i$ 连有向边,则图为若干个不相交的环( $n$ 条边 $n$ 个点)

当然,有时置换群不一定是一个排列的集合,但一定是置换的集合

轨道-稳定子群定理

定义一个集合 $A$ , $G$ 为一个作用于 $A$ 的置换群, $a\in A$

定义 $G^a=\{g|g(a)=a,g\in G \}$ ,称为稳定子群

$G(a)=\{g(a),g\in G \}$ ,称为轨道

$|G|=|G(a)|\times|G^a|$ ,证明如下

设 $x,y\in G$ ,且 $x(a)=y(a)$ ,则 $\Leftrightarrow a=x^{-1}(y(a))\Leftrightarrow x^{-1}y\in G^a\Leftrightarrow xG^a=yG^a$

将 $G$ 以 $G^a$ 陪集分解,则当 $x(a)=y(a)$ 时 $x,y$ 属于同一等价类

考虑等价类的个数即为有多少个不同的 $x(a)$ 即为 $|G(a)|$

Burnside 引理

$[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G}[A^g]$ , $A^g$ 的定义与 $G^a$ 类似,就是 $A^g=\{a|g(a)=a,a\in A \}$

$|G^a|=\dfrac{|G|}{|G(a)|}$ ，两边同时求和

$\sum\limits_{a\in A}|G^a|=\sum\limits_{a\in A}\dfrac{|G|}{|G(a)|}=|G|\sum\limits_{a\in A}\dfrac{1}{|G(a)|}$

观察 $\sum\limits_{a\in A}\dfrac{1}{|G(a)|}$ ，本质为轨道个数(每一个 $a$ 所在的等价类大小分之 $1$ 求和就是等价类的个数)= $[A/G]$

$\sum\limits_{a\in A}|G^a|=\sum\limits_{g\in G}[A^g]=|G|\times|[A/G]|$

即 $[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G}[A^g]$

在这里我们给问题赋予一个实际意义

考虑 $A$ 表示问题的所有方案, $G$ 为问题视为重复方案的置换

$[A/G]$ 即为将 $G$ 看作一个等价关系的集合后划分出的等价类集合

$G^a$ 即为满足对 $a$ 置换作用后依旧不变的置换, $A^g$ 差不多

$G(a)$ 为与 $a$ 一起视为一种方案的方案集合,也可一看作是 $a$ 所在的等价类

再具体一点的例子就是环的着色问题

Pólya 定理

具体到染色问题,假设有 $m$ 种颜色

则 $A^g=m^{c(g)}$ , $c(g)$ 为 $g$ 的不相交循环个数

【模板】Pólya 定理

给定一个 $n$ 个点， $n$ 条边的环，有 $n$ 种颜色，给每个顶点染色，问有多少种本质不同的染色方案，答案对 $10^9+7$ 取模

注意本题的本质不同，定义为：只需要不能通过旋转与别的染色方案相同。

很明显 $G$ 为一个轮换了 $i$ 次的置换群

问题在于计算 $c(g)$ ,考虑 $g$ 是轮换了 $i$ 次的的置换,当前位置为 $p$

$p->(p+i)mod\ n->(p+2i)mod\ n.....p'mod\ n=p$

即 $p+(n/c(g))i=p+kn$ ,即 $c(g)=\dfrac{i}{k}$ ，则 $c(g)$ 既为 $n$ 的因数也为 $i$ 的因数且最大

则 $c(g)=gcd(i,n)$

$[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G} n^{c(g)}=\dfrac{1}{n}\sum\limits_{i=1}^nn^{gcd(i,n)}$

令 $f(x)=n^x$

$[A/G]=\dfrac{1}{n}\sum\limits_{i=1}^nf(gcd(i,n))=\dfrac{1}{n}\sum\limits_{d|n}f(d)\sum\limits_{i=1}[gcd(i,n)=d]=\dfrac{1}{n}\sum\limits_{d|n}f(d)\phi(\dfrac{n}{d})$

这里用 $dfs$ 凑因子可以做到 $\Theta(\sqrt n)$

#include<bits/stdc++.h>
using namespace std;
const int MOD=1e9+7;
int t;
int n;
int Pow(int a,int b,int p)
{
	int res=1;
	int base=a;
	while(b)
	{
		if(b&1)
		{
			res=((long long)res*base)%p;
		}
		base=((long long)base*base)%p;
		b>>=1;
	} 
	return res;
}
vector<pair<int,int> >Rec;
int Phi[105][105];
int Pri[105][105];
int Used[105];
int Res=0;
void dfs(int x)
{
	if(x==Rec.size())
	{
		int d=1;
		int phi=1;
		for(int i=0;i<Rec.size();i++)
		{
			d=(d*Pri[i][Used[i]]);
			phi=(phi*Phi[i][Used[i]]);
		}
		Res=((long long)Res+((long long)phi*Pow(n,(n/d)-1,MOD))%MOD)%MOD;
		return;
	}
	int Lim=Rec[x].second;
	for(int i=0;i<=Lim;i++)
	{
		Used[x]=i;
		dfs(x+1);
	}
}
int main()
{
	scanf("%d",&t);
	while(t--)
	{
		Rec.clear();
		scanf("%d",&n);
		Res=0;
		int now=n;
		for(int d=2;d*d<=now;d++)
		{
			if(now%d==0)
			{
				int Tot=0;
				while(now%d==0)
				{
					now/=d;
					Tot++; 
				}
				Rec.push_back(make_pair(d,Tot));
			}
		}
		if(now>1)
		{
			Rec.push_back(make_pair(now,1));
		}
		for(int i=0;i<Rec.size();i++)
		{
			int Lim=Rec[i].second;
			int p=Rec[i].first;
			Phi[i][0]=1;
			Pri[i][0]=1;
			for(int j=1;j<=Lim;j++)
			{
				Pri[i][j]=Pri[i][j-1]*p;
				Phi[i][j]=Pri[i][j]-Pri[i][j-1];
			}
		}
		dfs(0);
		printf("%d\n",Res);
	}
}

Magic Bracelet

金妮的生日快到了。哈利波特正在为他的新女友准备生日礼物。礼物是一个由 $n$ 颗魔法珠组成的魔法手镯。有 $m$ 种不同的魔珠。每种珠子都有其独特的特征。将许多珠子串在一起，将制作一个漂亮的圆形魔法手镯。正如哈利波特的朋友赫敏所指出的那样，某些种类的珠子会相互作用并爆炸，哈利波特必须非常小心地确保这些对的珠子不会并排串在一起,有无数种珠子。如果忽略围绕手镯中心旋转产生的重复，哈利能制作多少种不同的手镯？找到取模 $9973$ 的答案。

同样定义 $G$ 为轮换 $i$ 次的置换群,但由于不能随便染色,所以不能用 $Pólya$ 定理

$[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G}|A^g|$

瓶颈在于计算 $|A^g|$

我们将 $g$ 拆分成不同的循环,这些循环的内部的点颜色是相同的且每个循环大小相同,问题是不同循环之间的关系

如果我们把一个循环看成一个点,再将和他有关系的连边,最后连出还是一个环

我们可以考虑只在这个环上计算答案

设 $f(x)$ 为长度为 $x$ 的环时的答案

$[A/G]=\dfrac{1}{n}\sum\limits_{g\in G}|A^g|=\dfrac{1}{n}\sum\limits_{d|n}f(d)\phi(\dfrac{n}{d})$

现在问题在与如何计算 $f(x)$

构造一个邻接矩阵 $T$ ,矛盾为 $0$ ，否则为 $1$ ,则 $T^x$ 时的对角线之和即为 $f(x)$

#include<cstdio>
#include<vector>
#include<utility>
#include<cstring>
using namespace std;
const int MOD=9973;

int t;
int m;
int x,y;
int k;
int Pow(int a,int b,int p)
{
	int res=1;
	int base=(a%p);
	while(b)
	{
		if(b&1)
		{
			res=(res*base)%p;
		}
		base=(base*base)%p;
		b>>=1;
	} 
	return res;
}
struct Martix{
    int n, m;
    int val[10][10];
    void clear() { memset(val, 0, sizeof(val)); }
    void init() {
        clear();
        for (int i = 0; i < n; i++) {
            val[i][i] = 1;
        }
    }
    Martix operator*(const Martix x) const {
        Martix Res;
        Res.n = n;
        Res.m = x.m;
        Res.clear();
        for (int k = 0; k <m; k++) {
            for (int i = 0; i < Res.n; i++) {
                for (int j = 0; j < Res.m; j++) {
                    Res.val[i][j]=(Res.val[i][j]+val[i][k]*x.val[k][j])%MOD;
                }
            }
        }
        return Res;
    }
}A;
Martix ppow(Martix Ad, int b) {
    Martix Res;
    Res=Ad;
    Res.init();
    Martix Base = Ad;
    while (b) {
        if (b & 1) {
            Res = Res * Base;
        }
        Base = (Base * Base);
        b >>= 1;
    }
    return Res;
}
int F(int x)
{
	Martix IDSY=ppow(A,x);
	int Res=0;
	for(int i=0;i<m;i++)
	{
		Res=(Res+IDSY.val[i][i])%MOD;
	}
	return Res;
}
vector<pair<int,int> >Rec;
int Phi[205][205];
int Pri[205][205];
int Used[205];
int Res=0;
int n;
void dfs(int x)
{
	if(x==Rec.size())
	{
		int d=1;
		int phi=1;
		for(int i=0;i<Rec.size();i++)
		{
			d=(d*Pri[i][Used[i]]);
			phi=(phi*Phi[i][Used[i]])%MOD;
		}
		Res=(Res+((phi)%MOD*F((n/d)))%MOD)%MOD;
		return;
	}
	int Lim=Rec[x].second;
	for(int i=0;i<=Lim;i++)
	{
		Used[x]=i;
		dfs(x+1);
	}
}

int main()
{
	scanf("%d",&t);
	while(t--)
	{
		Rec.clear();
		scanf("%d %d %d",&n,&m,&k);
		A.clear();
		A.n=m;
		A.m=m;
		for(int i=1;i<=A.n;i++)
		{
			for(int j=1;j<=A.n;j++)
			{
				A.val[i-1][j-1]=1;
			}
		}
		for(int i=1;i<=k;i++)
		{
			scanf("%d %d",&x,&y);
			A.val[x-1][y-1]=0;
			A.val[y-1][x-1]=0;
		}
		Res=0;
		int now=n;
		for(int d=2;d*d<=now;d++)
		{
			if(now%d==0)
			{
				int Tot=0;
				while(now%d==0)
				{
					now/=d;
					Tot++; 
				}
				Rec.push_back(make_pair(d,Tot));
			}
		}
		if(now>1)
		{
			Rec.push_back(make_pair(now,1));
		}
		for(int i=0;i<Rec.size();i++)
		{
			int Lim=Rec[i].second;
			int p=Rec[i].first;
			Phi[i][0]=1;
			Pri[i][0]=1;
			for(int j=1;j<=Lim;j++)
			{
				Pri[i][j]=Pri[i][j-1]*p;
				Phi[i][j]=Pri[i][j]-Pri[i][j-1];
			}
		}
		dfs(0);
		Res=(Res*Pow(n,MOD-2,MOD))%MOD;
		printf("%d\n",Res);
	}
	return 0;
}

[MtOI2018]魔力环

wkr 希望能够得到一个由 $n$ 个魔力珠串成的环。不过他对普通的环并不感兴趣，因此他提出了如下的要求：

wkr 希望在这个环上，恰好有 $m$ 个黑色的魔力珠与 $n - m$ 个白色的魔力珠。
由于 wkr 认为黑色魔力珠不应过于密集，因此 wkr 希望这个环上不会出现一段连续的黑色魔力珠，其长度超过 $k$ 。

在 wkr 的心目中，满足上述要求的环才是美妙的。

不过这样的环可能并不唯一。 wkr 想要知道共有多少种不同的环满足他所提出的要求。然而 wkr 并不喜欢计算，他希望聪明的你能够告诉他答案。

在这里，我们认为两个环是不同的，当且仅当其中一个环仅通过旋转无法得到另一个环。

由于答案可能过大，因此输出答案对 $998, 244, 353$ 取模后的结果。

沿用上一题的思路

$[A/G]=\dfrac{1}{n}\sum\limits_{g\in G}|A^g|=\dfrac{1}{n}\sum\limits_{d|n}f(d)\phi(\dfrac{n}{d})$ , $f(d)$ 为长度为 $d$ 时的答案,此时黑色点的数量为 $cb=(\dfrac{md}{(n)})$ ，这就要求 $cb$ 是 $\dfrac{n}{d}$ 的倍数, $cw=x-cb$ 为白色点的数目

考虑先构造一个点数为 $cw$ 的环,然后考虑向里面插入 $cb$ 个点且满足每个空隙的黑点数量不超过 $k$

计数带标号,所以断环为链,枚举断点的黑点数量 $i$

然后考虑剩下的链实际就是 $cw-1$ 个盒子, $cb-i$ 个球,每个盒子不能超过 $k$ 个球的方案

则 $F(d)=\sum\limits_{i=0}^{min(k,cb)}(i+1)\sum\limits_{j=0}^{n}\binom{cw-1}{j}\binom{cw-1+cb-i-1-kj}{cw-1-1}$

#include<bits/stdc++.h>
using namespace std;
const int MOD=998244353;
const int MAXN=1e5+5;
int n;
int m;
int k;
int Pow(int a,int b,int p)
{
	int res=1;
	int base=(a%p);
	while(b)
	{
		if(b&1)
		{
			res=((long long)res*base)%p;
		}
		base=((long long)base*base)%p;
		b>>=1;
	} 
	return res;
}
int inv(int a,int p)
{
	return Pow(a,p-2,p);
}
int gcd(int a,int b)
{
	if(b==0)
	{
		return a;
	}
	return gcd(b,a%b);
}
int fac[MAXN];
int inv_fac[MAXN];
int C(int n, int m) {
	if(m<0||m>n)
	{
		return 0;
	}
    if (m == 0 || n == m)
        return 1;
    int k = fac[n];
    int ans = ((long long)k*inv_fac[n - m])%MOD;
    ans = ((long long)ans*inv_fac[m])%MOD;
    return ans;
}
int Cal(int n,int m,int k)
{
	int Rex=0;
	if(m<0)
	{
		return 0;
	}
	for(int i=0;i<=n;i++)
	{
		if(m<(k+1)*i)
		{
			break;
		}
		int Con=((long long)C(n,i)*C(n+m-1-(k+1)*i,n-1))%MOD;
		if(i&1)
		{
			Rex=((long long)Rex-Con+MOD)%MOD; 
		 } 
		 else
		 {
		 	Rex=((long long)Rex+Con)%MOD;
		 }
		 //printf("%d %d %d %d?\n",Con,i,n+m-1-(k+1)*i,n-1);
	}
	return Rex;
}
int F(int x)
{
	if(m%(n/x))
	{
		return 0;
	 } 
	 int N=x;
	int cb=(m/(n/x));
 	int cw=(x-cb);
 	if(cb<=k)
	 {
	 	return C(N,cb);
	 }
	int Res=0;
	for(int i=0;i<=min(cb,k);i++)
	{
		Res=((long long)Res+((long long)(i+1)*Cal(cw-1,cb-i,k))%MOD)%MOD;	
	}
	return Res;
}
vector<pair<int,int> >Rec;
int Phi[205][205];
int Pri[205][205];
int Used[205];
int Res=0;
void dfs(int x)
{
	if(x==Rec.size())
	{
		int d=1;
		int phi=1;
		for(int i=0;i<Rec.size();i++)
		{
			d=(d*Pri[i][Used[i]]);
			phi=(phi*Phi[i][Used[i]])%MOD;
		}
		Res=((long long)Res+((long long)(phi)*F(n/d))%MOD)%MOD;
		return;
	}
	int Lim=Rec[x].second;
	for(int i=0;i<=Lim;i++)
	{
		Used[x]=i;
		dfs(x+1);
	}
}

signed main()
{
	fac[0] = 1;
    for (int i = 1; i <= MAXN-5; i++) {
        fac[i] = ((long long)fac[i - 1] * i)%MOD;
    }
    inv_fac[MAXN-5] = inv(fac[MAXN-5], MOD);
    for (int i = MAXN-5 - 1; i >= 0; i--) {
        inv_fac[i] = ((long long)inv_fac[i + 1] * (i + 1)) % MOD;
    }
	Rec.clear();
	scanf("%d %d %d",&n,&m,&k);
	Res=0;
	int now=n;
	for(int d=2;d*d<=now;d++)
	{
		if(now%d==0)
		{
			int Tot=0;
			while(now%d==0)
			{
				now/=d;
				Tot++; 
			}
			Rec.push_back(make_pair(d,Tot));
		}
	}
	if(now>1)
	{
		Rec.push_back(make_pair(now,1));
	}
	for(int i=0;i<Rec.size();i++)
	{
		int Lim=Rec[i].second;
		int p=Rec[i].first;
		Phi[i][0]=1;
		Pri[i][0]=1;
		for(int j=1;j<=Lim;j++)
		{
			Pri[i][j]=Pri[i][j-1]*p;
			Phi[i][j]=Pri[i][j]-Pri[i][j-1];
		}
	}
	dfs(0);
	Res=((long long)Res*inv(n,MOD))%MOD;
	printf("%d\n",Res);
	return 0;
}

[SHOI2006] 有色图

如果一张无向完全图（完全图就是任意两个不同的顶点之间有且仅有一条边相连）的每条边都被染成了一种颜色，我们就称这种图为有色图。如果两张有色图有相同数量的顶点，而且经过某种顶点编号的重排，能够使得两张图对应的边的颜色是一样的，我们就称这两张有色图是同构的。以下两张图就是同构的，因为假如你把第一张图的顶点 $(1,2,3,4)$ 置换成第二张图的 $(4,3,2,1)$ ，就会发现它们是一样的。

你的任务是，对于计算所有顶点数为 $n$ ，颜色种类不超过 $m$ 的图，最多有几张是两两不同构的图。由于最后的答案会很大，你只要输出结论模 $p$ 的余数就可以了（ $p$ 是一个质数）。

这里图的置换群 $G$ 就是一个全排列,同样用 $Burnside$

$[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G}|A^g|$ ,瓶颈还是在 $|A^g|$ ，注意 $|A^g|$ 是不动的边集

还是给 $g$ 分解成几个循环

如果 $(u,v)$ 是在同一个循环 $S$

则一共有 $\lfloor\dfrac{|S|}{2}\rfloor$ 种边的循环(考虑一个正 $|S|$ 多边形按边所对应的角度分类)

如果 $(u,v)$ 不在同一个循环,分别在 $S_1,S_2$

边 $(u,v)$ 会经过 $lcm(|S_1|,|S_2|)$ 次转动后复原,也就是说 $(u,v)$ 所在的边集环大小 $lcm(|S_1|,|S_2|)$

个数则为 $\dfrac{|S_1|\times|S_2|}{lcm(|S_1|,|S_2|)}=gcd(|S_1|,|S_2|)$

设 $g$ 的第 $i$ 个轮换大小为 $b_i$

因而 $[A/G]=\dfrac{1}{|G|}\sum\limits_{g\in G}|A^g|=\dfrac{1}{n!}\sum\limits_{g\in G}m^{\sum\lfloor\frac{b_i}{2}\rfloor+\sum\limits_i\sum\limits_{j>i}gcd(i,j)}$

如果我们分拆 $n$ 得到 $b$ ,定义 $f(b)$ 为轮换序列为 $b$ 的 $g$ 的个数

$[A/G]=\dfrac{1}{n!}\sum\limits_{b}m^{\sum\lfloor\frac{b_i}{2}\rfloor+\sum\limits_i\sum\limits_{j>i}gcd(i,j)}f(b)$

考虑 $f(b)$ 的计算

将带标号的排列分成大小为 $b_i$ 几组 $\dfrac{n!}{\prod b_i!}$ ,再考虑组内顺序为 $\dfrac{b_i!}{b_i}$

同时相同的 $b_i$ 是无顺序的,还要乘上 $\dfrac1{v_{bi}!}$

$f(b)=\dfrac{n!}{\prod b_i\prod v_{b_i}!}$

#include<bits/stdc++.h>
using namespace std;
int n,m,MOD;
int fac[60];
int inv_fac[60];
int Inv[60];
int Pow(int a,int b,int p)
{
	int res=1;
	int base=(a%p);
	while(b)
	{
		if(b&1)
		{
			res=((long long)res*base)%p;
		}
		base=((long long)base*base)%p;
		b>>=1;
	} 
	return res;
}
int inv(int a,int p)
{
	return Pow(a,p-2,p);
}
int gcd(int a,int b)
{
	if(b==0)
	{
		return a;
	}
	return gcd(b,a%b);
}
int b[60];
int v[60];
int Res=0;
int Gcd[65][65];
void dfs(int x,int Rest,int las)
{
	if(Rest==0)
	{
		for(int i=1;i<=n;i++)
		{
			v[i]=0;
		}
		int Tc=0;	
		for(int i=1;i<=x;i++)
		{
			v[b[i]]++;
			Tc=((long long)Tc+(b[i]/2))%(MOD-1); 
		}
		for(int i=1;i<=x;i++)
		{
			for(int j=i+1;j<=x;j++)
			{
				Tc=((long long)Tc+Gcd[b[i]][b[j]])%(MOD-1);
			}
		}
		int Con=Pow(m,Tc,MOD);
		for(int i=1;i<=x;i++)
		{
			Con=((long long)Con*Inv[b[i]])%MOD;
		}
		for(int i=1;i<=n;i++)
		{
			Con=((long long)Con*inv_fac[v[i]])%MOD;
		}
		Res=((long long)Res+Con)%MOD;
		return;
	}
	for(int i=las;i<=Rest;i++)
	{
		b[x+1]=i;
		dfs(x+1,Rest-i,i);
	}
}

int main()
{
	scanf("%d %d %d",&n,&m,&MOD);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			Gcd[i][j]=gcd(i,j); 
		}
		Inv[i]=inv(i,MOD);
	}
	
	fac[0] = 1;
    for (int i = 1; i <= n; i++) {
        fac[i] = ((long long)fac[i - 1] * i)%MOD;
    }
    inv_fac[n] = inv(fac[n], MOD);
    for (int i = n - 1; i >= 0; i--) {
        inv_fac[i] = ((long long)inv_fac[i + 1] * (i + 1)) % MOD;
    }
	dfs(0,n,1); 
	printf("%d\n",Res);
}

posted @ 2023-01-31 21:21 kid_magic 阅读(243) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 浅谈生成函数

· 廒睿骋隺冀

· 置换群 / Polya 原理 / Burnside 引理学习笔记

· Yukiの群论笔记

· 置换群、等价类计数与 Burnside 引理

公告

昵称： kid_magic
园龄： 4年4个月
粉丝： 16
关注： 9

+加关注

2025年3月

日

一

二

三

四

五

六

Yukino

浅谈群论

群

一些基础

子群

等价类

陪集

Lagrange定理

置换群相关定理

置换群

轨道-稳定子群定理

Burnside 引理

Pólya 定理

【模板】Pólya 定理

Magic Bracelet

[MtOI2018]魔力环

[SHOI2006] 有色图

公告

搜索

常用链接

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论