【组合数学_Polya专辑】

最新推荐文章于 2023-04-18 18:35:09 发布
最新推荐文章于 2023-04-18 18:35:09 发布
阅读量192 收藏 1
点赞数
分类专栏： ACM_阶段性总结 全部博客 ACM_数学系列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshi250hua/article/details/7847851
版权

    这几天家里事多，回家了一趟，利用在家的空余时间的看了下polya定理。

    之前的好几次比赛都碰到这种类型的题目，都跪了，长跪不起。现在拿起了《组合数学》从尾向头很功利地开始看，断断续续地把polya计数那章看完o艹，神级定理啊....又看了1遍似懂非懂，之后就开始研究例题，慢慢地就了解到它的皮毛。

    polya定理N(G,C)=sum{|C(f)|}*（1/|G|)(对于每一个f属于G),这句话的意思是C中不等价的计数等于通过G中的置换保持不变的计数的平均数。

    Polya计数问题有步骤可循：1、仔细看题目，建立模型

                             2、找出各个置换群

                             3、统计结果

  

  1、Hdu 3547 DIY Cube 在纸上仔细地找置换群，发现有24种，分别是不动置换、绕面面旋转±90°、绕面面旋转180°、绕棱棱旋转180°、绕点点旋转±120.最后的出来的公式(n^8+17*n^4+6*n^2)/24，再套个高精度模版就可以0msAC之。

   2、Uva 10601 CUBES  和上一题相似但更难些。置换也是24个，分别是不动置换、绕面面旋转±90°、绕面面旋转180°、绕棱棱旋转180°、绕点点旋转±120.然后利用置换中的循环长度，比如有四对对角顶点，那么绕点点旋转就有4种，每种旋转又分+120°和-120°，这两类旋转循环  都是3，循环个数为4个，这2个数字代表的意思是3条颜色相同的边要有四坨，然后用题目给的颜色算组合个数。

    3、Uva 11255  用三种颜色a,b,c组成长度为n=a+b+c的项链，旋转、翻转的项链都算同一种，问我们能组合几种。旋转的时候循环长度为gcd(i,n),i表示移动i步，设len=gcd(i,n),循环个数m = n/len,意义同上题最后一句描述，算法也大同小异。然后是翻转，翻转要判断a+b+c的奇偶，奇数 的时候以任意一个珠子为对称轴翻转,len=2,m=(n-1)/2，偶数的时候有两种情况，一种是以两颗对角的珠子为对称轴len=2,m=(n-2)/2，一种是以某两个珠子的中间为对称轴,len=2,m=n/2。总置换个数为2 * n;

    4、Hdu 2923 Invoker 问用m种颜色的珠子组成长度为n的项链的方案数，旋转和翻转都要考虑在内。置换分析和上题大同小异，但这题要用乘法逆元，去网上抄个模版就好了。这题我写了详细的解题报告，用到各种模版，见Here

    5、Hdu 4187 Alphabet Soup 给定一个圆环上的n个点，圆环被分成360000度，点的位置由角度确定。然后用m种材料来填充这些点，某方案与它旋转的方案同构，问不同构的方案数。先对角度排序，然后取相邻两个点的间隔进行kmp找到循环节长度和循环节个数，之后转化为项链计数问题，好题，解题报告见Here

    6、Zoj 2344 Toral Tickets  给定一张有n*m个格子的纸，每个格子有黑白两种颜色可以染。现在先将纸按长边粘起来得到一个圆柱，再将纸按短边拈起来得到一个游泳圈。如果两种染色方案卷起来后是一样的，那么它们同构。分两类讨论，n！=m时，滚动置换n*m个，旋转置换n*m个，n==m时，滚动置换n*m个，旋转置换3*n*m个，解题报告见Here

一些写得比较好的文章:

http://www.cppblog.com/sdfond/archive/2010/02/06/107403.aspx

http://endlesscount.blog.163.com/blog/static/82119787201221324524202/


3代码

#include <stdio.h>
#include <string.h>
#define MAX 41
#define int64 unsigned long long//__int64


int n,m,cnt[10],temp[10];
int64 c[MAX][MAX],ans;


void Initial() {

	for (int i = 0; i < MAX; ++i) {
	
		c[i][0] = c[i][i] = 1;
		for (int j = 1; j < i; ++j)
			c[i][j] = c[i-1][j] + c[i-1][j-1];
	}
}
int Gcd(int n,int m) {

	int r = n % m;
	while (r) {

		n = m,m = r;
		r = n % m;
	}
	return m;
}
int64 Calculate(int n,int m) {
	//n是循环个数，m是循环长度即必须要有m个珠子颜色一样
	int64 i,j,ans = 1;
	for (i = 1; i <= 3; ++i) {
		
		if (temp[i] % m) return 0;
		temp[i] /= m;
		ans *= c[n][temp[i]];
		n -= temp[i];
	}


	return ans;
}
int64 Polya() {

	int i,j,m;
	ans = 0;
	memcpy(temp,cnt,sizeof(cnt));
	ans += Calculate(n,1);


	for (i = 1; i < n; ++i) {

		m = Gcd(n,i);
		memcpy(temp,cnt,sizeof(cnt));
		ans += Calculate(m,n/m);
	}

	if (n % 2 == 1) {

		for (j = 1; j <= 3; ++j) {
		
			memcpy(temp,cnt,sizeof(cnt));
			temp[j]--;
			if (temp[j] < 0) continue;
			ans += n * Calculate((n-1)/2,2);
		}
	}
	else {

		memcpy(temp,cnt,sizeof(cnt));
		ans += n / 2 * Calculate(n/2,2);
		for (i = 1; i <= 3; ++i)
			for (j = 1; j <= 3; ++j) {
				
				memcpy(temp,cnt,sizeof(cnt));
				temp[i]--,temp[j]--;
				if (temp[j] < 0 || temp[i] < 0) continue;
				ans += n / 2 * Calculate((n-2)/2,2);
			}
	}
	

	return ans / 2 / n;
}


int main()
{
	int i,j,k,t;
	Initial();


	scanf("%d",&t);
	while (t--) {

		for (n = 0,i = 1; i <= 3; ++i)
			scanf("%d",&cnt[i]),n += cnt[i];
		ans = Polya();
		printf("%llu\n",ans);
	}
}
/*
2
2 2 2
3 2 1
*/

2代码

#include <stdio.h>
#include <string.h>
#define MAX 13
#define int64 __int64


int64 ans;
int cnt[MAX],temp[MAX];
int64 c[MAX][MAX];



void Initial() {

	for (int i = 0; i <= 12; ++i) {

		c[i][0] = c[i][i] = 1;
		for (int j = 1; j < i; ++j)
			c[i][j] = c[i-1][j] + c[i-1][j-1];
	}
}
int64 Calculate(int n,int m) {
	//计算组合数，比如n=6，m=2
	//temp[1] = 12，经第一个循环后变成temp[1] = 6
	//那么ans = c[n][6]等于1种
	int64 i,j,k,ans = 1;
	for (i = 1; i <= 6; ++i) {

		if (temp[i] % m != 0)
			return 0;
		temp[i] /= m;
                ans *= c[n][temp[i]];
		n -= temp[i];
	}

	
	return ans;
}
int64 Still_Replace() {

	int64 ans = 0;
	memcpy(temp,cnt,sizeof(cnt));	//不动置换
	ans += Calculate(12/1,1);
	memcpy(temp,cnt,sizeof(cnt));   //面面旋转90或270
	ans += 3 * 2 * Calculate(12/4,4);
	memcpy(temp,cnt,sizeof(cnt));   //面面旋转180
	ans += 3 * 1 * Calculate(12/2,2);
	return ans;
}
int64 Vertex_Replace() {

	int64 ans = 0;
	memcpy(temp,cnt,sizeof(cnt));	//绕对角顶点120或240
	ans += 4 * 2 * Calculate(12/3,3);
	return ans;
}
int64 Edge_Replace() {

	int64 ans = 0;
	for (int i = 1; i <= 6; ++i)
		for (int j = 1; j <= 6; ++j) {
									//绕对角棱中点旋转

180
			memcpy(temp,cnt,sizeof(cnt));	
			if (temp[i] == 0 || temp[j] == 0)
				continue;
			temp[i]--,temp[j]--;
			ans += 6 * Calculate(10/2,2);
		}
	return ans;
}
int64 Polya() {

	ans = 0;
	ans +=  Still_Replace();
	ans +=   Edge_Replace();
	ans += Vertex_Replace();
	return ans/24;
}


int main()
{
	int i,j,k,t;
	Initial();


	scanf("%d",&t);
	while (t--) {

		memset(cnt,0,sizeof(cnt));
		for (i = 1; i <= 12; ++i) {

			scanf("%d",&k);
			cnt[k]++;
		}


		ans = Polya();
		printf("%lld\n",ans);
	}
}


 

1代码
#include<iostream> 
#include<string> 
#include <stdio.h>
using namespace std; 

#define MAXN 9
#define MAXSIZE 10
#define DLEN 1

class BigNum
{ 
public: 
	int a[150];    //可以控制大数的位数 
	int len;       //大数长度
public: 
	BigNum(){ len = 1;memset(a,0,sizeof(a)); }   //构造函数
	BigNum(const int);       //将一个int类型的变量转化为大数
	BigNum(const char*);     //将一个字符串类型的变量转化为大数
	BigNum(const BigNum &);  //拷贝构造函数
	BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

	friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
	friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

	BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算 
	BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算 
	BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算 
	BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

	BigNum operator^(const int  &) const;    //大数的n次方运算
	int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算    
	bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
	bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

	void print();       //输出大数
}; 
BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
{ 
	int c,d = b;
	len = 0;
	memset(a,0,sizeof(a));
	while(d > MAXN)
	{
		c = d - (d / (MAXN + 1)) * (MAXN + 1); 
		d = d / (MAXN + 1);
		a[len++] = c;
	}
	a[len++] = d;
}
BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
{
	int t,k,index,l,i;
	memset(a,0,sizeof(a));
	l=strlen(s);   
	len=l/DLEN;
	if(l%DLEN)
		len++;
	index=0;
	for(i=l-1;i>=0;i-=DLEN)
	{
		t=0;
		k=i-DLEN+1;
		if(k<0)
			k=0;
		for(int j=k;j<=i;j++)
			t=t*10+s[j]-'0';
		a[index++]=t;
	}
}
BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
{ 
	int i; 
	memset(a,0,sizeof(a)); 
	for(i = 0 ; i < len ; i++)
		a[i] = T.a[i]; 
} 
BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
{
	int i;
	len = n.len;
	memset(a,0,sizeof(a)); 
	for(i = 0 ; i < len ; i++) 
		a[i] = n.a[i]; 
	return *this; 
}
istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
{
	char ch[MAXSIZE*4];
	int i = -1;
	in>>ch;
	int l=strlen(ch);
	int count=0,sum=0;
	for(i=l-1;i>=0;)
	{
		sum = 0;
		int t=1;
		for(int j=0;j<4&&i>=0;j++,i--,t*=10)
		{
			sum+=(ch[i]-'0')*t;
		}
		b.a[count]=sum;
		count++;
	}
	b.len =count++;
	return in;

}
ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
{
	int i;  
	cout << b.a[b.len - 1]; 
	for(i = b.len - 2 ; i >= 0 ; i--)
	{ 
		cout.width(DLEN); 
		cout.fill('0'); 
		cout << b.a[i]; 
	} 
	return out;
}

BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
{
	BigNum t(*this);
	int i,big;      //位数   
	big = T.len > len ? T.len : len; 
	for(i = 0 ; i < big ; i++) 
	{ 
		t.a[i] +=T.a[i]; 
		if(t.a[i] > MAXN) 
		{ 
			t.a[i + 1]++; 
			t.a[i] -=MAXN+1; 
		} 
	} 
	if(t.a[big] != 0)
		t.len = big + 1; 
	else
		t.len = big;   
	return t;
}
BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算 
{  
	int i,j,big;
	bool flag;
	BigNum t1,t2;
	if(*this>T)
	{
		t1=*this;
		t2=T;
		flag=0;
	}
	else
	{
		t1=T;
		t2=*this;
		flag=1;
	}
	big=t1.len;
	for(i = 0 ; i < big ; i++)
	{
		if(t1.a[i] < t2.a[i])
		{ 
			j = i + 1; 
			while(t1.a[j] == 0)
				j++; 
			t1.a[j--]--; 
			while(j > i)
				t1.a[j--] += MAXN;
			t1.a[i] += MAXN + 1 - t2.a[i]; 
		} 
		else
			t1.a[i] -= t2.a[i];
	}
	t1.len = big;
	while(t1.a[len - 1] == 0 && t1.len > 1)
	{
		t1.len--; 
		big--;
	}
	if(flag)
		t1.a[big-1]=0-t1.a[big-1];
	return t1; 
} 

BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算 
{ 
	BigNum ret; 
	int i,j,up; 
	int temp,temp1;   
	for(i = 0 ; i < len ; i++)
	{ 
		up = 0; 
		for(j = 0 ; j < T.len ; j++)
		{ 
			temp = a[i] * T.a[j] + ret.a[i + j] + up; 
			if(temp > MAXN)
			{ 
				temp1 = temp - temp / (MAXN + 1) * (MAXN + 1); 
				up = temp / (MAXN + 1); 
				ret.a[i + j] = temp1; 
			} 
			else
			{ 
				up = 0; 
				ret.a[i + j] = temp; 
			} 
		} 
		if(up != 0) 
			ret.a[i + j] = up; 
	} 
	ret.len = i + j; 
	while(ret.a[ret.len - 1] == 0 && ret.len > 1)
		ret.len--; 
	return ret; 
} 
BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
{ 
	BigNum ret; 
	int i,down = 0;   
	for(i = len - 1 ; i >= 0 ; i--)
	{ 
		ret.a[i] = (a[i] + down * (MAXN + 1)) / b; 
		down = a[i] + down * (MAXN + 1) - ret.a[i] * b; 
	} 
	ret.len = len; 
	while(ret.a[ret.len - 1] == 0 && ret.len > 1)
		ret.len--; 
	return ret; 
}
int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算    
{
	int i,d=0;
	for (i = len-1; i>=0; i--)
	{
		d = ((d * (MAXN+1))% b + a[i])% b;  
	}
	return d;
}
BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
{
	BigNum t,ret(1);
	int i;
	if(n<0)
		exit(-1);
	if(n==0)
		return 1;
	if(n==1)
		return *this;
	int m=n;
	while(m>1)
	{
		t=*this;
		for( i=1;i<<1<=m;i<<=1)
		{
			t=t*t;
		}
		m-=i;
		ret=ret*t;
		if(m==1)
			ret=ret*(*this);
	}
	return ret;
}
bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
{ 
	int ln; 
	if(len > T.len)
		return true; 
	else if(len == T.len)
	{ 
		ln = len - 1; 
		while(a[ln] == T.a[ln] && ln >= 0)
			ln--; 
		if(ln >= 0 && a[ln] > T.a[ln])
			return true; 
		else
			return false; 
	} 
	else
		return false; 
}
bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
{
	BigNum b(t);
	return *this>b;
}

void BigNum::print()    //输出大数
{ 
	int i = 14 < len - 1? 14 : len - 1;   
	__int64 ans = 0,p = 1;
	for (; i >= 0;--i)
		printf("%d",a[i]);
	printf("\n");
}
int main(void)
{
	int i,n,t,cas = 0;


	scanf("%d",&t);
	while(t--){

		scanf("%d",&n);
		BigNum x(n),y;
		BigNum a(17),b(6);
		y = x ^ 8;
		y = y + a * (x ^ 4);
		y = y + b * (x ^ 2);
		y = y / 24;
		//x = (x^8 + a * x ^ 4 + b * x ^ 2) / 24;
		printf("Case %d: ",++cas),y.print();
	}
}













































                

        

        

    




    

      

        

            

              
                
                  ZeroClock
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    1
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
组合数学常用内容——Polya定理+Burnside引理

				
			

			

				

					tick_tock97的博客
				

				

					05-07
					
					3030
					
				

			

		

		

			
				
Burnside引理设G是N{1,2，.....，n}上的置换群，G在N上可引出不同的等价类（在置换群中有置换的都等价），其不同的等价类的个数为LL=1/|G|*（c1(a1)+...c1(ai)...+c1(ag)）c1表示置换ai作用过后不变的方案数，也就是置换中循环节长度是1的循环个数（N中的元素是组合方案的序号不是自然数！此置换群是关于所有着色图像（所有可能的情况）集合N的置换）

			
		

	



                

              
                



	

		

			

				
					
组合数学中的Polya定理

				
			

			

				

					weixin_33970449的博客
				

				

					08-03
					
					209
					
				

			

		

		

			
				
polya定理是组合数学中比较难的一部分。首先需要对置换群、集合论有一定的了解，这样有助于理解burnside引理的证明。其次，polya定理只 是对于在环上存在旋转、反射等等价的变换的一种计数方法，实际的题目中很多需要其他的知识来进行辅助。
环上的计数主要就是处理置换 -> 着色这种情况。很关键的一点是同一循环内着色相同。因此很多题目就在置换和着色上下文章。
最最简单的polya定理题...

			
		

	



                


  
              

                


	

		

			

				
					
组合数学及其应用——polya计数

				
			

			

				

					weixin_30763455的博客
				

				

					08-03
					
					343
					
				

			

		

		

			
				
在处理类似下面的问题中，一般的计数方法会出现问题：假如你要用红、蓝两种颜色给一个正四面体的四个顶点着色，试问存在多少种不同的着色方案？
 在高中我们常用的方法是模拟涂色过程，分情况讨论，然后基于分步乘法原理。但是在那里没有考虑几何体通过旋转等操作带来的对称性，在本文中，我们就来介绍一种专门处理这类问题的工具——Polya计数。

 首先我们要做的是引入一些基本的概念。
 置...

			
		

	





	

		

			

				
					
组合数学_第4章_Polya定理

					
最新发布

				
			

			

				

					CSDN博客
				

				

					04-18
					
					345
					
				

			

		

		

			
				
给定一个集合Gabc⋯Gabc⋯和集合GGG上的二元运算“⋅\cdot⋅”，并满足下列4个条件：封闭性：若ab∈Ga,b \in Gab∈G，则存在c∈Gc \in Gc∈G，使得，a⋅bca⋅bc结合律：对于任意的abc∈Gabc∈G，恒有a⋅b⋅ca⋅b⋅ca⋅b⋅ca⋅b⋅cGGG中存在一个元素eee，使得对于GGG的任意元素aaa，恒有a⋅。

			
		

	



		

			
		



	

		

			

				
					
普通涂色问题  组合数学-Polya定理

				
			

			

				

					LUCKYOJ
				

				

					11-11
					
					1万+
					
				

			

		

		

			
				
Polya定理是组合数学理论中最重要的定理之一。该定理是要解决这样的问题，在一个集合内，定义了一个等价关系，人们往往关心由这个等价关系所决定的等价类的数目。


Polya定理：
    设有n个对象，G是这n个对象上的置换群，用m种颜色涂染这n个对象，每个对象涂染一种颜色。若一种染色方案在群G的作用下变为另一种方案，则这两种方案当作是一种方案。那么存在的方案个数为：L=∑mc(ai)/|

			
		

	





	

		

			

				
					
第五章_Polya定理1

				
			

			

				

					08-03
				

			

		

		

			
				
4. **Pólya计数定理**：这个定理是组合数学中的一个重要结果，用于计算具有对称性的结构的不同排列或组合数。它考虑了群在集合上作用时的固定点、轨道等概念，使得在计算复杂计数问题时能够简化处理。  5. **自同构...

			
		

	





	

		

			

				
					
组合数学习题答案

				
			

			

				

					10-13
				

			

		

		

			
				
组合数学是离散数学的一个重要分支，主要研究有限集合中元素的不同组合方式。在这个主题下，我们关注的是从一个集合中选择元素的各种方法，而不仅仅是排列。姜建国版的西电组合数学讲义是一个深入探讨这个领域的重要...

			
		

	





	

		

			

				
					
中科大 组合数学 期末考试 2020秋季学期

				
			

			

				

					01-18
				

			

		

		

			
				
### 中科大组合数学2020秋季学期期末考试知识点概览  #### 一、教材P67例2类型的题目  此类题目考察的是学生对于**排列组合基础理论**的应用能力。具体来说，这类题目通常涉及如何计算特定条件下元素的排列或组合...

			
		

	





	

		

			

				
					
组合数学引论课件

				
			

			

				

					06-05
				

			

		

		

			
				
《组合数学引论课件》是由北京邮电大学数学系提供的教育资源，主要基于中国科学技术大学出版的《组合数学引论》第二版。这套课件详细介绍了组合数学的基础理论与应用，旨在帮助学习者深入理解这一领域的核心概念。...

			
		

	





	

		

			

				
					
清华大学组合数学

				
			

			

				

					09-24
				

			

		

		

			
				
【清华大学组合数学】课程涵盖了多个核心的组合数学概念，这些概念在计算机科学、数学以及其他相关领域都有着广泛的应用。以下是对每个文件名所对应知识点的详细解释：  1. **C08鸽巢原理**：又称抽屉原理，是组合...

			
		

	





	

		

			

				
					
组合数学 - 波利亚定理 --- poj : 2154 Color

				
			

			

				

					weixin_34293059的博客
				

				

					09-12
					
					192
					
				

			

		

		

			
				
 Color




Time Limit: 2000MS
 
Memory Limit: 65536K


Total Submissions: 7873
 
Accepted: 2565




Description
Beads of N colors are connected together into a circular necklace of N...

			
		

	





	

		

			

				
					
ACM中的【数学知识】之【组合数学】（一） Polya定理的简单理解  POJ 1286

				
			

			

				

					under_sky_dxj的博客
				

				

					07-09
					
					1883
					
				

			

		

		

			
				
因为数学渣，Polya定理不是很清楚，但其实际操作大概如下。

解释下上图。
N个位置，K种颜色放置。
x1,x2,x3,x4,……，xn
（x1,x2,x3……xn)∈{1 2 3 4 …… K}
则
放置总数为上图
|G| 是【所有的（被定义的）置换（也就是变化的方式）】的个数
——被定义就是说，某变化为M，任意情况A经过变化M变为B，A和B算作同一种情况。
k就是K
c

			
		

	





	

		

			

				
					
sgu 208 Toral Tickets polya定理

				
			

			

				

					weixin_30682127的博客
				

				

					03-19
					
					101
					
				

			

		

		

			
				
题意：给你N和M，对于一个N*M的单面方格纸你可以对它的每个个格子黑白染色，然后把方格纸的长边卷起来，卷成一个圆柱体，然后再把两个短边形成的圆也接起来，形成一个游泳圈的形状（我们染的色只在游泳圈的外表面）。如果对于两种黑白染色方案，通过卷成这样的游泳圈后，是一样的，则这两种方案也是一样的。给定N，M<=20 ，求染色方案总数.
思路：polya定理
.当n!=m时，每一列上下可以滚动，每...

			
		

	





	

		

			

				
					
【转】波利亚酒鬼回家定理的证明

				
			

			

				

					pymqq的专栏
				

				

					02-26
					
					4939
					
				

			

		

		

			
				
证明定理：喝醉的酒鬼总能找到回家的路，喝醉的小鸟则可能永远也回不了家。

假设有一条水平直线，从某个位置出发，每次有 50% 的概率向左走1米，有50%的概率向右走1米。按照这种方式无限地随机游走下去，最终能回到出发点的概率是多少？答案是100% 。在一维随机游走过程中，只要时间足够长，我们最终总能回到出发点。
现在考虑一个喝醉的酒鬼，他在街道上随机游走。假设整个城市的街道呈网格状分布，酒鬼每走到

			
		

	





	

		

			

				
					
染色问题(n个格子，3种颜色)

				
			

			

				

					系统运维
				

				

					03-23
					
					3499
					
				

			

		

		

			
				
有排成一行的ｎ个方格，用红(Red)、粉(Pink)、绿(Green)三色涂每个格子，每格涂一色，要求任何相邻的方格不能同色，且首尾两格也不同色．求全部的满足要求的涂法.

递推公式：
A1 = 3
A2 = 6 //A(3,2)=6
A3 = 6 //A(3,3)=6
An=2*A(n-2)+A(n-1), n&gt;=4

证明：
考虑第n-1个格子:
1. 如果这个格子和...

			
		

	





	

		

			

				
					
前缀和--BZOJ-4972 小Q的方格纸

				
			

			

				

					unintended
				

				

					08-23
					
					654
					
				

			

		

		

			
				
小Q的方格纸有n行m列，一共n*m个方格，从上到下依次标记为第1,2,...,n行，从左到右依次标记为第1,2,...,m列，方便起见，小Q称第i行第j列的方格为(i,j)。小Q在方格纸中填满了数字，每个格子中都恰好有一个整数a_{i,j}。



小Q一共会给出q个询问，每次给定一个方格(x,y)和一个整数k(1
将三角形化为梯形和矩形的和，差。
先用前缀和计算梯形、矩形的和即可。


			
		

	





	

		

			

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

				
			

			

				

					火火的博客
				

				

					12-03
					
					2499
					
				

			

		

		

			
				
文章目录Burnside引理和Polya定理Burnside引理定义：Burnside例子解释Polya定理
Burnside引理和Polya定理

对于图形来说，如果通过旋转，图像能达到其他图像的效果，这叫做本质上一样。
Burnside的目的是，我们能有多少种排列方案，求的是一个方案的数量num。

Burnside引理定义：


反正直接让我看这个定义…我是看不懂…所以还是直接上例子吧。

Burnside例子解释



所以！！！例子套用Burnside引理就是 L = (16+2+4+2)/4 =

			
		

	





	

		

			

				
					
【DP_背包专辑】【10.14最新更新】

					
热门推荐

				
			

			

				

					
				

				

					06-07
					
					1万+
					
				

			

		

		

			
				
这短时间看了论文《背包九讲》，看到背包问题解法中的优美之处也看到背包问题在现实中的应用，总结出一句话：背包问题值得一看。
    背包问题可以概括为这样的模型：有若干种选择，每种选择有一定的代价和价值，做某些选择会得到特定的状态，问我们在约定的条件下怎么得到特定的状态？这里的状态可以是代价和或者价值和或者由其他这两者组合而来的状态。这类问题需要枚举每种状态，但是可以通过动态规划减少枚举的次数，提

			
		

	





	

		

			

				
					
组合数学问题的求解方法和Polya原理概述

				
			

			

				

					
				

			

		

		

			
				
在组合数学中，有一些重要的概念和方法，如Polya原理和置换群等，用于解决各种组合问题。组合问题有很多不同的解题方法，但基本上可以分为常规方法和非常规方法。  常规方法是从组合学的基本概念和原理出发，根据...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值