POLYA合集

最新推荐文章于 2020-06-08 01:03:48 发布
最新推荐文章于 2020-06-08 01:03:48 发布
阅读量797 收藏
点赞数
分类专栏： 数论 文章标签： polya 费马小定理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/30283623
版权

hdu 4633 Who's Aunt Zhang

polya计数，费马小定理

分为以下几种循环节：

初始态；对面旋转；对点旋转；对棱旋转

幸好题目规模不大，肉眼完全可以数出来

#include<cstdio>
#include<algorithm>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int mod = 10007;
int k;
int mpower(int b, int a)
{
	int res = 1, p = b;
	while (a)
	{
		if (a & 1) res = res*p%mod;
		p = p*p%mod;
		a >>= 1;
	}
	return res;
}
int cal()
{
	int res = 0;
	res += mpower(k, 54+8+12);
	res += mpower(k, 3+3+9+3+2)*3;
	res += mpower(k, 5+5+18+6+4)*3;
	res += mpower(k, 3+3+9+3+2)*3;
	res += mpower(k, 27+7+4)*6;
	res += mpower(k, 18+4+4)*4;
	res += mpower(k, 18+4+4)*4;
	res %= mod;
	return res*mpower(24, mod-2)%mod;
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int t, cs = 1;
	scanf("%d", &t);
	while (t--)
	{
		printf("Case %d: ", cs++);
		scanf("%d", &k);
		printf("%d\n", cal());
	}
	return 0;
}

hdu 3441 Rotation

即便是借鉴了别人的思路，还是费了不少力气。
新学到了利用欧拉函数优化环形polya计数的方法
若数据庞大，分解质因子后搜索可大幅提升效率 
#include<cstdio>
#include<algorithm>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef __int64 ll;
const ll mod = 1000000007;
const int MAXN = 32000;
bool isPrime[MAXN] = {false};
ll prime[MAXN], res, color, all, ssm;
int np = 0;
void init()
{
    for (int i = 2; i< MAXN; ++i)
    {
        if (!isPrime[i]) 
            prime[np++] = i;
        for (int j = 0; j<np && prime[j]*i< MAXN; ++j)
        {
            isPrime[prime[j]*i] = true;
            if (i % prime[j] == 0) break;
        }
    }
}

ll mpower(ll b, ll a)
{
    ll res = 1, p = b%mod;    // 失误点：b可能大于mod 
    while (a)
    {
        if (a & 1) res = res*p%mod;
        p = p*p%mod;
        a >>= 1;
    }
    return res;
}
ll getTran(ll a, ll c)
{
    const ll ny = mpower(4, mod-2);
    if (a & 1)
    {
        return (mpower(c, a*a) + mpower(c, (a*a+3)>>2)*2%mod
            + mpower(c, (a*a+1)>>1))*ny%mod;
    }
    else
    {
        return (mpower(c, a*a) + mpower(c, (a*a)>>2)*2%mod + mpower(c, (a*a)>>1))*ny%mod;
    }
}
ll fact[100], fenjie[100][2];
int nfac, nfen;
void addFac(ll aa)    // 失误点：本例中素数未全部列出 
{
    for (int i = 0; i< np && prime[i]*prime[i] <= aa; ++i)
    {
        while ( aa % prime[i] == 0) aa /= prime[i], fact[nfac++] = prime[i];
    }
    if (aa != 1) fact[nfac++] = aa;
}
void dfs2(int idx, ll x, ll sa, ll sb, ll a, ll c)
{
    if (idx == nfen)
    {
        ll k = a / x; 
        ssm = (ssm + mpower(c, k)*(x/sa*sb%mod)%mod)%mod;
    }
    else
    {
        ll cn = 0, p = fenjie[idx][1], q = fenjie[idx][0];
        for ( ; cn <= p; ++cn)
        {
            if (cn == 0) dfs2(idx+1, x, sa, sb, a, c);
            else dfs2(idx+1, x, sa*q, sb*(q-1), a, c);
            x *= q;
        }
    }
}
void dfs(int idx, ll b)
{
    if (idx == nfen)
    {
        ll ncol = getTran(b, color);
        ll k = (all*all-1)/b/b;
        ssm = 0;
        dfs2(0, 1, 1, 1, k, ncol);
        ssm = ssm*mpower(k, mod-2)%mod;
        res = (res + ssm)%mod;
    }
    else
    {
        ll cn = 0, s = fenjie[idx][1];
        for ( ; cn <= s; )
        {
            fenjie[idx][1] -= cn;            
            dfs(idx+1, b);
            fenjie[idx][1] += cn;
            cn += 2;
            b *= fenjie[idx][0];
        }
    }
}
ll solve()
{
    res = 0;
    nfac = 0;
    nfen = 0;
    addFac(all-1); addFac(all+1);
    sort(fact, fact + nfac);
    fenjie[0][0] = fact[0]; fenjie[0][1] = 1;
    for (int i = 1; i< nfac; ++i)
    {
        if (fact[i] == fact[i-1])
        {
            fenjie[nfen][1]++;
        }
        else
        {
            nfen++;
            fenjie[nfen][0] = fact[i];
            fenjie[nfen][1] = 1;
        }
    }
    nfen++;
    dfs(0, 1);
    return res*color%mod;
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t, cs = 0;
    init();
    scanf("%d", &t);
    while (t--)
    {
        printf("Case %d: ", ++cs);
        scanf("%I64d%I64d", &all, &color);
        if (all == 1) printf("%I64d\n", color);
        else
            printf("%I64d\n", solve());
    }
    return 0;
}

hdu 3547 DIY Cube

Java的大数用着就是爽 
import java.math.BigInteger;
import java.util.Scanner;

public class Main
{
	static Scanner cin = new Scanner(System.in);
	public static void main(String[] args)
	{
		final BigInteger mod = BigInteger.valueOf(10).pow(15);
		int t = 0, cs = 1;
		t = cin.nextInt();
		while ((t--) != 0)
		{
			System.out.print("Case "+(cs++)+": ");
			BigInteger c = cin.nextBigInteger(), p;
			BigInteger sum = BigInteger.valueOf(0), cnt = BigInteger.valueOf(24);
			p = c.pow(8);
			sum = sum.add(p);
			p = c.pow(2).multiply(BigInteger.valueOf(6));
			sum = sum.add(p);
			p = c.pow(4).multiply(BigInteger.valueOf(17));
			sum = sum.add(p);
			sum = sum.divide(cnt);
			
			if (sum.compareTo(mod) > 0)
			{
				sum = sum.mod(mod);
				String msString = sum.toString();
				for (int i = msString.length(); i < 15; ++i)
					System.out.print(0);
			}		
			System.out.println(sum);			
		}
	}
}


hdu 2865 Birthday Toy

polya及其优化，组合数学
对于每种置换，不变的着色方案数的计算 可转化为 环着色，根据题意
为n个节点的环着m种颜色且相邻节点颜色不同的方案数为：(m-1)^a + (-1)^n * ((m-1)^3 - m*(m-1)*(m-2))
需要注意的是若n == 1，则方案数为0（题目的特殊性质决定） 
#include<cstdio>
#include<algorithm>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef __int64 ll;
const ll mod = 1000000007;
const int MAXN = 32000;
bool isPrime[MAXN] = {false};
ll prime[MAXN], np = 0;
ll nn, mm;
void initPrime()
{
	for (int i = 2; i< MAXN; ++i)
	{
		if(!isPrime[i]) prime[np++] = i;
		for (int j = 0; j<np && i*prime[j]<MAXN; ++j)
		{
			isPrime[i*prime[j]] = true;
			if (i % prime[j] == 0) break;
		}
	}
}
ll npow(ll a, ll b)
{
	ll res = 1, p = a%mod;
	while (b)
	{
		if (b & 1) res = res*p%mod;
		p = p*p % mod;
		b >>= 1;
	}
	return res;
}
ll fenzi[100][2];
int nfen;
void divide(ll a)
{
	for (int i = 0; i< np && prime[i]*prime[i] <= a; ++i)
	{
		if (a % prime[i] == 0)
		{
			fenzi[nfen][0] = prime[i]; fenzi[nfen][1] = 0;
			while (a % prime[i] == 0)
			{
				a /= prime[i];
				fenzi[nfen][1]++;
			}
			nfen++;
		}
	}
	if (a != 1)
	{
		fenzi[nfen][0] = a; fenzi[nfen++][1] = 1;
	}
}
ll resAll;
ll getCircle(ll m, ll n)
{
	ll res;
	if (n == 1) return 0;
	if (n == 2) return m*(m-1)%mod;
	res = (npow(m-1, 3) - m*(m-1)%mod*(m-2)%mod)%mod;
	res = n&1?-res:res;
	res = (res + mod)%mod;
	res = (res + npow(m-1, n)) % mod;
	return res;
}
void dfs(int i, ll p1, ll p2, ll x)
{
	if (i == nfen)
	{
		ll t = nn/x;
		resAll = (resAll + getCircle(mm-1, t)*(x/p1*p2%mod)%mod)%mod;		
	}else
	{
		int cnt = 0, p = fenzi[i][1], q = fenzi[i][0];
		for ( ;cnt <= p; ++cnt)
		{
			if (!cnt) dfs(i+1, p1, p2, x);
			else dfs(i+1, p1*q, p2*(q-1), x);
			x *= q;
		}
	}
}
ll solve()
{
	nfen = 0;
	resAll = 0;
	divide(nn);
	dfs(0, 1, 1, 1);
	return resAll*npow(nn, mod-2)%mod*mm%mod;
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
    initPrime();
    while (scanf("%I64d%I64d", &nn, &mm) != EOF)
    {
		printf("%I64d\n", solve());
    }
    return 0;
}


hdu 5080 Colorful Toy

核心是找出置换群，所以先找中心，再根据置换的步数暴力搜索 
#include <stdio.h>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
typedef long long LL;
const int MAXN = 55;
const LL MOD = 1e9+7;
const double eps = 1e-8, PI = acos(-1.0);
inline int zero(double a)
{
    return (a>eps) - (a<-eps);
}
struct _Point
{
    double x, y;
    double angle, dis;
    _Point (double x=0.0, double y=0.0) {this->x=x; this->y=y;}
    bool operator == (const _Point & a) const
    {
        return !zero(x-a.x) && !zero(y-a.y);
    }
    void getDis()
    {
        dis = sqrt(x*x + y*y);
    }
    _Point rota(double ag)
    {
        return _Point(dis*cos(angle+ag), dis*sin(angle+ag));
    }
} pt[MAXN], center;
bool mmp[MAXN][MAXN];
int n, m, c;
int P[MAXN], cnt, Permt[MAXN], np;
bool cmp(const int a, const int b)
{
    if (zero(pt[a].angle - pt[b].angle) != 0) return pt[a].angle < pt[b].angle;
    return (pt[a].dis) < (pt[b].dis);
}
int check_pt()
{
    double rs = pt[Permt[P[0]]].angle - pt[P[0]].angle;
    for (int i = 0; i< cnt; ++i)
    {
        if (!(pt[Permt[P[i]]] == pt[P[i]].rota(rs)))
            return 0;
    }
    return 1;
}
int check_link()
{
    for (int i = 0; i< n; ++i)
    {
        for (int j = 0; j< n; ++j)
            if (mmp[i][j] != mmp[Permt[i]][Permt[j]]) return 0;
    }
    return 1;
}
bool vis[MAXN];
LL mpow(LL a, LL b)
{
    LL res = 1, p = a;
    while (b)
    {
        if (b & 1) res = res*p%MOD;
        p = p*p%MOD;
        b >>= 1;
    }
    return res;
}
LL solve()
{
    int ans = 0;
    memset(vis, 0, sizeof vis);
    for (int i = 0; i<n; ++i)
    {
        if (!vis[i])
        {
            ++ans;
            for (int tp=i; !vis[tp]; tp = Permt[tp])
                vis[tp] = 1;
        }
    }
    return mpow(c, ans);
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
#endif // ONLINE_JUDGE
    int t, u, v;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d%d", &n, &m, &c);
        center.x = center.y = 0.0;
        for (int i = 0; i< n; ++i)
            scanf("%lf%lf", &pt[i].x, &pt[i].y), center.x += pt[i].x, center.y += pt[i].y;
        center.x /= n;
        center.y /= n;
        cnt = 0;
        for (int i = 0; i< n; ++i)
        {
            pt[i].x -= center.x;
            pt[i].y -= center.y;
            pt[i].getDis();
            if (pt[i] == center)
            {
                Permt[i] = i;
                continue;
            }
            pt[i].angle = atan2(pt[i].y, pt[i].x);
            P[cnt++] = i;
        }
        sort(P, P+cnt, cmp);
        memset(mmp, 0, sizeof mmp);
        for (int i = 0; i< m; ++i)
        {
            scanf("%d%d", &u, &v);
            --u; --v;
            mmp[u][v] = mmp[v][u] = 1;
        }
        LL res = 0LL;
        np = 0;
        for (int i = 0; i< cnt; ++i)  // 转过i个单位
        {
            for (int j = 0; j< cnt; ++j)
                Permt[P[j]] = P[(i+j)%cnt];
            if (check_pt() && check_link())
            {
                ++np;
                res = res + solve();
            }
        }
        cout<<res*mpow(np,MOD-2)%MOD <<endl;
    }
    return 0;
}





deprecated_tzg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Polya问题
上善若水
02-09 627
Polya问题给定红色和蓝色给八个棋子涂色，求所有的涂色方案，其中某种方案可以通过旋转到另一种，则这两种方案视作一种。研一组合数学讲的波利亚定义，旋转轮换的内容。如果用代码解决，可以将八个棋子视作二进制的8位。那么如果不考虑条件所说的旋转算一做，那理论上有255种不同的方案。同样是筛选法的思想，假设现在一共255种方案，那么遍历这些方案，对某种方案循环左移8次（8次后肯定会回到相同的位置），循环左移
Polya定理Polya定理Polya定理
11-09
Polya定理 Polya定理是组合数学中用来计算全部互异的组合状态的个数的一个十分高效、简便的工具。下面，我就向大家介绍一下什么是Polya定理以及它的应用。 Polya定理的基本概念： 1. 群：群是一个满足封闭性、...
（组合数学笔记）Pólya计数理论_Part.8_Pólya定理的几种扩展
zorchp
06-08 471
介绍Pólya定理的一些扩展，包括直和、Cartes(笛卡尔)积和2-子集上的扩展。
POLYA合集 II
solotzg
07-05 630
hdu 2481 Toy
polya计数
qq_17080419的博客
09-03 216
Let it Bead POJ 2409 #include <iostream> #include <algorithm> #include <cstdio> #include <queue> #include <vector> #include <set> #include <map> #include <...
polya 定理总结
taotao 的大学墓志
11-16 592
公式　用cc 种颜色对　nn 个置换群G1,G2,…,GnG_1,G_2,\dots ,G_n着色,设每个置换群的循环节数为kik_i那么不同的着色总数 PG=1|G|∑ni=1ckiP_G = \frac{1}{|G|}\sum_{i=1}^n c^{k_i}常见置换群循环节总结 循环群 比如nn 颗珠子的项链，考虑绕中心旋转重合视为相同. 那么共有　nn 个循环群，其中每个循环群为:
Polya定理模板
Eiffel的博客
07-27 570
相信很多初学者刚接触Polya定理的时候一脸懵逼，因为它以许多离散数学的知识为基础，所以不太好上手，所以我在这里把模板贴出来。 Polya定理是用来求出m种颜色涂入n个对象一共有多少种方法的一种定理。 暴力版模板 #include #include #include using namespace std; typedef long long LL; int gcd(in
Polya计数
逐梦者
07-10 1869
ACM模版Polya计数/* * c种颜色的珠子，组成长为s的项链，项链没有方向和起始位置 */ int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }int main(int argc, const char * argv[]) { int c, s; while (cin >> c >> s) {
Polya计数原理小记
纵无涯
12-28 1152
Polya计数原理小记 Polya计数原理： 证明：emmm我不会 1)只有旋转（平面内旋转最小单位角度 360° / n, 一共n种旋转方案，第i种方案的旋转角度 i * 360° / n, 其循环节为 gcd(n,i) ） 使用欧拉函数的原因: 对于大多数i,gcd（n，i）值相同都是n的约数，当n比较大的时候转而用sqrt(n)的复杂度枚举n的约数。 For(d | n){ temp +...
polya计数回顾
grandpi的专栏
11-03 480
burnside引理设G=g1,g2...gkG={g_1,g_2...g_k}是[1,n]上的置换群，令c(gi)c(g_i)表示置换gig_i下不动点的个数，那么G将[1,n]划分为等价类>的个数是： l=1|G|∑j=1|G|c(gi) l = \frac{1}{|G|}{\sum_{j=1}^{|G|}{c(g_i)}}即是说，等价类个数等于不动点个数的均值。 如果存在gig_i将gi(
组合polya定理
11-28
关于组合数学很详细的ppt，描述了polya定理，清晰易懂
Polya定理以及知识点详解
02-19
Pólya原理是组合数学中，用来计算全部互异的组合状态的个数的一个十分高效、简便的工具。下面，我就向大家介绍一下什么是Pólya原理以及它的应用。请先看下面这道例题： 【例题1】 对2*2的方阵用黑白两种颜色涂色...
polya定理模板
11-15
polya是组合数学中用来计数的，要结合动态规划使用
hdu 2243 考研路茫茫——单词情结
solotzg
07-16 810
矩阵快速幂、幂相加是重点 还设计到一些ac自动机的dp #include #include #include using namespace std; typedef unsigned long long ULL; const int MAXN = 60; const int szGP = MAXN*MAXN*(sizeof (ULL)); struct tire { int
hdu 4610 Cards （分解质因数）
solotzg
08-28 794
数学推导，快速求素数，模拟 #include #include #include #include #include using namespace std; typedef long long ll; const int MAXN = 4000010; /** n = a0^b0 * a1*b1 * a2^b2 * a3^b3 ...... a均为素数 因子数
hdu 4565 So Easy!
solotzg
06-06 708
数学推导，矩阵快速幂 题目连接。。。 题目涉及n次方，自然想到用矩阵的快速幂来简化操作，把根号的部分和整数部分分开考虑，不难得出矩阵 [a,b; 1,a]，初始的数为[a,1] 但是这样一来最后的结果中就要涉及开根号，由于在矩阵幂运算中要mod m ，所以开根号后肯定会出错。 幸好网上有大神提供了一种猜想，即整数部分和带根号的部分向上取整的值相同，证明了下，还真是这样。。。 [(a+
数论合集 I
solotzg
05-08 691
由题意可以得出将U和I都转化为I的方法
OI竞赛中的群论基础：Burnside引理与Polya定理
"OI群论入门，讲解Burnside引理和Polya定理，适用于初学者" 群论是抽象代数的一个重要分支，它研究的是满足特定运算规则的数学对象——群。群的概念广泛应用于数学的各个领域，如几何、代数、数论以及计算机科学中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值