polya/burnside定理入门

最新推荐文章于 2023-12-08 18:06:50 发布

lhfl911

最新推荐文章于 2023-12-08 18:06:50 发布

阅读量1.6k

点赞数 1

分类专栏： polya 文章标签： polya定理 burnside定理组合数学

本文链接：https://blog.csdn.net/lhfl911/article/details/52743085

版权

polya 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

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

首先将旋转、翻转之类的变换都转变为一个置换，构成一个置换群G。
简单来说，burnside定理就是 非等价染色数 = 在G中单个置换下保持不变的染色数的平均数。
而polya定理说的是一种特殊情况，若有m中颜色，每种颜色不限数量，则在G中的某个置换g下，保持不变的染色数= $m^k$ ，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互质的数，即欧拉函数 $\phi(n/d)$ 。

a n s = \sum n i = 1 n g c d ( i , n ) n = \sum d | n n d ϕ ( n / d ) n = \sum d | n n d - 1 ϕ (n / d)

$ans =\frac{\sum_{i=1}^nn^{gcd(i,n)}}{n} = \frac{\sum_{d|n}n^d\phi(n/d)}{n} = \sum_{d|n}n^{d-1}\phi(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的个数，合法路径数即为 $M^d$ 中对角线和。欧拉优化和上题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满足
$x_i = (m-1)*y_{i-1}, y_i = x_{i-1} + (m-2)*y_{i-1}, x_0=1,y_0=0$
$M^d$ 的对角线和即为 $x_d*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;
}