hdu-5868 Different Circle Permutation 矩阵快速幂 + 欧拉函数 + polya计数定理

题意：

给n个点，构成一个环，每个点可染黑或白色，要求染色方案中任意两个相邻的点不能都为黑色，问在旋转同构意义下的染色方案数。

解析：

设f(n)为不考虑旋转同构时n个点的方案数（其实不考虑旋转同构就**套路成序列了吧），有f(n)=f(n-1)【第n个为白色】+f(n-2)【第n为黑色】

这个可以用矩阵快速幂logn求1次f(n). 

、

放着不管，去分析问题的套路：

先看

burnside   引理（对于一个置换f，若一个着色方案s经过置换后不变，称s为f的不动点。将f的不动点数目记为C(f)，则可以证明等价类数目为所有C(f)的平均值。此结论称为 burnside 引理


那么对于原问题首先当然是有n种旋转方式，我们来求第i种的不动点数目。
对于第i种旋转方式，可以知道这个置换写成循环的形式，将会有gcd(i,n)个循环（并且循环内颜色一致），拿出每一个循环来考虑，单个循环代表一种颜色的话，要使得置换i满足题目要求： 黑色点(人)不可相邻，白点(空位)随意，我们可以这样：  

假设循环内部已经合法(颜色一致)的话,那么我们怎么才能拼出一个合法的置换呢，其实只要把每个循环看成一个数，这几个循环的排列合法即可，如果x个循环，则该置换的合法情况有f（x）种，（即之前提到的f(x)）也就是f( gcd(i,n) )
  
所以所有的等价类个数应该是 ∑(f( gcd(i,n) ))/n   ( 1<=i<=n)

      这个式子可以优化一下：

 

那么我们枚举n的约数，顺便求个欧拉。（n范围1e9）

f(d)的话是个斐波那契数列，矩阵快速幂搞，欧拉暴力搞

因为d个数大概不超过sqrt(n)嘛，

因此暴力搞复杂度不过是  n^（4/3）

注意的是递推f(d)时，

  if (x==1) return 1;
    if (x==2) return 3;
    if (x==3) return 4;

这个有点诡异，3和2可以算出，1的话得逆推，（直接算你会发现f(1)可以=2按照定义。

最后答案要特判n==1。

城市套路深···············

参考代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#include <iostream>
using namespace std;
typedef long long ll;
ll  mod=1000000000+7;

struct Matrix
{
    long long mat[2][2];
} ;
Matrix unit_matrix ;
ll k=2;
long long powe_m(long long  a,long long  b )
{
    long long ans=1;
    long long tmp=a;
    while(b!=0)
    {
        if (b&1)
            ans=ans*tmp%mod;
        tmp=tmp*tmp%mod;
        b=b>>1;
    }
    return ans;
}
Matrix mul(Matrix a, Matrix b) //矩阵相乘
{
    Matrix res;
    for(int i = 0; i < k; i++)
        for(int j = 0; j < k; j++)
        {
            res.mat[i][j] = 0;
            for(int t = 0; t < k; t++)
            {
                res.mat[i][j] += a.mat[i][t] * b.mat[t][j];
                res.mat[i][j] %= mod;
            }
        }

    return res;
}

Matrix pow_matrix(Matrix a, long long m)  //矩阵快速幂
{
    Matrix res = unit_matrix;
    while(m != 0)
    {
        if(m & 1)
            res = mul(res, a);
        a = mul(a, a);
        m >>= 1;
    }
    return res;
}



int prim[10005];
int ok;
void ff(ll n)
{
    for (ll i=1; i*i<=n; i++)
    {
        if (n%i==0)
        {
            prim[++ok]=i;
            if (i*i!=n) prim[++ok]=n/i;
        }
    }
}
ll ela(ll n)
{
    ll ans=n;
    for(ll i=2; i*i<=n; i++)
    {
        if (n%i==0)
        {
            ans=ans-ans/i;
            n/=i;
            while(n%i==0)
                n/=i;
        }
    }
    if (n!=1)
        ans=ans-ans/n;
    return ans;
}


ll get( ll x)   //fib(x)
{
    if (x==1) return 1;
    if (x==2) return 3;
    if (x==3) return 4;
    Matrix ori;
    ori.mat[0][0]=3;
    ori.mat[0][1]=1;
    ori.mat[1][0]=0;
    ori.mat[1][1]=0;
    Matrix c;
    c.mat[0][0]=1;
    c.mat[0][1]=1;
    c.mat[1][0]=1;
    c.mat[1][1]=0;
    Matrix ans = pow_matrix(c, x-2);
    ans = mul(ori,ans);
    return ans.mat[0][0];
}
int main()
{
    for(int i = 0; i < k; i++)
        for(int j = 0; j < k; j++)
            unit_matrix.mat[i][j] = 0;
    for(int i = 0; i < k; i++)
        unit_matrix.mat[i][i] = 1;
    ll n;
    while(scanf("%lld",&n)!=EOF)
    {

        if (n==1)           //特判1
        {
            printf("2\n");
            continue;
        }
        ok=0;
        ff(n);
        sort(prim+1,prim+1+ok);
        ll ans=0;
        for (int i=1; i<=ok; i++)
        {
            ll tmp= get(prim[i]) * ela(n/prim[i])%mod ;
            ans=(ans+tmp)%mod;
        }
        ans=ans*powe_m(n,mod-2)%mod;
        printf("%lld\n",(ans+mod)%mod );
    }

    return 0;

}