polya/burnside定理入门

lhfl911 lhfl911 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.7k累计阅读 1.7k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
原创 最新推荐文章于 2022-07-26 22:41:02 发布 1.7k 阅读 AI 写同款· GEO 优化 ›
【学习笔记】Burnside引理,Pólya定理及其应用 好东西+1 阅读详情

burnside和polya都是解决非等价染色方案的计数工具，最近刚刚学习，做了几道入门题，今天整理一下。

首先将旋转、翻转之类的变换都转变为一个置换，构成一个置换群G。
简单来说，burnside定理就是 非等价染色数 = 在G中单个置换下保持不变的染色数的平均数。
而polya定理说的是一种特殊情况，若有m中颜色，每种颜色不限数量，则在G中的某个置换g下，保持不变的染色数= mk ，k为置换g的循环个数。

详细描述和证明可以参考组合数学，讲的很透彻，容易理解。

poj1286 Necklace of Beads
最简单的polya应用，旋转情况下置换的循环个数为gcd，翻转情况下分奇偶讨论。

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int main()
{
    int n;
    while(scanf("%d", &n), ~n)
    {
        if(!n)
        {
            printf("0\n");
            continue;
        }
        long long ans = 0;
        for(int i = 1; i <= n; i++)
            ans += pow(3, __gcd(i, n));
        if(n&1) ans += n * pow(3, n/2+1);
        else
        {
            ans += n / 2 * pow(3, n/2+1);
            ans += n / 2 * pow(3, n/2);
        }
        ans /= 2*n;
        printf("%lld\n", ans);
    }
    return 0;
}

hdu3923Invoker
还是polya，多了快速幂和取模处理

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int MOD = 1000000007;

LL fp(LL a, LL b)
{
    LL ans = 1;
    while(b)
    {
        if(b&1) ans = ans * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    for(int cas = 1; cas <= t; cas++)
    {
        int c, n;
        scanf("%d%d", &c, &n);
        if(!n)
        {
            printf("0\n");
            continue;
        }
        long long ans = 0;
        for(int i = 1; i <= n; i++)
        {
            ans += fp(c, __gcd(i, n));
            ans %= MOD;
        }
        if(n&1)
        {
            ans += n * fp(c, n/2+1);
            ans %= MOD;
        }
        else
        {
            ans += n / 2 * fp(c, n/2+1);
            ans %= MOD;
            ans += n / 2 * fp(c, n/2);
            ans %= MOD;
        }
        ans = ans * fp(2*n, MOD-2) % MOD;
        printf("Case #%d: %lld\n", cas, ans);
    }
    return 0;
}

uva10601 Cubes
正方体的变换比较复杂，恒等置换1种，绕对角点旋转4*2种，绕对边中点旋转6*1种，绕面中心旋转3*3种，一共24种。因为颜色数目有限，不能直接套用polya，只能burnside对每种置换用组合数讨论染色数。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;

int n;
int a[13], u[13];
LL c[13][13];

void init()
{
    memset(c, 0, sizeof(c));
    c[0][0] = 1;
    for(int i = 1; i <= 12; i++)
    {
        c[i][0] = 1;
        for(int j = 1; j <= i; j++)
            c[i][j] = c[i-1][j-1] + c[i-1][j];
    }
}
LL sol(int k)
{
    LL ret = 1;
    int tn = 0;
    for(int i = 0; i < n; i++)
    {
        if(u[i] % k)
            return 0;
        u[i] /= k;
        tn += u[i];
    }
    for(int i = 0; i < n; i++)
    {
        ret *= c[tn][u[i]];
        tn -= u[i];
    }
    return ret;
}
LL burnside()
{
    LL ans = 0;
    memcpy(u, a, sizeof(a));
    ans += sol(1);
    memcpy(u, a, sizeof(a));
    ans += 8 * sol(3);
    memcpy(u, a, sizeof(a));
    ans += 6 * sol(4);
    memcpy(u, a, sizeof(a));
    ans += 3 * sol(2);
    for(int i = 0; i < n; i++)
        for(int j = 0; j < n; j++)
            if(a[i] && a[j])
            {
                memcpy(u, a, sizeof(a));
                u[i]--;
                u[j]--;
                if(u[i] >= 0 && u[j] >= 0)
                    ans += 6 * sol(2);
            }
    ans /= 24;
    return ans;
}
int main()
{
    int t;
    init();
    scanf("%d", &t);
    while(t--)
    {
        memset(a, 0, sizeof(a));
        for(int i = 0; i < 12; i++)
        {
            int x;
            scanf("%d", &x);
            a[x]++;
        }
        sort(a, a+7, greater<int>());
        n = 0;
        while(a[n])
            n++;
        printf("%lld\n", burnside());
    }
    return 0;
}

POJ2154 Color polya+欧拉函数优化
n种颜色构成长度为n的环，不限颜色数，典型的polya，不过n的范围很大，不可能枚举每种旋转置换，可以用欧拉函数优化。
第i个旋转的置换循环个数为gcd(i,n)，可以看出gcd的种类数不会超过n的约数的个数，因为所有的gcd都是n的约数。
对于某一类gcd(i,n)=d的情况，i满足i%d=0&&gcd(i/d,n/d)=1，并且i<=n，所以循环个数为d的情况个数为n/d以内与n/d互质的数，即欧拉函数 ϕ(n/d) 。

ans=∑ni=1ngcd(i,n)n=∑d|nndϕ(n/d)n=∑d|nnd−1ϕ(n/d) 

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAXN = 33000;
int n, p;
int pri[MAXN];
bool prime[MAXN];

void init()
{
    int cnt = 0;
    memset(prime, true, sizeof(prime));
    for(int i = 2; i < MAXN; i++)
        if(prime[i])
        {
            pri[cnt++] = i;
            for(int j = i<<1; j < MAXN; j += i)
                prime[j] = false;
        }
}
int phi(int x)
{
    int ans = x;
    for(int i = 0; pri[i]*pri[i] <= x; i++)
        if(x % pri[i] == 0)
        {
            ans -= ans / pri[i];
            while(x % pri[i] == 0)
                x /= pri[i];
        }
    if(x > 1)
        ans -= ans / x;
    return ans%p;
}
int quickpow(int a, int b)
{
    int ans = 1;
    a %= p;
    while(b)
    {
        if(b&1) ans = ans * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return ans;
}
int main()
{
    int t;
    init();
    scanf("%d", &t);
    while(t--)
    {
        int ans = 0;
        scanf("%d%d", &n, &p);
        for(int i = 1; i*i <= n; i++)
            if(n % i == 0)
            {
                if(i*i==n)
                    ans = (ans + quickpow(n, i-1) * phi(i) % p) % p;
                else
                    ans = (ans + quickpow(n, i-1)*phi(n/i)%p + quickpow(n, n/i-1)*phi(i)%p) % p;
            }
        printf("%d\n", ans);
    }
    return 0;
}

POJ2888 Magic Bracelet burnside+矩阵快速幂求解+欧拉优化
m种颜色构成长度为n的环，颜色不限，但是有k种相邻限制。将相邻情况抽象成一个m*m矩阵M，能相邻为1，不能为0。在循环个数为d的某个置换下，对这d个循环的染色方案可以看成一条度为d的个数，合法路径数即为 Md 中对角线和。欧拉优化和上题POJ2154 Color 一样。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

const int MOD = 9973;
const int MAXN = 36000;

struct MAT
{
    int mat[13][13];
    MAT() {memset(mat, 0, sizeof(mat));}
};
MAT mp;
int m;
int pri[MAXN];
bool prime[MAXN];

void init()
{
    int cnt = 0;
    memset(prime, true, sizeof(prime));
    for(int i = 2; i < MAXN; i++)
        if(prime[i])
        {
            pri[cnt++] = i;
            for(int j = i<<1; j < MAXN; j += i)
                prime[j] = false;
        }
}
int phi(int x)
{
    int ans = x;
    for(int i = 0; pri[i]*pri[i] <= x; i++)
        if(x % pri[i] == 0)
        {
            ans -= ans / pri[i];
            while(x % pri[i] == 0)
                x /= pri[i];
        }
    if(x > 1)
        ans -= ans / x;
    return ans%MOD;
}

MAT mul(MAT a, MAT b)
{
    MAT ans;
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= m; j++)
            for(int k = 1; k <= m; k++)
                ans.mat[i][j] = (ans.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % MOD;
    return ans;
}
MAT matpow(MAT a, int b)
{
    MAT ans;
    for(int i = 1; i <= m; i++)
        ans.mat[i][i] = 1;
    while(b)
    {
        if(b&1) ans = mul(ans, a);
        a = mul(a, a);
        b >>= 1;
    }
    return ans;
}
int sol(int x)
{
    MAT c = matpow(mp, x);
    int ret = 0;
    for(int i = 1; i <= m; i++)
        ret = (ret + c.mat[i][i]) % MOD;
    return ret;
}
int qpow(int a, int b)
{
    int ans = 1;
    a %= MOD;
    while(b)
    {
        if(b&1) ans = ans * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return ans;
}
int main()
{
    int t;
    init();
    scanf("%d", &t);
    while(t--)
    {
        int n, k;
        scanf("%d%d%d", &n, &m, &k);
        for(int i = 1; i <= m; i++)
            for(int j = 1; j <= m; j++)
                mp.mat[i][j] = 1;
        while(k--)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            mp.mat[x][y] = mp.mat[y][x] = 0;
        }

        int ans = 0;
        int i;
        for(i = 1; i*i < n; i++)
            if(n % i == 0)
                ans = (ans + phi(i) * sol(n/i) + phi(n/i) * sol(i)) % MOD;
        if(i*i == n)
            ans = (ans + phi(i) * sol(i)) % MOD;
        ans = (ans * qpow(n, MOD-2)) % MOD;

        printf("%d\n", ans);
    }
    return 0;
}

HDU Birthday Toy burnside+矩阵找规律+欧拉优化
和上题POJ2888 Magic Bracelet 类似，多了个中间的节点，特殊考虑即可，ans = burnside(n, k-1) * k。
这题颜色种类数k很大，不能直接处理M矩阵，但可以看出M有规律，要求不能相同的颜色相邻，即M矩阵中对角线为0，其余为1。M的自幂矩阵中只有两个值，对角线上的x，和非对角线的y，并且x、y满足
xi=(m−1)∗yi−1,yi=xi−1+(m−2)∗yi−1,x0=1,y0=0
Md 的对角线和即为 xd∗m
最后注意除以n用逆元处理。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int MOD = 1e9+7;
const int MAXN = 36000;

struct MAT
{
    LL mat[3][3];
    MAT() {memset(mat, 0, sizeof(mat));}
};

int m = 2;
int pri[MAXN];
bool prime[MAXN];

void init()
{
    int cnt = 0;
    memset(prime, true, sizeof(prime));
    for(int i = 2; i < MAXN; i++)
        if(prime[i])
        {
            pri[cnt++] = i;
            for(int j = i<<1; j < MAXN; j += i)
                prime[j] = false;
        }
}
int phi(int x)
{
    int ans = x;
    for(int i = 0; pri[i]*pri[i] <= x; i++)
        if(x % pri[i] == 0)
        {
            ans -= ans / pri[i];
            while(x % pri[i] == 0)
                x /= pri[i];
        }
    if(x > 1)
        ans -= ans / x;
    return ans%MOD;
}

MAT mul(MAT a, MAT b)
{
    MAT ans;
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= m; j++)
            for(int k = 1; k <= m; k++)
                ans.mat[i][j] = (ans.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % MOD;
    return ans;
}
MAT matpow(MAT a, int b)
{
    MAT ans;
    for(int i = 1; i <= m; i++)
        ans.mat[i][i] = 1;
    while(b)
    {
        if(b&1) ans = mul(ans, a);
        a = mul(a, a);
        b >>= 1;
    }
    return ans;
}
LL sol(int k, int x)
{
    MAT ans;
    ans.mat[1][2] = k - 1;
    ans.mat[2][1] = 1;
    ans.mat[2][2] = k - 2;
    ans = matpow(ans, x);
    return ans.mat[1][1] * k % MOD;
}
LL qpow(LL a, LL b)
{
    LL ans = 1;
    a %= MOD;
    while(b)
    {
        if(b&1) ans = ans * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return ans;
}
LL burnside(int n, int k)
{
    LL ans = 0;
    int i;
    for(i = 1; i*i < n; i++)
        if(n % i == 0)
            ans = (ans + phi(i) * sol(k, n/i) + phi(n/i) * sol(k, i)) % MOD;
    if(i*i == n)
        ans = (ans + phi(i) * sol(k, i)) % MOD;
    ans = (ans * qpow(n, MOD-2)) % MOD;
    return ans;
}
int main()
{
    init();
    int n, k;
    while(~scanf("%d%d", &n, &k))
        printf("%lld\n", burnside(n, k-1) * k % MOD);
    return 0;
}
收录于
polya

当前文章被收录于：

polya
1 篇文章 0 人学习
订阅专栏 查看详情
标签
#polya定理 #burnside定理 #组合数学
本内容遵循 CC 4.0 BY-SA 版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Burnside引理和Polya定理详解（适合零基础） 声明：本知识点为帮助大家更好地理解置换群论这一抽象的内容，一些定义中掺杂了撰写者自身的理解，和严格的数学定义有些出入，基本为数学定义的缩小解释和限制解释。 另外，统一一些符号的使用。 对集合A，|A|表示A中元素的个数 对命题p，若为真，则[p]=1；若为假，则[p]=0。如[1>2]=0，[gcd(3,5)=1]=1 对一个群，e表示该群的单位元，g−1g^{-1}g−1表示群中元素ggg的逆元 =问题描述= 一个n个点的环，用n种颜色去染。求有多少种本质不同的染色方案。 两种染色方案相同当且仅当通 阅读详情

相关推荐

【组合数学】通俗解释 Burnside引理和Polya定理

文章目录Burnside引理和Polya定理Burnside引理定义：Burnside例子解释Polya定理 Burnside引理和Polya定理 对于图形来说，如果通过旋转，图像能达到其他图像的效果，这叫做本质上一样。 Burnside的目的是，我们能有多少种排列方案，求的是一个方案的数量num。 Burnside引理定义： 反正直接让我看这个定义…我是看不懂…所以还是直接上例子吧。 Burnside例子解释 所以！！！例子套用Burnside引理就是 L = (16+2+4+2)/4 =

火火的博客 3332

伯恩赛德定理（集合S的 置换群 诱导出来的等价关系 对集合S 划分 得到的 等价类个数）

前言：仅个人小记。 定理内容 由 S 的置换群 <G, >

Zetaa的博客 3750

Burnside引理与Polya定理

Burnside引理与Polya定理Burnside引理与Polya定理是有关组合数学的两条十分重要的定理（引理）,但是网上的一些资料大多晦涩难懂或者与实际并不相关联，因此在这里做一些浅显的解读，希望通过此文章可以让这两条定理（引理）能够发挥其作用。PS:引理与定理的区别:Ψ引理是数学中为了取得某个更好的定理而作为步骤被证明的命题,其意义并不在于自身被证明,而在于为达成最终定理作出贡献. Ψ一个引

This is Mendez. 4205

Burnside引理和polay计数学习笔记

本文参考自：https://blog.csdn.net/lyc1635566ty/article/details/52545355   首先由一个 2 * 2的矩阵里染色问题引出：   在一个 2 * 2的矩阵中染色，问有多少种染色方法，旋转后相同的算一种。   显然穷举的话，有以上种，但是不难发现，（2，3，4，5）是同一种，（6，7）是同一种，（8，9，10，11）是一种，（12，13，14...

桃夭丶的博客 418

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

前言正如大家所知，我是一个蒟蒻，所以我滚来学群论了QAQ 群论其实是个很厉害的东西，不知道比反演什么的简单到哪里去了。 啊，学渣苦，学渣累。——Friedrich Taylor什么是群？首先我们要知道什么是群。 群的定义：给定一个集合G={a,b,c,…}和集合上的二元运算”∗*”,满足以下四条性质： 1.封闭性：∀a,b∈G,∃c∈G,a∗b=c\forall a,b\in

Friedrich_Taylor的博客 1万+

Polya定理，Burnside引理

涉及到组合数学的问题，首先是群的概念： 设G是一个集合，*是G上的二元运算，如果(G,*)满足下面的条件： 封闭性：对于任何a,b∈G,有a*b∈G; 结合律：对任何a,b,c∈G有(a*b)*c=a*(b*c); 单位元：存在e∈G,使得对所有的a∈G,都有a*e=e*a=a; 逆元：对于每个元素a∈G,存在x∈G,使得a*x=x*a=e,这个时候记x为a-1，称为a的逆元，那么则称(

许增强 1万+

Burnside引理和Polya定理

首先谈一下我对置换群的理解（PS：写给没学过抽象代数的我们……）：置换群就是一些置换的集合，例如 (12233144)\begin{pmatrix} 1 & 2 & 3 & 4\\ 2 & 3 & 1 & 4 \end{pmatrix} 是一个置换，但不是一个置换群,置换只与每列的相对字符有关，与列顺序天关，比如(12233144)=(23123144)\begin{gather}\begin

geng4512的专栏 8713

Burnside定理 && Polya定理

学数论的上午注定是自闭的。 原作: By Lucky_Glass Burnside定理 主要是自己理解，简单的地方不多赘述。 置换 (f⋅g)(x)=f(g(x))(f\cdot g)(x)=f(g(x))(f⋅g)(x)=f(g(x)) 恒等置换 单位元：ι\iotaι 逆函数：f⋅f−1=ιf \cdot f^{-1} = \iotaf⋅f−1=ι 置换群 令定义在1−n1-n1−n上的所有置...

ICEEBBING的博客 602

Polya定理及例题

概念 先讲Burnside定理： 百度百科的传送门：https://baike.baidu.com/item/burnside%E5%BC%95%E7%90%86/1505996  再放一个例题：    重点还是Polya定理 百度百科的传送门：https://baike.baidu.com/item/Polya/11020869 Polya定理在Burnside定...

OneLine_的博客 8672

Polya 定理入门[Burnside引理,Polya定理,欧拉函数]

Burnside引理Burnside引理Burnside引理 L=1∣G∣∑i=1∣G∣D(ai)L=\frac{1}{|G|}\sum_{i=1}^{|G|}D(a_i)L=∣G∣1​i=1∑∣G∣​D(ai​) LLL: 本质不同的方案数. GGG: 置换群集合. aia_iai​: 置换群中的第 iii 个置换. D(ai)D(a_i)D(ai​): 进行 aia_iai​ 这个置换,...

Zbr162的博客 506

【算法讲27：Polya定理】BurnSide 引理 Polya定理 | 洛谷 P4980

【算法讲27：Polya定理】洛谷 P4980前置引入前置：BurnSideBurnSideBurnSide 引理Polya 定理回到题目代码 注：下文证明都略，只记录重要的性质结论 前置 群，置换 下文的记号： ggg 置换 GGG 置换集 ∣G∣|G|∣G∣ 置换集大小 (a,b,c,⋯ )(a,b,c,\cdots)(a,b,c,⋯) 一个置换 引入 洛谷 P4980 一个串，上面有 NNN 个珠子，用 NNN 种颜色给它染色 求有多少个本质不同的染色方案 本质相同：可以通过旋转，让两串珠子

溢流眼泪的博客 758

群论-Burnside引理与Polya定理 三千字

偶数个点时，有过两点对称轴和不过点对称轴两种，前者n/2个置换，每个置换包含(n/2+1)个循环((n-2)/2+2)，后者n/2个置换，每个置换n/2个循环。奇数个点时，对称轴有n条，长度为2的循环（翻转轴两侧必须相同）有(n-1)/2,长度为1的，对称轴穿过点有1个，共计(n+1)/2个循环，有n个置换,m种颜色，故。对于一个置换f，若一个元素s经过该置换后不变，则称s为f的不动点，记f不动点个数为C(f),则（置换群）所有（方案数）置换等价类个数为所有C(f)的平均值。................

jisuanji2606414的博客 1254

Polya定理与Burnside引理及其应用

Polya定理及其应用群与置换群 群与置换群 群是近世代数的一个概念，简单的说，群就是集合配运算，如果运算满足： 封闭性 结合性 双元存在（即幺元和逆元） 例如：全体偶数集合配上算术加法就构成一个群。而全体偶数集合配上算术乘法就不是一个群。 置换群是非常重要的一类群。首先介绍置换，假设有(1,...,n)(1,...,n)(1,...,n)的数，将其变为(a1,...,an)(a_1,...,a_n)(a1​,...,an​)，其中aia_iai​只能在[1,n][1,n][1,n]中取值且不重复，这种

RBS的专栏 1219

Burnside引理和Polya定理简单入门

不学这个定理，真是亏死了…… 见到那种对称（循环）的计数题都不知道该怎么做…… 先表明一下，本人没有群论基础。 所以，有关群论的概念，我只会提“置换”。 对于初学者来说，这可能是更加容易理解的方法吧。 更加严谨的网上博客一大堆。 例子 给你一个长度为nnn的环，有mmm种颜色，每个点可以染成任意颜色。 循环同构的环算是同一种方案（为方便讨论就先不考虑翻转）。 问有多少种方案。 以下以这个例子作...

A1847225889的博客 406

ACM_置换群 burnside引理 Polya定理

置换群也是群论当中一个比较重要的内容，可是在离散课上老师直接跳过了这章内容我也是……(日了dog了)，自己看了半天资料总算是有点眉目了。 1.置换群：…… 2.burnside引理：…… 3.Pólya定理：……

RaAlGhul的博客 6654
上一篇： ACM集训队论文合集
下一篇： poj1185炮兵阵地【状压dp】
点赞 1
评论 0
书签 书签 1
lhfl911
lhfl911
博客等级 码龄11年 13粉丝 76原创
+ 关注 专栏目录 订阅专栏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值