polya定理小结

最新推荐文章于 2023-12-22 15:11:07 发布
最新推荐文章于 2023-12-22 15:11:07 发布
阅读量745 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_ma/article/details/52549422
版权

polya定理主要是解决那些什么手镯，项链旋转翻转的问题
先要知道它旋转翻转一共有多少种情况，最后要除一下
翻转简单，主要是旋转，旋转就是找有多少个循环
一个循环，就是你旋转之后，这些循环里的珠子互相置换
所以对于同一个循环，颜色应该一样
如果有x个循环，m个颜色，那么方案就是xm
对于旋转i格，那么循环个数就是gcd(i,n)
如果n特别大，那么就不能枚举i了，就要枚举因子，然后还要求欧拉函数
对于有限制的情况，如果明确给出了限制，那么直接矩阵快速幂优化，因为一般这样颜色不会多
如果不给出明确限制，就说相邻的颜色不一样，然后颜色又很多的话，就要推公式了
推完公式然后继续矩阵快速幂优化

poj 2154
裸题，就是要求欧拉函数的，并且n个珠子n个颜色，最后不能乘n的逆元，因为不互质，所以前面要除掉n

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           40005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const LL     mod   = 998244353;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

bool prime[MAX];
int pr[MAX];
int tot;

void init(){
    mem(prime,0);
    tot=0;
    for(int i=2;i<MAX;i++){
        if(!prime[i]){
            for(int j=i*i;j<MAX;j+=i) prime[j]=1;
            pr[tot++]=i;
        }
    }
}
int p;
int qpow(int a,int n){
    int ans=1;
    while(n){
        if(n&1) ans=ans*a%p;
        a=a*a%p;
        n>>=1;
    }
    return ans;
}

int phi(int x){
    int ans=1;
    for(int i=0;i<tot&&pr[i]*pr[i]<=x;i++){
        if(x%pr[i]==0){
            ans*=(pr[i]-1);
            x/=pr[i];
            while(x%pr[i]==0){
                x/=pr[i];
                ans*=pr[i];
            }
        }
    }
    if(x!=1) ans*=(x-1);
    return ans%p;
}
int main(){
    int t;
    cin>>t;
    init();
    while(t--){
        int n;
        cin>>n>>p;
        int ans=0;
        for(int i=1;i*i<=n;i++){
            if(n%i==0){
                ans=(ans+qpow(n%p,i-1)*phi(n/i)%p)%p;
                if(n/i!=i) ans=(ans+qpow(n%p,n/i-1)*phi(i)%p)%p;
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

poj 2888
有限制条件，颜色少，直接矩阵，然后特判n=1的时候是m，循环个数是x，矩阵快速幂x次，从第一个到第x+1个，因为第一个和x+1个都是一个循环的开头，所以要同色，所以，直接加同色的就行，并且能保证x和x+1满足条件限制。所以这样算的话n=1的时候要特判呢

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           40005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const LL     mod   = 9973;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

bool prime[MAX];
int pr[MAX];
int tot;

void init(){
    mem(prime,0);
    tot=0;
    for(int i=2;i<MAX;i++){
        if(!prime[i]){
            for(int j=i*i;j<MAX;j+=i) prime[j]=1;
            pr[tot++]=i;
        }
    }
}

struct Matrix{
    int n;
    LL maze[maxnode][maxnode];
    void init(int n){
        this->n=n;
        mem(maze,0);
    }

    Matrix operator * (Matrix &rhs){
        Matrix m;
        m.init(n);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    m.maze[i][j]=m.maze[i][j]+maze[i][k]*rhs.maze[k][j];
                }
                m.maze[i][j]%=mod;
            }
        }
        return m;
    }
}A;

LL qpow(Matrix a,LL n){
    Matrix ans;
    ans.init(a.n);
    for(int i=0;i<ans.n;i++) ans.maze[i][i]=1;
    while(n){
        if(n&1) ans=ans*a;
        a=a*a;
        n>>=1;
    }
    LL sum=0;
    for(int i=0;i<ans.n;i++) sum=(sum+ans.maze[i][i])%mod;
    return sum;
}

LL phi(int x){
    int ans=1;
    for(int i=0;i<tot&&pr[i]*pr[i]<=x;i++){
        if(x%pr[i]==0){
            x/=pr[i];
            ans*=(pr[i]-1);
            while(x%pr[i]==0){
                x/=pr[i];
                ans*=pr[i];
            }
        }
    }
    if(x!=1) ans*=(x-1);
    return ans%mod;
}
LL cal(int x){
    return qpow(A,x);
}

LL ppow(LL a,LL n){
    LL ans=1;
    while(n){
        if(n&1) ans=ans*a%mod;
        a=a*a%mod;
        n>>=1;
    }
    return ans;
}
int main(){
    int t;
    cin>>t;
    init();
    while(t--){
        int n,m,k;
        cin>>n>>m>>k;
        A.init(m);
        for(int i=0;i<m;i++){
            for(int j=0;j<m;j++) A.maze[i][j]=1;
        }
        for(int i=0;i<k;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            A.maze[a-1][b-1]=0;
            A.maze[b-1][a-1]=0;
        }
        if(n==1){
            cout<<m<<endl;
            continue;
        }
        LL ans=0;
        for(int i=1;i*i<=n;i++){
            if(n%i==0){
                ans=(ans+cal(i)*phi(n/i)%mod)%mod;
                if(n/i!=i) ans=(ans+cal(n/i)*phi(i)%mod)%mod;
            }
        }
        cout<<ans*ppow(n,mod-2)%mod<<endl;
    }
    return 0;
}

hdu 2865
限制条件是相邻的不同色，颜色特别大，不能直接矩阵，所以可以直接推导公式，推完之后再矩阵，循环个数x，要保证x和第一个不同色。
别忘了中间那个珠子

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           40005
#define   MAXN          1000005
#define   maxnode       3
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-8;
const LL     mod   = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

bool prime[MAX];
int pr[MAX];
int tot;

void init(){
    mem(prime,0);
    tot=0;
    for(int i=2;i<MAX;i++){
        if(!prime[i]){
            for(int j=i*i;j<MAX;j+=i) prime[j]=1;
            pr[tot++]=i;
        }
    }
}

struct Matrix{
    int n;
    LL maze[maxnode][maxnode];
    void init(int n){
        this->n=n;
        mem(maze,0);
    }

    Matrix operator * (Matrix &rhs){
        Matrix m;
        m.init(n);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++)
                    m.maze[i][j]=(m.maze[i][j]+maze[i][k]*rhs.maze[k][j])%mod;
            }
        }
        return m;
    }
}A;

LL k;
LL qpow(Matrix a,LL n){
    Matrix ans;
    ans.init(a.n);
    for(int i=0;i<ans.n;i++) ans.maze[i][i]=1;
    while(n){
        if(n&1) ans=ans*a;
        a=a*a;
        n>>=1;
    }
    LL f3=(k*(k-1)%mod)*(k-2)%mod;
    LL f2=k*(k-1)%mod;
    return (ans.maze[0][0]*f3+ans.maze[0][1]*f2)%mod;
}

LL phi(int x){
    int ans=1;
    for(int i=0;i<tot&&pr[i]*pr[i]<=x;i++){
        if(x%pr[i]==0){
            x/=pr[i];
            ans*=(pr[i]-1);
            while(x%pr[i]==0){
                x/=pr[i];
                ans*=pr[i];
            }
        }
    }
    if(x!=1) ans*=(x-1);
    return ans%mod;
}

LL cal(int x){
    if(x==1) return 0;
    if(x==2) return k*(k-1)%mod;
    return qpow(A,x-3);
}

LL ppow(LL a,LL n){
    LL ans=1;
    while(n){
        if(n&1) ans=ans*a%mod;
        a=a*a%mod;
        n>>=1;
    }
    return ans;
}
int main(){
    init();
    int n;
    while(cin>>n>>k){
        A.init(2);
        k=k-1;
        A.maze[0][0]=k-2;A.maze[0][1]=k-1;
        A.maze[1][0]=1;A.maze[1][1]=0;
        LL ans=0;
        for(int i=1;i*i<=n;i++){
            if(n%i==0){
                ans=(ans+cal(i)*phi(n/i)%mod)%mod;
                if(n/i!=i) ans=(ans+cal(n/i)*phi(i)%mod)%mod;
            }
        }
        cout<<(ans*ppow(n,mod-2)%mod)*(k+1)%mod<<endl;
    }
    return 0;
}
Miracle_ma
关注
Burnside引理和Polya定理
geng4512的专栏
01-23 8461
首先谈一下我对置换群的理解（PS：写给没学过抽象代数的我们……）：置换群就是一些置换的集合，例如 (12233144)\begin{pmatrix} 1 & 2 & 3 & 4\\ 2 & 3 & 1 & 4 \end{pmatrix} 是一个置换，但不是一个置换群,置换只与每列的相对字符有关，与列顺序天关，比如(12233144)=(23123144)\begin{gather}\begin
polya计数学习小结
xiaohuan1991的专栏
09-25 8343
最近半个月以来一直在看《组合数学》，马马虎虎也算翻完了，理解的也很浅，接下来的一个月中，我将把主要精力放在做数学题上同时巩固总结这一 个月以来所学的数论组合数学知识。那就先从Polya计数法开始吧。 Burnside定理： 首先介绍一下有关置换群的一些知识。 置换： 设
Polya定理小结
tulunta
04-12 163
转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 最近接触了Polya计数定理，建议之前先去学习置换群。 只会皮毛，深层定理含义及证明一般书上都有。 http://poj.org/problem?id=2409 赤裸裸的Polya啊，数据范围很小，直接枚举i，对于旋转每个转换的循环节长度为g...
polya定理
weixin_33753845的博客
04-03 126
这就是所谓的polya定理。具体去百度文库看论文。 POJ 1286Necklace of Beads 题意：用3种颜色给圆上n个点染色。问你有多少种染色方法。 做法：旋转有n个置换，对称也有n个置换。然后对于旋转，暴力找出循环节；对称，根据n是奇数还是偶数分开来求，循环节就根据对称来求。然后套上polya定理就好了 1 #include <iostream> ...
POJ 1286-Necklace of Beads（Polya定理-旋转+翻转 串项链）
Some.
04-18 892
Necklace of Beads Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 8298   Accepted: 3467 Description Beads of red, blue or green colors are connected together
POJ 2409-Let it Bead（Polya定理-旋转+翻转 串项链）
Some.
04-18 893
Let it Bead Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 5895   Accepted: 3950 Description "Let it Bead" company is located upstairs at 700 Cannery Row in
【POJ - 2409 && POJ - 1286 】 【polya定理】【旋转 or 翻转 详解】
lzs_lazy
11-11 478
这两个题目就是一个题目。 题意: 有一个长度为n的项链，现在给m个颜色的珠子，每种的珠子个数都是无限个，现在问你能够做成几个本质不同的项链（如果两个项链不能够通过旋转或者翻转达到相同，则认为本质不同） 。 在做这个题目之前最好把群相关的知识点看看。 分析 ： 现在给了两种操作可能使项链相同 , 翻转和旋转。 我们一个个来分析。1 》 旋转 首先旋转的话，可能会旋转一个珠子，旋转两个珠子，
polya小结 更新中....
08-01 570
Burnside定理 pku 2154 Color    burnside是一种计数方法，用来计算含有不等价类的数量， 简单说就是对于每个置换 fi ，他都对一定量的着色无效（该着色经过fi置换不变），设这些着色数量为ai，  所有ai的平均数就是不等价类的数量， 当然也可以变换求和顺序， 先考虑每中着色， 再求他的稳定核， 但一般情况是置换数很少， 着色数很多， 所以前者很常用
怎样解题 Polya
11-13
### 小结 通过上述对 Polya 解题法的详细介绍，我们可以看出这种方法论的核心在于引导人们从不同角度思考问题，并通过系统化的方式去解决问题。这种思维方式不仅能够帮助我们在数学学习中取得更好的成绩，也能在...
江苏省大学生程序设计竞赛（JSCPC）赛后感
fancy的专栏
05-09 1410
仔细的算了一下，这是我第6次参加与acm有关的比赛了，每一次的经历，在我看来都是一次对自己能力的认识与评估，身边学计算机专业的同龄人对这项比赛的热爱，专注，勇气以及所获得的成就让要好好努力，更要加倍付出。我要再努力点，再专注点，虽然我还是不太满意自己目前的状态和解题能力，但是最后一年了，我愿意继续与acmicpc走完这最后一年的征途。我希望在最后这一年为自己的acmicpc比赛收获一枚奖牌！ 来
Polya定理
Owen_hzt的专栏
12-24 641
burnside引理： 在一个置换群上的等价类为：(1 / n) * sigma(一个置换的不动点个数) 对于旋转的问题，暴力统计要枚举每种置换，则循环节长度为(n, i)，可以发现只要枚举n的约数k，统计后乘上phi(n / k)即可。 对于翻折是和奇偶有关, 通常有ans[n] = (1/2) * (f[n] + f[ floor(n + 1 / 2) ])，有时需根据奇偶分类处理。
【组合数学】Pólya 计数理论
最新发布
恭仔的博客
12-22 2373
Pólya 计数理论与Burnside 引理介绍及应用。
组合数学--Polya 原理及典型应用
weixin_30553837的博客
07-15 355
Redfield-Polya （Pólya enumeration theorem，简称PET）定理是组合数学理论中最重要的定理之一．自从 1927 年 Redfield 首次运用 group reduction function 概念，现在称之为群的循环指标（circle index of a group），至今 60 多年来，他在许多实际计数问题上得到了广泛的应用，它以置换群为理论基础，...
Polya定理，Burnside引理
热门推荐
许增强
04-19 1万+
涉及到组合数学的问题，首先是群的概念： 设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的逆元，那么则称(
Burnside引理和polay计数学习小记
whyorwhnt的专栏
09-17 1410
跟数学有关的东西总是非常神奇。 Burnside引理和polay计数学习小记 - Only the Strong Survive - 博客频道 - CSDN.NET Polya定理_百度文库 Chap4-2Burnside引理、Polya定理_百度文库 polya 定理小结 （转）_jiazheng2222的空间_百度空间
polya定理再小结
08-01 585
转自：http://www.cppblog.com/sdfond/archive/2010/02/06/107403.aspx 话说ICPC的题目是越来越难，因为经典的算法大家都知道了，因此出题的方向只能是要么把模型隐藏的很深，要么就把一系列算法知识综合起来考察，这个时候分析问题的能力和灵活运用知识的能力就显得尤为重要。 　　polya定理在很久以前的ICPC题目中就已经出现过，不过那个时候大
polya 定理小结 （转）及 相应练习
Stay hungry,stay foolish!
03-13 917
转载自：http://hi.baidu.com/lewutian/blog/item/95421b8205fd7f81f703a600.html http://hi.baidu.com/lewutian polya定理是组合数学中比较难的一部分。首先需要对置换群、集合论有一定的了解，这样有助于理解burnside引理的证明。其次，polya定理只 是对于在环上存在旋转、反射等等价的变换的一种计
Polya定理在组合计数中的应用
"Polya定理模板用于解决组合计数问题，常与动态规划结合使用。它可以高效地计算不同颜色涂染项链的种类数，考虑旋转和翻转的不同定义。通常涉及置换群理论和Burnside引理，但具体内容在算法模板中不详述。在编程实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值