HDU5868-Different Circle Permutation【Burnside】【欧拉函数】

在马大爷的指导下，再加上看了 http://blog.csdn.net/viphong/article/details/52540902# 的博客(ps：个人认为递推式证明有错)，对于Burnside定理有了深入的了解。

Burnside定理 基本的叙述 参看 百度百科Burnside

尤其对于在应用中的例1，对于理解公式中各个参数的含义很有帮助

求出所有方案集合S，记为初始集合。

在S上有N（个数）种旋转方案，可以得到置换之后的Si，不动点的定义是，经过置换Ti后得到的Si中的某个方案和初始集合S中相对应的那个方案完全相同，那么这个点即为不动点。

Burnside引理的含义就是不动点的个数除以置换的个数，即平均每种置换有多少个不动点，就有多少个不同构的方案。

ans = ∑（每种置换中不动点的个数） / N;

①N种旋转（置换方式）有多少个不动点，经过置换Ti后不动，显然，对于所有的不动点都有一个共同性质它具有长度为 gcd（i，n） 的循环节 

那么 方案数是多少呢，很显然就是长度为gcd（i，n）的链有多少种配色方案

又因为链是组成这题中环的一部分，所以除了黑黑不能相邻之外还要满足一个别的条件那就是首尾不能同为黑

②长度为x的环不考虑同构有多少种方案，动态规划？递推式？ 有f[x] = f[x-1] + f[x-2]

显然有

f（2） = 3；（01，00,10）

f（3） = 4；（000,100,001,010）

推导过程讨论第x位放什么

①若放白色（0为白，1为黑），F_w[x] = F_w[x-1] + F2[x-1]

说明F2的含义为，F2[t]是长度为t，格式为10XXX01（对L=x-1来说是非法方案，但是这些串加上一个0之后，对于L=x是合法）的链的个数

②若放黑色，F_b[x] = F[x-2] - F3[x-2]

说明F3的含义为，F3[t]是长度为t，格式为10XXX0（对L = t 是合法的）的链的个数

显然观察F2和F3的定义，会发现F2[t] = F3[t-1]

==》 F[x] = F_w[x] + F_b[x] = F[x-1] + F[x-2]；

欧拉函数优化这个过程。百度百科欧拉函数 

 根据上面讨论，公式变为∑ (F( gcd(i,N) )) / N   (1<=i<=n)

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
struct mat
{
    long long a[4][4];
};
const long long mod=(1e9)+7;
mat operator *(mat A,mat B)
{
    mat C;
    memset(C.a,0,sizeof(C.a));
    for (int i = 1 ; i<=2; i++)
        for (int j = 1 ; j<=2 ; j++)
            for (int k = 1; k<=2; k++)
        C.a[i][j]= (C.a[i][j] + (A.a[i][k]*B.a[k][j]) % mod) % mod;
    return C;
}
mat ksm(mat A,long long t)
{
    mat ans;
    memset(ans.a,0,sizeof ans.a);
    ans.a[1][1] = 1;
    ans.a[2][2] = 1;
    while (t){
        if (t&1) ans = ans*A;
        A=A*A;
        t/=2;
    }
    return ans;
}
long long  inv(long long A)
{
    long long tans = 1;
    long long t = mod-2LL;
    while (t){
        if (t&1LL) tans = (tans*A) % mod;
        A=(A*A) % mod;
        t/=2LL;
    }
    return tans;
}
long long  eula (long long x)
{
    long long ans = x;
    for (long long i = 2; i*i <=x; i++){
        if (x%i==0){
            ans = ans-ans/i;
            while (x%i==0)x/=i;
        }
    }
    if (x!=1) ans = ans - ans/x;
    return ans;
}
long long F(long long i)
{
    if (i==1) return 1;
    if (i==2) return 3;
    mat A;
    memset(A.a,0,sizeof(A.a));
    A.a[2][1] = 1;
    A.a[2][2] = 1;
    A.a[1][2] = 1;
    A = ksm(A,i-2);
    return (A.a[1][2] + 3*A.a[2][2] % mod ) % mod;
}
int main()
{
    long long N = 0;
    while (cin >> N ){
        if (N==1) {puts("2");continue;}
        long long sans = 0;
        for (long long i = 1; i*i<=N; i++){
            if (N % i==0){
                sans= (sans + F(i) * eula(N/i) % mod ) % mod;
                if (i*i!=N) sans= (sans + F(N/i) * eula(i) % mod ) % mod;
            }
        }
        sans = ((sans * inv(N)) % mod);
        cout << sans <<endl;
    }
    return 0;
}